Function.cpp revision 477fc628b3c9ce1c970d4a678dd5607b15242cc8
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}; 459 460 461static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, 462 SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) { 463 IIT_Info Info = IIT_Info(Infos[NextElt++]); 464 unsigned StructElts = 2; 465 using namespace Intrinsic; 466 467 switch (Info) { 468 case IIT_Done: 469 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0)); 470 return; 471 case IIT_MMX: 472 OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0)); 473 return; 474 case IIT_METADATA: 475 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0)); 476 return; 477 case IIT_F16: 478 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0)); 479 return; 480 case IIT_F32: 481 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0)); 482 return; 483 case IIT_F64: 484 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0)); 485 return; 486 case IIT_I1: 487 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1)); 488 return; 489 case IIT_I8: 490 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8)); 491 return; 492 case IIT_I16: 493 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16)); 494 return; 495 case IIT_I32: 496 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32)); 497 return; 498 case IIT_I64: 499 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64)); 500 return; 501 case IIT_V1: 502 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1)); 503 DecodeIITType(NextElt, Infos, OutputTable); 504 return; 505 case IIT_V2: 506 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2)); 507 DecodeIITType(NextElt, Infos, OutputTable); 508 return; 509 case IIT_V4: 510 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4)); 511 DecodeIITType(NextElt, Infos, OutputTable); 512 return; 513 case IIT_V8: 514 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8)); 515 DecodeIITType(NextElt, Infos, OutputTable); 516 return; 517 case IIT_V16: 518 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16)); 519 DecodeIITType(NextElt, Infos, OutputTable); 520 return; 521 case IIT_V32: 522 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32)); 523 DecodeIITType(NextElt, Infos, OutputTable); 524 return; 525 case IIT_PTR: 526 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0)); 527 DecodeIITType(NextElt, Infos, OutputTable); 528 return; 529 case IIT_ANYPTR: { // [ANYPTR addrspace, subtype] 530 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 531 Infos[NextElt++])); 532 DecodeIITType(NextElt, Infos, OutputTable); 533 return; 534 } 535 case IIT_ARG: { 536 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 537 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo)); 538 return; 539 } 540 case IIT_EXTEND_VEC_ARG: { 541 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 542 OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendVecArgument, 543 ArgInfo)); 544 return; 545 } 546 case IIT_TRUNC_VEC_ARG: { 547 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 548 OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncVecArgument, 549 ArgInfo)); 550 return; 551 } 552 case IIT_EMPTYSTRUCT: 553 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0)); 554 return; 555 case IIT_STRUCT5: ++StructElts; // FALL THROUGH. 556 case IIT_STRUCT4: ++StructElts; // FALL THROUGH. 557 case IIT_STRUCT3: ++StructElts; // FALL THROUGH. 558 case IIT_STRUCT2: { 559 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts)); 560 561 for (unsigned i = 0; i != StructElts; ++i) 562 DecodeIITType(NextElt, Infos, OutputTable); 563 return; 564 } 565 } 566 llvm_unreachable("unhandled"); 567} 568 569 570#define GET_INTRINSIC_GENERATOR_GLOBAL 571#include "llvm/IR/Intrinsics.gen" 572#undef GET_INTRINSIC_GENERATOR_GLOBAL 573 574void Intrinsic::getIntrinsicInfoTableEntries(ID id, 575 SmallVectorImpl<IITDescriptor> &T){ 576 // Check to see if the intrinsic's type was expressible by the table. 577 unsigned TableVal = IIT_Table[id-1]; 578 579 // Decode the TableVal into an array of IITValues. 580 SmallVector<unsigned char, 8> IITValues; 581 ArrayRef<unsigned char> IITEntries; 582 unsigned NextElt = 0; 583 if ((TableVal >> 31) != 0) { 584 // This is an offset into the IIT_LongEncodingTable. 585 IITEntries = IIT_LongEncodingTable; 586 587 // Strip sentinel bit. 588 NextElt = (TableVal << 1) >> 1; 589 } else { 590 // Decode the TableVal into an array of IITValues. If the entry was encoded 591 // into a single word in the table itself, decode it now. 592 do { 593 IITValues.push_back(TableVal & 0xF); 594 TableVal >>= 4; 595 } while (TableVal); 596 597 IITEntries = IITValues; 598 NextElt = 0; 599 } 600 601 // Okay, decode the table into the output vector of IITDescriptors. 602 DecodeIITType(NextElt, IITEntries, T); 603 while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0) 604 DecodeIITType(NextElt, IITEntries, T); 605} 606 607 608static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos, 609 ArrayRef<Type*> Tys, LLVMContext &Context) { 610 using namespace Intrinsic; 611 IITDescriptor D = Infos.front(); 612 Infos = Infos.slice(1); 613 614 switch (D.Kind) { 615 case IITDescriptor::Void: return Type::getVoidTy(Context); 616 case IITDescriptor::MMX: return Type::getX86_MMXTy(Context); 617 case IITDescriptor::Metadata: return Type::getMetadataTy(Context); 618 case IITDescriptor::Half: return Type::getHalfTy(Context); 619 case IITDescriptor::Float: return Type::getFloatTy(Context); 620 case IITDescriptor::Double: return Type::getDoubleTy(Context); 621 622 case IITDescriptor::Integer: 623 return IntegerType::get(Context, D.Integer_Width); 624 case IITDescriptor::Vector: 625 return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width); 626 case IITDescriptor::Pointer: 627 return PointerType::get(DecodeFixedType(Infos, Tys, Context), 628 D.Pointer_AddressSpace); 629 case IITDescriptor::Struct: { 630 Type *Elts[5]; 631 assert(D.Struct_NumElements <= 5 && "Can't handle this yet"); 632 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 633 Elts[i] = DecodeFixedType(Infos, Tys, Context); 634 return StructType::get(Context, ArrayRef<Type*>(Elts,D.Struct_NumElements)); 635 } 636 637 case IITDescriptor::Argument: 638 return Tys[D.getArgumentNumber()]; 639 case IITDescriptor::ExtendVecArgument: 640 return VectorType::getExtendedElementVectorType(cast<VectorType>( 641 Tys[D.getArgumentNumber()])); 642 643 case IITDescriptor::TruncVecArgument: 644 return VectorType::getTruncatedElementVectorType(cast<VectorType>( 645 Tys[D.getArgumentNumber()])); 646 } 647 llvm_unreachable("unhandled"); 648} 649 650 651 652FunctionType *Intrinsic::getType(LLVMContext &Context, 653 ID id, ArrayRef<Type*> Tys) { 654 SmallVector<IITDescriptor, 8> Table; 655 getIntrinsicInfoTableEntries(id, Table); 656 657 ArrayRef<IITDescriptor> TableRef = Table; 658 Type *ResultTy = DecodeFixedType(TableRef, Tys, Context); 659 660 SmallVector<Type*, 8> ArgTys; 661 while (!TableRef.empty()) 662 ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context)); 663 664 return FunctionType::get(ResultTy, ArgTys, false); 665} 666 667bool Intrinsic::isOverloaded(ID id) { 668#define GET_INTRINSIC_OVERLOAD_TABLE 669#include "llvm/IR/Intrinsics.gen" 670#undef GET_INTRINSIC_OVERLOAD_TABLE 671} 672 673/// This defines the "Intrinsic::getAttributes(ID id)" method. 674#define GET_INTRINSIC_ATTRIBUTES 675#include "llvm/IR/Intrinsics.gen" 676#undef GET_INTRINSIC_ATTRIBUTES 677 678Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) { 679 // There can never be multiple globals with the same name of different types, 680 // because intrinsics must be a specific type. 681 return 682 cast<Function>(M->getOrInsertFunction(getName(id, Tys), 683 getType(M->getContext(), id, Tys))); 684} 685 686// This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method. 687#define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 688#include "llvm/IR/Intrinsics.gen" 689#undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 690 691/// hasAddressTaken - returns true if there are any uses of this function 692/// other than direct calls or invokes to it. 693bool Function::hasAddressTaken(const User* *PutOffender) const { 694 for (Value::const_use_iterator I = use_begin(), E = use_end(); I != E; ++I) { 695 const User *U = *I; 696 if (isa<BlockAddress>(U)) 697 continue; 698 if (!isa<CallInst>(U) && !isa<InvokeInst>(U)) 699 return PutOffender ? (*PutOffender = U, true) : true; 700 ImmutableCallSite CS(cast<Instruction>(U)); 701 if (!CS.isCallee(I)) 702 return PutOffender ? (*PutOffender = U, true) : true; 703 } 704 return false; 705} 706 707bool Function::isDefTriviallyDead() const { 708 // Check the linkage 709 if (!hasLinkOnceLinkage() && !hasLocalLinkage() && 710 !hasAvailableExternallyLinkage()) 711 return false; 712 713 // Check if the function is used by anything other than a blockaddress. 714 for (Value::const_use_iterator I = use_begin(), E = use_end(); I != E; ++I) 715 if (!isa<BlockAddress>(*I)) 716 return false; 717 718 return true; 719} 720 721/// callsFunctionThatReturnsTwice - Return true if the function has a call to 722/// setjmp or other function that gcc recognizes as "returning twice". 723bool Function::callsFunctionThatReturnsTwice() const { 724 for (const_inst_iterator 725 I = inst_begin(this), E = inst_end(this); I != E; ++I) { 726 const CallInst* callInst = dyn_cast<CallInst>(&*I); 727 if (!callInst) 728 continue; 729 if (callInst->canReturnTwice()) 730 return true; 731 } 732 733 return false; 734} 735 736Constant *Function::getPrefixData() const { 737 assert(hasPrefixData()); 738 const LLVMContextImpl::PrefixDataMapTy &PDMap = 739 getContext().pImpl->PrefixDataMap; 740 assert(PDMap.find(this) != PDMap.end()); 741 return cast<Constant>(PDMap.find(this)->second->getReturnValue()); 742} 743 744void Function::setPrefixData(Constant *PrefixData) { 745 if (!PrefixData && !hasPrefixData()) 746 return; 747 748 unsigned SCData = getSubclassDataFromValue(); 749 LLVMContextImpl::PrefixDataMapTy &PDMap = getContext().pImpl->PrefixDataMap; 750 ReturnInst *&PDHolder = PDMap[this]; 751 if (PrefixData) { 752 if (PDHolder) 753 PDHolder->setOperand(0, PrefixData); 754 else 755 PDHolder = ReturnInst::Create(getContext(), PrefixData); 756 SCData |= 2; 757 } else { 758 delete PDHolder; 759 PDMap.erase(this); 760 SCData &= ~2; 761 } 762 setValueSubclassData(SCData); 763} 764