Function.cpp revision 263508
1//===-- Function.cpp - Implement the Global object classes ----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Function class for the IR library. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/IR/Function.h" 15#include "LLVMContextImpl.h" 16#include "SymbolTableListTraitsImpl.h" 17#include "llvm/ADT/DenseMap.h" 18#include "llvm/ADT/STLExtras.h" 19#include "llvm/ADT/StringExtras.h" 20#include "llvm/CodeGen/ValueTypes.h" 21#include "llvm/IR/DerivedTypes.h" 22#include "llvm/IR/IntrinsicInst.h" 23#include "llvm/IR/LLVMContext.h" 24#include "llvm/IR/Module.h" 25#include "llvm/Support/CallSite.h" 26#include "llvm/Support/InstIterator.h" 27#include "llvm/Support/LeakDetector.h" 28#include "llvm/Support/ManagedStatic.h" 29#include "llvm/Support/RWMutex.h" 30#include "llvm/Support/StringPool.h" 31#include "llvm/Support/Threading.h" 32using namespace llvm; 33 34// Explicit instantiations of SymbolTableListTraits since some of the methods 35// are not in the public header file... 36template class llvm::SymbolTableListTraits<Argument, Function>; 37template class llvm::SymbolTableListTraits<BasicBlock, Function>; 38 39//===----------------------------------------------------------------------===// 40// Argument Implementation 41//===----------------------------------------------------------------------===// 42 43void Argument::anchor() { } 44 45Argument::Argument(Type *Ty, const Twine &Name, Function *Par) 46 : Value(Ty, Value::ArgumentVal) { 47 Parent = 0; 48 49 // Make sure that we get added to a function 50 LeakDetector::addGarbageObject(this); 51 52 if (Par) 53 Par->getArgumentList().push_back(this); 54 setName(Name); 55} 56 57void Argument::setParent(Function *parent) { 58 if (getParent()) 59 LeakDetector::addGarbageObject(this); 60 Parent = parent; 61 if (getParent()) 62 LeakDetector::removeGarbageObject(this); 63} 64 65/// getArgNo - Return the index of this formal argument in its containing 66/// function. For example in "void foo(int a, float b)" a is 0 and b is 1. 67unsigned Argument::getArgNo() const { 68 const Function *F = getParent(); 69 assert(F && "Argument is not in a function"); 70 71 Function::const_arg_iterator AI = F->arg_begin(); 72 unsigned ArgIdx = 0; 73 for (; &*AI != this; ++AI) 74 ++ArgIdx; 75 76 return ArgIdx; 77} 78 79/// hasByValAttr - Return true if this argument has the byval attribute on it 80/// in its containing function. 81bool Argument::hasByValAttr() const { 82 if (!getType()->isPointerTy()) return false; 83 return getParent()->getAttributes(). 84 hasAttribute(getArgNo()+1, Attribute::ByVal); 85} 86 87unsigned Argument::getParamAlignment() const { 88 assert(getType()->isPointerTy() && "Only pointers have alignments"); 89 return getParent()->getParamAlignment(getArgNo()+1); 90 91} 92 93/// hasNestAttr - Return true if this argument has the nest attribute on 94/// it in its containing function. 95bool Argument::hasNestAttr() const { 96 if (!getType()->isPointerTy()) return false; 97 return getParent()->getAttributes(). 98 hasAttribute(getArgNo()+1, Attribute::Nest); 99} 100 101/// hasNoAliasAttr - Return true if this argument has the noalias attribute on 102/// it in its containing function. 103bool Argument::hasNoAliasAttr() const { 104 if (!getType()->isPointerTy()) return false; 105 return getParent()->getAttributes(). 106 hasAttribute(getArgNo()+1, Attribute::NoAlias); 107} 108 109/// hasNoCaptureAttr - Return true if this argument has the nocapture attribute 110/// on it in its containing function. 111bool Argument::hasNoCaptureAttr() const { 112 if (!getType()->isPointerTy()) return false; 113 return getParent()->getAttributes(). 114 hasAttribute(getArgNo()+1, Attribute::NoCapture); 115} 116 117/// hasSRetAttr - Return true if this argument has the sret attribute on 118/// it in its containing function. 119bool Argument::hasStructRetAttr() const { 120 if (!getType()->isPointerTy()) return false; 121 if (this != getParent()->arg_begin()) 122 return false; // StructRet param must be first param 123 return getParent()->getAttributes(). 124 hasAttribute(1, Attribute::StructRet); 125} 126 127/// hasReturnedAttr - Return true if this argument has the returned attribute on 128/// it in its containing function. 129bool Argument::hasReturnedAttr() const { 130 return getParent()->getAttributes(). 131 hasAttribute(getArgNo()+1, Attribute::Returned); 132} 133 134/// Return true if this argument has the readonly or readnone attribute on it 135/// in its containing function. 136bool Argument::onlyReadsMemory() const { 137 return getParent()->getAttributes(). 138 hasAttribute(getArgNo()+1, Attribute::ReadOnly) || 139 getParent()->getAttributes(). 140 hasAttribute(getArgNo()+1, Attribute::ReadNone); 141} 142 143/// addAttr - Add attributes to an argument. 144void Argument::addAttr(AttributeSet AS) { 145 assert(AS.getNumSlots() <= 1 && 146 "Trying to add more than one attribute set to an argument!"); 147 AttrBuilder B(AS, AS.getSlotIndex(0)); 148 getParent()->addAttributes(getArgNo() + 1, 149 AttributeSet::get(Parent->getContext(), 150 getArgNo() + 1, B)); 151} 152 153/// removeAttr - Remove attributes from an argument. 154void Argument::removeAttr(AttributeSet AS) { 155 assert(AS.getNumSlots() <= 1 && 156 "Trying to remove more than one attribute set from an argument!"); 157 AttrBuilder B(AS, AS.getSlotIndex(0)); 158 getParent()->removeAttributes(getArgNo() + 1, 159 AttributeSet::get(Parent->getContext(), 160 getArgNo() + 1, B)); 161} 162 163//===----------------------------------------------------------------------===// 164// Helper Methods in Function 165//===----------------------------------------------------------------------===// 166 167LLVMContext &Function::getContext() const { 168 return getType()->getContext(); 169} 170 171FunctionType *Function::getFunctionType() const { 172 return cast<FunctionType>(getType()->getElementType()); 173} 174 175bool Function::isVarArg() const { 176 return getFunctionType()->isVarArg(); 177} 178 179Type *Function::getReturnType() const { 180 return getFunctionType()->getReturnType(); 181} 182 183void Function::removeFromParent() { 184 getParent()->getFunctionList().remove(this); 185} 186 187void Function::eraseFromParent() { 188 getParent()->getFunctionList().erase(this); 189} 190 191//===----------------------------------------------------------------------===// 192// Function Implementation 193//===----------------------------------------------------------------------===// 194 195Function::Function(FunctionType *Ty, LinkageTypes Linkage, 196 const Twine &name, Module *ParentModule) 197 : GlobalValue(PointerType::getUnqual(Ty), 198 Value::FunctionVal, 0, 0, Linkage, name) { 199 assert(FunctionType::isValidReturnType(getReturnType()) && 200 "invalid return type"); 201 SymTab = new ValueSymbolTable(); 202 203 // If the function has arguments, mark them as lazily built. 204 if (Ty->getNumParams()) 205 setValueSubclassData(1); // Set the "has lazy arguments" bit. 206 207 // Make sure that we get added to a function 208 LeakDetector::addGarbageObject(this); 209 210 if (ParentModule) 211 ParentModule->getFunctionList().push_back(this); 212 213 // Ensure intrinsics have the right parameter attributes. 214 if (unsigned IID = getIntrinsicID()) 215 setAttributes(Intrinsic::getAttributes(getContext(), Intrinsic::ID(IID))); 216 217} 218 219Function::~Function() { 220 dropAllReferences(); // After this it is safe to delete instructions. 221 222 // Delete all of the method arguments and unlink from symbol table... 223 ArgumentList.clear(); 224 delete SymTab; 225 226 // Remove the function from the on-the-side GC table. 227 clearGC(); 228 229 // Remove the intrinsicID from the Cache. 230 if (getValueName() && isIntrinsic()) 231 getContext().pImpl->IntrinsicIDCache.erase(this); 232} 233 234void Function::BuildLazyArguments() const { 235 // Create the arguments vector, all arguments start out unnamed. 236 FunctionType *FT = getFunctionType(); 237 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 238 assert(!FT->getParamType(i)->isVoidTy() && 239 "Cannot have void typed arguments!"); 240 ArgumentList.push_back(new Argument(FT->getParamType(i))); 241 } 242 243 // Clear the lazy arguments bit. 244 unsigned SDC = getSubclassDataFromValue(); 245 const_cast<Function*>(this)->setValueSubclassData(SDC &= ~1); 246} 247 248size_t Function::arg_size() const { 249 return getFunctionType()->getNumParams(); 250} 251bool Function::arg_empty() const { 252 return getFunctionType()->getNumParams() == 0; 253} 254 255void Function::setParent(Module *parent) { 256 if (getParent()) 257 LeakDetector::addGarbageObject(this); 258 Parent = parent; 259 if (getParent()) 260 LeakDetector::removeGarbageObject(this); 261} 262 263// dropAllReferences() - This function causes all the subinstructions to "let 264// go" of all references that they are maintaining. This allows one to 265// 'delete' a whole class at a time, even though there may be circular 266// references... first all references are dropped, and all use counts go to 267// zero. Then everything is deleted for real. Note that no operations are 268// valid on an object that has "dropped all references", except operator 269// delete. 270// 271void Function::dropAllReferences() { 272 for (iterator I = begin(), E = end(); I != E; ++I) 273 I->dropAllReferences(); 274 275 // Delete all basic blocks. They are now unused, except possibly by 276 // blockaddresses, but BasicBlock's destructor takes care of those. 277 while (!BasicBlocks.empty()) 278 BasicBlocks.begin()->eraseFromParent(); 279 280 // Prefix data is stored in a side table. 281 setPrefixData(0); 282} 283 284void Function::addAttribute(unsigned i, Attribute::AttrKind attr) { 285 AttributeSet PAL = getAttributes(); 286 PAL = PAL.addAttribute(getContext(), i, attr); 287 setAttributes(PAL); 288} 289 290void Function::addAttributes(unsigned i, AttributeSet attrs) { 291 AttributeSet PAL = getAttributes(); 292 PAL = PAL.addAttributes(getContext(), i, attrs); 293 setAttributes(PAL); 294} 295 296void Function::removeAttributes(unsigned i, AttributeSet attrs) { 297 AttributeSet PAL = getAttributes(); 298 PAL = PAL.removeAttributes(getContext(), i, attrs); 299 setAttributes(PAL); 300} 301 302// Maintain the GC name for each function in an on-the-side table. This saves 303// allocating an additional word in Function for programs which do not use GC 304// (i.e., most programs) at the cost of increased overhead for clients which do 305// use GC. 306static DenseMap<const Function*,PooledStringPtr> *GCNames; 307static StringPool *GCNamePool; 308static ManagedStatic<sys::SmartRWMutex<true> > GCLock; 309 310bool Function::hasGC() const { 311 sys::SmartScopedReader<true> Reader(*GCLock); 312 return GCNames && GCNames->count(this); 313} 314 315const char *Function::getGC() const { 316 assert(hasGC() && "Function has no collector"); 317 sys::SmartScopedReader<true> Reader(*GCLock); 318 return *(*GCNames)[this]; 319} 320 321void Function::setGC(const char *Str) { 322 sys::SmartScopedWriter<true> Writer(*GCLock); 323 if (!GCNamePool) 324 GCNamePool = new StringPool(); 325 if (!GCNames) 326 GCNames = new DenseMap<const Function*,PooledStringPtr>(); 327 (*GCNames)[this] = GCNamePool->intern(Str); 328} 329 330void Function::clearGC() { 331 sys::SmartScopedWriter<true> Writer(*GCLock); 332 if (GCNames) { 333 GCNames->erase(this); 334 if (GCNames->empty()) { 335 delete GCNames; 336 GCNames = 0; 337 if (GCNamePool->empty()) { 338 delete GCNamePool; 339 GCNamePool = 0; 340 } 341 } 342 } 343} 344 345/// copyAttributesFrom - copy all additional attributes (those not needed to 346/// create a Function) from the Function Src to this one. 347void Function::copyAttributesFrom(const GlobalValue *Src) { 348 assert(isa<Function>(Src) && "Expected a Function!"); 349 GlobalValue::copyAttributesFrom(Src); 350 const Function *SrcF = cast<Function>(Src); 351 setCallingConv(SrcF->getCallingConv()); 352 setAttributes(SrcF->getAttributes()); 353 if (SrcF->hasGC()) 354 setGC(SrcF->getGC()); 355 else 356 clearGC(); 357 if (SrcF->hasPrefixData()) 358 setPrefixData(SrcF->getPrefixData()); 359 else 360 setPrefixData(0); 361} 362 363/// getIntrinsicID - This method returns the ID number of the specified 364/// function, or Intrinsic::not_intrinsic if the function is not an 365/// intrinsic, or if the pointer is null. This value is always defined to be 366/// zero to allow easy checking for whether a function is intrinsic or not. The 367/// particular intrinsic functions which correspond to this value are defined in 368/// llvm/Intrinsics.h. Results are cached in the LLVM context, subsequent 369/// requests for the same ID return results much faster from the cache. 370/// 371unsigned Function::getIntrinsicID() const { 372 const ValueName *ValName = this->getValueName(); 373 if (!ValName || !isIntrinsic()) 374 return 0; 375 376 LLVMContextImpl::IntrinsicIDCacheTy &IntrinsicIDCache = 377 getContext().pImpl->IntrinsicIDCache; 378 if (!IntrinsicIDCache.count(this)) { 379 unsigned Id = lookupIntrinsicID(); 380 IntrinsicIDCache[this]=Id; 381 return Id; 382 } 383 return IntrinsicIDCache[this]; 384} 385 386/// This private method does the actual lookup of an intrinsic ID when the query 387/// could not be answered from the cache. 388unsigned Function::lookupIntrinsicID() const { 389 const ValueName *ValName = this->getValueName(); 390 unsigned Len = ValName->getKeyLength(); 391 const char *Name = ValName->getKeyData(); 392 393#define GET_FUNCTION_RECOGNIZER 394#include "llvm/IR/Intrinsics.gen" 395#undef GET_FUNCTION_RECOGNIZER 396 397 return 0; 398} 399 400std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) { 401 assert(id < num_intrinsics && "Invalid intrinsic ID!"); 402 static const char * const Table[] = { 403 "not_intrinsic", 404#define GET_INTRINSIC_NAME_TABLE 405#include "llvm/IR/Intrinsics.gen" 406#undef GET_INTRINSIC_NAME_TABLE 407 }; 408 if (Tys.empty()) 409 return Table[id]; 410 std::string Result(Table[id]); 411 for (unsigned i = 0; i < Tys.size(); ++i) { 412 if (PointerType* PTyp = dyn_cast<PointerType>(Tys[i])) { 413 Result += ".p" + llvm::utostr(PTyp->getAddressSpace()) + 414 EVT::getEVT(PTyp->getElementType()).getEVTString(); 415 } 416 else if (Tys[i]) 417 Result += "." + EVT::getEVT(Tys[i]).getEVTString(); 418 } 419 return Result; 420} 421 422 423/// IIT_Info - These are enumerators that describe the entries returned by the 424/// getIntrinsicInfoTableEntries function. 425/// 426/// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter! 427enum IIT_Info { 428 // Common values should be encoded with 0-15. 429 IIT_Done = 0, 430 IIT_I1 = 1, 431 IIT_I8 = 2, 432 IIT_I16 = 3, 433 IIT_I32 = 4, 434 IIT_I64 = 5, 435 IIT_F16 = 6, 436 IIT_F32 = 7, 437 IIT_F64 = 8, 438 IIT_V2 = 9, 439 IIT_V4 = 10, 440 IIT_V8 = 11, 441 IIT_V16 = 12, 442 IIT_V32 = 13, 443 IIT_PTR = 14, 444 IIT_ARG = 15, 445 446 // Values from 16+ are only encodable with the inefficient encoding. 447 IIT_MMX = 16, 448 IIT_METADATA = 17, 449 IIT_EMPTYSTRUCT = 18, 450 IIT_STRUCT2 = 19, 451 IIT_STRUCT3 = 20, 452 IIT_STRUCT4 = 21, 453 IIT_STRUCT5 = 22, 454 IIT_EXTEND_VEC_ARG = 23, 455 IIT_TRUNC_VEC_ARG = 24, 456 IIT_ANYPTR = 25, 457 IIT_V1 = 26, 458 IIT_VARARG = 27 459}; 460 461 462static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, 463 SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) { 464 IIT_Info Info = IIT_Info(Infos[NextElt++]); 465 unsigned StructElts = 2; 466 using namespace Intrinsic; 467 468 switch (Info) { 469 case IIT_Done: 470 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0)); 471 return; 472 case IIT_VARARG: 473 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0)); 474 return; 475 case IIT_MMX: 476 OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0)); 477 return; 478 case IIT_METADATA: 479 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0)); 480 return; 481 case IIT_F16: 482 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0)); 483 return; 484 case IIT_F32: 485 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0)); 486 return; 487 case IIT_F64: 488 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0)); 489 return; 490 case IIT_I1: 491 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1)); 492 return; 493 case IIT_I8: 494 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8)); 495 return; 496 case IIT_I16: 497 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16)); 498 return; 499 case IIT_I32: 500 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32)); 501 return; 502 case IIT_I64: 503 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64)); 504 return; 505 case IIT_V1: 506 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1)); 507 DecodeIITType(NextElt, Infos, OutputTable); 508 return; 509 case IIT_V2: 510 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2)); 511 DecodeIITType(NextElt, Infos, OutputTable); 512 return; 513 case IIT_V4: 514 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4)); 515 DecodeIITType(NextElt, Infos, OutputTable); 516 return; 517 case IIT_V8: 518 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8)); 519 DecodeIITType(NextElt, Infos, OutputTable); 520 return; 521 case IIT_V16: 522 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16)); 523 DecodeIITType(NextElt, Infos, OutputTable); 524 return; 525 case IIT_V32: 526 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32)); 527 DecodeIITType(NextElt, Infos, OutputTable); 528 return; 529 case IIT_PTR: 530 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0)); 531 DecodeIITType(NextElt, Infos, OutputTable); 532 return; 533 case IIT_ANYPTR: { // [ANYPTR addrspace, subtype] 534 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 535 Infos[NextElt++])); 536 DecodeIITType(NextElt, Infos, OutputTable); 537 return; 538 } 539 case IIT_ARG: { 540 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 541 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo)); 542 return; 543 } 544 case IIT_EXTEND_VEC_ARG: { 545 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 546 OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendVecArgument, 547 ArgInfo)); 548 return; 549 } 550 case IIT_TRUNC_VEC_ARG: { 551 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 552 OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncVecArgument, 553 ArgInfo)); 554 return; 555 } 556 case IIT_EMPTYSTRUCT: 557 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0)); 558 return; 559 case IIT_STRUCT5: ++StructElts; // FALL THROUGH. 560 case IIT_STRUCT4: ++StructElts; // FALL THROUGH. 561 case IIT_STRUCT3: ++StructElts; // FALL THROUGH. 562 case IIT_STRUCT2: { 563 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts)); 564 565 for (unsigned i = 0; i != StructElts; ++i) 566 DecodeIITType(NextElt, Infos, OutputTable); 567 return; 568 } 569 } 570 llvm_unreachable("unhandled"); 571} 572 573 574#define GET_INTRINSIC_GENERATOR_GLOBAL 575#include "llvm/IR/Intrinsics.gen" 576#undef GET_INTRINSIC_GENERATOR_GLOBAL 577 578void Intrinsic::getIntrinsicInfoTableEntries(ID id, 579 SmallVectorImpl<IITDescriptor> &T){ 580 // Check to see if the intrinsic's type was expressible by the table. 581 unsigned TableVal = IIT_Table[id-1]; 582 583 // Decode the TableVal into an array of IITValues. 584 SmallVector<unsigned char, 8> IITValues; 585 ArrayRef<unsigned char> IITEntries; 586 unsigned NextElt = 0; 587 if ((TableVal >> 31) != 0) { 588 // This is an offset into the IIT_LongEncodingTable. 589 IITEntries = IIT_LongEncodingTable; 590 591 // Strip sentinel bit. 592 NextElt = (TableVal << 1) >> 1; 593 } else { 594 // Decode the TableVal into an array of IITValues. If the entry was encoded 595 // into a single word in the table itself, decode it now. 596 do { 597 IITValues.push_back(TableVal & 0xF); 598 TableVal >>= 4; 599 } while (TableVal); 600 601 IITEntries = IITValues; 602 NextElt = 0; 603 } 604 605 // Okay, decode the table into the output vector of IITDescriptors. 606 DecodeIITType(NextElt, IITEntries, T); 607 while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0) 608 DecodeIITType(NextElt, IITEntries, T); 609} 610 611 612static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos, 613 ArrayRef<Type*> Tys, LLVMContext &Context) { 614 using namespace Intrinsic; 615 IITDescriptor D = Infos.front(); 616 Infos = Infos.slice(1); 617 618 switch (D.Kind) { 619 case IITDescriptor::Void: return Type::getVoidTy(Context); 620 case IITDescriptor::VarArg: return Type::getVoidTy(Context); 621 case IITDescriptor::MMX: return Type::getX86_MMXTy(Context); 622 case IITDescriptor::Metadata: return Type::getMetadataTy(Context); 623 case IITDescriptor::Half: return Type::getHalfTy(Context); 624 case IITDescriptor::Float: return Type::getFloatTy(Context); 625 case IITDescriptor::Double: return Type::getDoubleTy(Context); 626 627 case IITDescriptor::Integer: 628 return IntegerType::get(Context, D.Integer_Width); 629 case IITDescriptor::Vector: 630 return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width); 631 case IITDescriptor::Pointer: 632 return PointerType::get(DecodeFixedType(Infos, Tys, Context), 633 D.Pointer_AddressSpace); 634 case IITDescriptor::Struct: { 635 Type *Elts[5]; 636 assert(D.Struct_NumElements <= 5 && "Can't handle this yet"); 637 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 638 Elts[i] = DecodeFixedType(Infos, Tys, Context); 639 return StructType::get(Context, ArrayRef<Type*>(Elts,D.Struct_NumElements)); 640 } 641 642 case IITDescriptor::Argument: 643 return Tys[D.getArgumentNumber()]; 644 case IITDescriptor::ExtendVecArgument: 645 return VectorType::getExtendedElementVectorType(cast<VectorType>( 646 Tys[D.getArgumentNumber()])); 647 648 case IITDescriptor::TruncVecArgument: 649 return VectorType::getTruncatedElementVectorType(cast<VectorType>( 650 Tys[D.getArgumentNumber()])); 651 } 652 llvm_unreachable("unhandled"); 653} 654 655 656 657FunctionType *Intrinsic::getType(LLVMContext &Context, 658 ID id, ArrayRef<Type*> Tys) { 659 SmallVector<IITDescriptor, 8> Table; 660 getIntrinsicInfoTableEntries(id, Table); 661 662 ArrayRef<IITDescriptor> TableRef = Table; 663 Type *ResultTy = DecodeFixedType(TableRef, Tys, Context); 664 665 SmallVector<Type*, 8> ArgTys; 666 while (!TableRef.empty()) 667 ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context)); 668 669 return FunctionType::get(ResultTy, ArgTys, false); 670} 671 672bool Intrinsic::isOverloaded(ID id) { 673#define GET_INTRINSIC_OVERLOAD_TABLE 674#include "llvm/IR/Intrinsics.gen" 675#undef GET_INTRINSIC_OVERLOAD_TABLE 676} 677 678/// This defines the "Intrinsic::getAttributes(ID id)" method. 679#define GET_INTRINSIC_ATTRIBUTES 680#include "llvm/IR/Intrinsics.gen" 681#undef GET_INTRINSIC_ATTRIBUTES 682 683Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) { 684 // There can never be multiple globals with the same name of different types, 685 // because intrinsics must be a specific type. 686 return 687 cast<Function>(M->getOrInsertFunction(getName(id, Tys), 688 getType(M->getContext(), id, Tys))); 689} 690 691// This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method. 692#define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 693#include "llvm/IR/Intrinsics.gen" 694#undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 695 696/// hasAddressTaken - returns true if there are any uses of this function 697/// other than direct calls or invokes to it. 698bool Function::hasAddressTaken(const User* *PutOffender) const { 699 for (Value::const_use_iterator I = use_begin(), E = use_end(); I != E; ++I) { 700 const User *U = *I; 701 if (isa<BlockAddress>(U)) 702 continue; 703 if (!isa<CallInst>(U) && !isa<InvokeInst>(U)) 704 return PutOffender ? (*PutOffender = U, true) : true; 705 ImmutableCallSite CS(cast<Instruction>(U)); 706 if (!CS.isCallee(I)) 707 return PutOffender ? (*PutOffender = U, true) : true; 708 } 709 return false; 710} 711 712bool Function::isDefTriviallyDead() const { 713 // Check the linkage 714 if (!hasLinkOnceLinkage() && !hasLocalLinkage() && 715 !hasAvailableExternallyLinkage()) 716 return false; 717 718 // Check if the function is used by anything other than a blockaddress. 719 for (Value::const_use_iterator I = use_begin(), E = use_end(); I != E; ++I) 720 if (!isa<BlockAddress>(*I)) 721 return false; 722 723 return true; 724} 725 726/// callsFunctionThatReturnsTwice - Return true if the function has a call to 727/// setjmp or other function that gcc recognizes as "returning twice". 728bool Function::callsFunctionThatReturnsTwice() const { 729 for (const_inst_iterator 730 I = inst_begin(this), E = inst_end(this); I != E; ++I) { 731 const CallInst* callInst = dyn_cast<CallInst>(&*I); 732 if (!callInst) 733 continue; 734 if (callInst->canReturnTwice()) 735 return true; 736 } 737 738 return false; 739} 740 741Constant *Function::getPrefixData() const { 742 assert(hasPrefixData()); 743 const LLVMContextImpl::PrefixDataMapTy &PDMap = 744 getContext().pImpl->PrefixDataMap; 745 assert(PDMap.find(this) != PDMap.end()); 746 return cast<Constant>(PDMap.find(this)->second->getReturnValue()); 747} 748 749void Function::setPrefixData(Constant *PrefixData) { 750 if (!PrefixData && !hasPrefixData()) 751 return; 752 753 unsigned SCData = getSubclassDataFromValue(); 754 LLVMContextImpl::PrefixDataMapTy &PDMap = getContext().pImpl->PrefixDataMap; 755 ReturnInst *&PDHolder = PDMap[this]; 756 if (PrefixData) { 757 if (PDHolder) 758 PDHolder->setOperand(0, PrefixData); 759 else 760 PDHolder = ReturnInst::Create(getContext(), PrefixData); 761 SCData |= 2; 762 } else { 763 delete PDHolder; 764 PDMap.erase(this); 765 SCData &= ~2; 766 } 767 setValueSubclassData(SCData); 768} 769