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/CallSite.h" 22 #include "llvm/IR/DerivedTypes.h" 23 #include "llvm/IR/InstIterator.h" 24 #include "llvm/IR/IntrinsicInst.h" 25 #include "llvm/IR/LLVMContext.h" 26 #include "llvm/IR/Module.h" 27 #include "llvm/Support/ManagedStatic.h" 28 #include "llvm/Support/RWMutex.h" 29 #include "llvm/Support/StringPool.h" 30 #include "llvm/Support/Threading.h" 31 using namespace llvm; 32 33 // Explicit instantiations of SymbolTableListTraits since some of the methods 34 // are not in the public header file... 35 template class llvm::SymbolTableListTraits<Argument, Function>; 36 template class llvm::SymbolTableListTraits<BasicBlock, Function>; 37 38 //===----------------------------------------------------------------------===// 39 // Argument Implementation 40 //===----------------------------------------------------------------------===// 41 42 void Argument::anchor() { } 43 44 Argument::Argument(Type *Ty, const Twine &Name, Function *Par) 45 : Value(Ty, Value::ArgumentVal) { 46 Parent = nullptr; 47 48 if (Par) 49 Par->getArgumentList().push_back(this); 50 setName(Name); 51 } 52 53 void Argument::setParent(Function *parent) { 54 Parent = parent; 55 } 56 57 /// getArgNo - Return the index of this formal argument in its containing 58 /// function. For example in "void foo(int a, float b)" a is 0 and b is 1. 59 unsigned Argument::getArgNo() const { 60 const Function *F = getParent(); 61 assert(F && "Argument is not in a function"); 62 63 Function::const_arg_iterator AI = F->arg_begin(); 64 unsigned ArgIdx = 0; 65 for (; &*AI != this; ++AI) 66 ++ArgIdx; 67 68 return ArgIdx; 69 } 70 71 /// hasNonNullAttr - Return true if this argument has the nonnull attribute on 72 /// it in its containing function. Also returns true if at least one byte is 73 /// known to be dereferenceable and the pointer is in addrspace(0). 74 bool Argument::hasNonNullAttr() const { 75 if (!getType()->isPointerTy()) return false; 76 if (getParent()->getAttributes(). 77 hasAttribute(getArgNo()+1, Attribute::NonNull)) 78 return true; 79 else if (getDereferenceableBytes() > 0 && 80 getType()->getPointerAddressSpace() == 0) 81 return true; 82 return false; 83 } 84 85 /// hasByValAttr - Return true if this argument has the byval attribute on it 86 /// in its containing function. 87 bool Argument::hasByValAttr() const { 88 if (!getType()->isPointerTy()) return false; 89 return getParent()->getAttributes(). 90 hasAttribute(getArgNo()+1, Attribute::ByVal); 91 } 92 93 /// \brief Return true if this argument has the inalloca attribute on it in 94 /// its containing function. 95 bool Argument::hasInAllocaAttr() const { 96 if (!getType()->isPointerTy()) return false; 97 return getParent()->getAttributes(). 98 hasAttribute(getArgNo()+1, Attribute::InAlloca); 99 } 100 101 bool Argument::hasByValOrInAllocaAttr() const { 102 if (!getType()->isPointerTy()) return false; 103 AttributeSet Attrs = getParent()->getAttributes(); 104 return Attrs.hasAttribute(getArgNo() + 1, Attribute::ByVal) || 105 Attrs.hasAttribute(getArgNo() + 1, Attribute::InAlloca); 106 } 107 108 unsigned Argument::getParamAlignment() const { 109 assert(getType()->isPointerTy() && "Only pointers have alignments"); 110 return getParent()->getParamAlignment(getArgNo()+1); 111 112 } 113 114 uint64_t Argument::getDereferenceableBytes() const { 115 assert(getType()->isPointerTy() && 116 "Only pointers have dereferenceable bytes"); 117 return getParent()->getDereferenceableBytes(getArgNo()+1); 118 } 119 120 /// hasNestAttr - Return true if this argument has the nest attribute on 121 /// it in its containing function. 122 bool Argument::hasNestAttr() const { 123 if (!getType()->isPointerTy()) return false; 124 return getParent()->getAttributes(). 125 hasAttribute(getArgNo()+1, Attribute::Nest); 126 } 127 128 /// hasNoAliasAttr - Return true if this argument has the noalias attribute on 129 /// it in its containing function. 130 bool Argument::hasNoAliasAttr() const { 131 if (!getType()->isPointerTy()) return false; 132 return getParent()->getAttributes(). 133 hasAttribute(getArgNo()+1, Attribute::NoAlias); 134 } 135 136 /// hasNoCaptureAttr - Return true if this argument has the nocapture attribute 137 /// on it in its containing function. 138 bool Argument::hasNoCaptureAttr() const { 139 if (!getType()->isPointerTy()) return false; 140 return getParent()->getAttributes(). 141 hasAttribute(getArgNo()+1, Attribute::NoCapture); 142 } 143 144 /// hasSRetAttr - Return true if this argument has the sret attribute on 145 /// it in its containing function. 146 bool Argument::hasStructRetAttr() const { 147 if (!getType()->isPointerTy()) return false; 148 if (this != getParent()->arg_begin()) 149 return false; // StructRet param must be first param 150 return getParent()->getAttributes(). 151 hasAttribute(1, Attribute::StructRet); 152 } 153 154 /// hasReturnedAttr - Return true if this argument has the returned attribute on 155 /// it in its containing function. 156 bool Argument::hasReturnedAttr() const { 157 return getParent()->getAttributes(). 158 hasAttribute(getArgNo()+1, Attribute::Returned); 159 } 160 161 /// hasZExtAttr - Return true if this argument has the zext attribute on it in 162 /// its containing function. 163 bool Argument::hasZExtAttr() const { 164 return getParent()->getAttributes(). 165 hasAttribute(getArgNo()+1, Attribute::ZExt); 166 } 167 168 /// hasSExtAttr Return true if this argument has the sext attribute on it in its 169 /// containing function. 170 bool Argument::hasSExtAttr() const { 171 return getParent()->getAttributes(). 172 hasAttribute(getArgNo()+1, Attribute::SExt); 173 } 174 175 /// Return true if this argument has the readonly or readnone attribute on it 176 /// in its containing function. 177 bool Argument::onlyReadsMemory() const { 178 return getParent()->getAttributes(). 179 hasAttribute(getArgNo()+1, Attribute::ReadOnly) || 180 getParent()->getAttributes(). 181 hasAttribute(getArgNo()+1, Attribute::ReadNone); 182 } 183 184 /// addAttr - Add attributes to an argument. 185 void Argument::addAttr(AttributeSet AS) { 186 assert(AS.getNumSlots() <= 1 && 187 "Trying to add more than one attribute set to an argument!"); 188 AttrBuilder B(AS, AS.getSlotIndex(0)); 189 getParent()->addAttributes(getArgNo() + 1, 190 AttributeSet::get(Parent->getContext(), 191 getArgNo() + 1, B)); 192 } 193 194 /// removeAttr - Remove attributes from an argument. 195 void Argument::removeAttr(AttributeSet AS) { 196 assert(AS.getNumSlots() <= 1 && 197 "Trying to remove more than one attribute set from an argument!"); 198 AttrBuilder B(AS, AS.getSlotIndex(0)); 199 getParent()->removeAttributes(getArgNo() + 1, 200 AttributeSet::get(Parent->getContext(), 201 getArgNo() + 1, B)); 202 } 203 204 //===----------------------------------------------------------------------===// 205 // Helper Methods in Function 206 //===----------------------------------------------------------------------===// 207 208 bool Function::isMaterializable() const { 209 return getGlobalObjectSubClassData(); 210 } 211 212 void Function::setIsMaterializable(bool V) { setGlobalObjectSubClassData(V); } 213 214 LLVMContext &Function::getContext() const { 215 return getType()->getContext(); 216 } 217 218 FunctionType *Function::getFunctionType() const { 219 return cast<FunctionType>(getType()->getElementType()); 220 } 221 222 bool Function::isVarArg() const { 223 return getFunctionType()->isVarArg(); 224 } 225 226 Type *Function::getReturnType() const { 227 return getFunctionType()->getReturnType(); 228 } 229 230 void Function::removeFromParent() { 231 getParent()->getFunctionList().remove(this); 232 } 233 234 void Function::eraseFromParent() { 235 getParent()->getFunctionList().erase(this); 236 } 237 238 //===----------------------------------------------------------------------===// 239 // Function Implementation 240 //===----------------------------------------------------------------------===// 241 242 Function::Function(FunctionType *Ty, LinkageTypes Linkage, const Twine &name, 243 Module *ParentModule) 244 : GlobalObject(PointerType::getUnqual(Ty), Value::FunctionVal, nullptr, 0, 245 Linkage, name) { 246 assert(FunctionType::isValidReturnType(getReturnType()) && 247 "invalid return type"); 248 setIsMaterializable(false); 249 SymTab = new ValueSymbolTable(); 250 251 // If the function has arguments, mark them as lazily built. 252 if (Ty->getNumParams()) 253 setValueSubclassData(1); // Set the "has lazy arguments" bit. 254 255 if (ParentModule) 256 ParentModule->getFunctionList().push_back(this); 257 258 // Ensure intrinsics have the right parameter attributes. 259 if (unsigned IID = getIntrinsicID()) 260 setAttributes(Intrinsic::getAttributes(getContext(), Intrinsic::ID(IID))); 261 262 } 263 264 Function::~Function() { 265 dropAllReferences(); // After this it is safe to delete instructions. 266 267 // Delete all of the method arguments and unlink from symbol table... 268 ArgumentList.clear(); 269 delete SymTab; 270 271 // Remove the function from the on-the-side GC table. 272 clearGC(); 273 274 // Remove the intrinsicID from the Cache. 275 if (getValueName() && isIntrinsic()) 276 getContext().pImpl->IntrinsicIDCache.erase(this); 277 } 278 279 void Function::BuildLazyArguments() const { 280 // Create the arguments vector, all arguments start out unnamed. 281 FunctionType *FT = getFunctionType(); 282 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 283 assert(!FT->getParamType(i)->isVoidTy() && 284 "Cannot have void typed arguments!"); 285 ArgumentList.push_back(new Argument(FT->getParamType(i))); 286 } 287 288 // Clear the lazy arguments bit. 289 unsigned SDC = getSubclassDataFromValue(); 290 const_cast<Function*>(this)->setValueSubclassData(SDC &= ~(1<<0)); 291 } 292 293 size_t Function::arg_size() const { 294 return getFunctionType()->getNumParams(); 295 } 296 bool Function::arg_empty() const { 297 return getFunctionType()->getNumParams() == 0; 298 } 299 300 void Function::setParent(Module *parent) { 301 Parent = parent; 302 } 303 304 // dropAllReferences() - This function causes all the subinstructions to "let 305 // go" of all references that they are maintaining. This allows one to 306 // 'delete' a whole class at a time, even though there may be circular 307 // references... first all references are dropped, and all use counts go to 308 // zero. Then everything is deleted for real. Note that no operations are 309 // valid on an object that has "dropped all references", except operator 310 // delete. 311 // 312 void Function::dropAllReferences() { 313 setIsMaterializable(false); 314 315 for (iterator I = begin(), E = end(); I != E; ++I) 316 I->dropAllReferences(); 317 318 // Delete all basic blocks. They are now unused, except possibly by 319 // blockaddresses, but BasicBlock's destructor takes care of those. 320 while (!BasicBlocks.empty()) 321 BasicBlocks.begin()->eraseFromParent(); 322 323 // Prefix and prologue data are stored in a side table. 324 setPrefixData(nullptr); 325 setPrologueData(nullptr); 326 } 327 328 void Function::addAttribute(unsigned i, Attribute::AttrKind attr) { 329 AttributeSet PAL = getAttributes(); 330 PAL = PAL.addAttribute(getContext(), i, attr); 331 setAttributes(PAL); 332 } 333 334 void Function::addAttributes(unsigned i, AttributeSet attrs) { 335 AttributeSet PAL = getAttributes(); 336 PAL = PAL.addAttributes(getContext(), i, attrs); 337 setAttributes(PAL); 338 } 339 340 void Function::removeAttributes(unsigned i, AttributeSet attrs) { 341 AttributeSet PAL = getAttributes(); 342 PAL = PAL.removeAttributes(getContext(), i, attrs); 343 setAttributes(PAL); 344 } 345 346 // Maintain the GC name for each function in an on-the-side table. This saves 347 // allocating an additional word in Function for programs which do not use GC 348 // (i.e., most programs) at the cost of increased overhead for clients which do 349 // use GC. 350 static DenseMap<const Function*,PooledStringPtr> *GCNames; 351 static StringPool *GCNamePool; 352 static ManagedStatic<sys::SmartRWMutex<true> > GCLock; 353 354 bool Function::hasGC() const { 355 sys::SmartScopedReader<true> Reader(*GCLock); 356 return GCNames && GCNames->count(this); 357 } 358 359 const char *Function::getGC() const { 360 assert(hasGC() && "Function has no collector"); 361 sys::SmartScopedReader<true> Reader(*GCLock); 362 return *(*GCNames)[this]; 363 } 364 365 void Function::setGC(const char *Str) { 366 sys::SmartScopedWriter<true> Writer(*GCLock); 367 if (!GCNamePool) 368 GCNamePool = new StringPool(); 369 if (!GCNames) 370 GCNames = new DenseMap<const Function*,PooledStringPtr>(); 371 (*GCNames)[this] = GCNamePool->intern(Str); 372 } 373 374 void Function::clearGC() { 375 sys::SmartScopedWriter<true> Writer(*GCLock); 376 if (GCNames) { 377 GCNames->erase(this); 378 if (GCNames->empty()) { 379 delete GCNames; 380 GCNames = nullptr; 381 if (GCNamePool->empty()) { 382 delete GCNamePool; 383 GCNamePool = nullptr; 384 } 385 } 386 } 387 } 388 389 /// copyAttributesFrom - copy all additional attributes (those not needed to 390 /// create a Function) from the Function Src to this one. 391 void Function::copyAttributesFrom(const GlobalValue *Src) { 392 assert(isa<Function>(Src) && "Expected a Function!"); 393 GlobalObject::copyAttributesFrom(Src); 394 const Function *SrcF = cast<Function>(Src); 395 setCallingConv(SrcF->getCallingConv()); 396 setAttributes(SrcF->getAttributes()); 397 if (SrcF->hasGC()) 398 setGC(SrcF->getGC()); 399 else 400 clearGC(); 401 if (SrcF->hasPrefixData()) 402 setPrefixData(SrcF->getPrefixData()); 403 else 404 setPrefixData(nullptr); 405 if (SrcF->hasPrologueData()) 406 setPrologueData(SrcF->getPrologueData()); 407 else 408 setPrologueData(nullptr); 409 } 410 411 /// getIntrinsicID - This method returns the ID number of the specified 412 /// function, or Intrinsic::not_intrinsic if the function is not an 413 /// intrinsic, or if the pointer is null. This value is always defined to be 414 /// zero to allow easy checking for whether a function is intrinsic or not. The 415 /// particular intrinsic functions which correspond to this value are defined in 416 /// llvm/Intrinsics.h. Results are cached in the LLVM context, subsequent 417 /// requests for the same ID return results much faster from the cache. 418 /// 419 unsigned Function::getIntrinsicID() const { 420 const ValueName *ValName = this->getValueName(); 421 if (!ValName || !isIntrinsic()) 422 return 0; 423 424 LLVMContextImpl::IntrinsicIDCacheTy &IntrinsicIDCache = 425 getContext().pImpl->IntrinsicIDCache; 426 if (!IntrinsicIDCache.count(this)) { 427 unsigned Id = lookupIntrinsicID(); 428 IntrinsicIDCache[this]=Id; 429 return Id; 430 } 431 return IntrinsicIDCache[this]; 432 } 433 434 /// This private method does the actual lookup of an intrinsic ID when the query 435 /// could not be answered from the cache. 436 unsigned Function::lookupIntrinsicID() const { 437 const ValueName *ValName = this->getValueName(); 438 unsigned Len = ValName->getKeyLength(); 439 const char *Name = ValName->getKeyData(); 440 441 #define GET_FUNCTION_RECOGNIZER 442 #include "llvm/IR/Intrinsics.gen" 443 #undef GET_FUNCTION_RECOGNIZER 444 445 return 0; 446 } 447 448 /// Returns a stable mangling for the type specified for use in the name 449 /// mangling scheme used by 'any' types in intrinsic signatures. The mangling 450 /// of named types is simply their name. Manglings for unnamed types consist 451 /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions) 452 /// combined with the mangling of their component types. A vararg function 453 /// type will have a suffix of 'vararg'. Since function types can contain 454 /// other function types, we close a function type mangling with suffix 'f' 455 /// which can't be confused with it's prefix. This ensures we don't have 456 /// collisions between two unrelated function types. Otherwise, you might 457 /// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.) 458 /// Manglings of integers, floats, and vectors ('i', 'f', and 'v' prefix in most 459 /// cases) fall back to the MVT codepath, where they could be mangled to 460 /// 'x86mmx', for example; matching on derived types is not sufficient to mangle 461 /// everything. 462 static std::string getMangledTypeStr(Type* Ty) { 463 std::string Result; 464 if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) { 465 Result += "p" + llvm::utostr(PTyp->getAddressSpace()) + 466 getMangledTypeStr(PTyp->getElementType()); 467 } else if (ArrayType* ATyp = dyn_cast<ArrayType>(Ty)) { 468 Result += "a" + llvm::utostr(ATyp->getNumElements()) + 469 getMangledTypeStr(ATyp->getElementType()); 470 } else if (StructType* STyp = dyn_cast<StructType>(Ty)) { 471 if (!STyp->isLiteral()) 472 Result += STyp->getName(); 473 else 474 llvm_unreachable("TODO: implement literal types"); 475 } else if (FunctionType* FT = dyn_cast<FunctionType>(Ty)) { 476 Result += "f_" + getMangledTypeStr(FT->getReturnType()); 477 for (size_t i = 0; i < FT->getNumParams(); i++) 478 Result += getMangledTypeStr(FT->getParamType(i)); 479 if (FT->isVarArg()) 480 Result += "vararg"; 481 // Ensure nested function types are distinguishable. 482 Result += "f"; 483 } else if (Ty) 484 Result += EVT::getEVT(Ty).getEVTString(); 485 return Result; 486 } 487 488 std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) { 489 assert(id < num_intrinsics && "Invalid intrinsic ID!"); 490 static const char * const Table[] = { 491 "not_intrinsic", 492 #define GET_INTRINSIC_NAME_TABLE 493 #include "llvm/IR/Intrinsics.gen" 494 #undef GET_INTRINSIC_NAME_TABLE 495 }; 496 if (Tys.empty()) 497 return Table[id]; 498 std::string Result(Table[id]); 499 for (unsigned i = 0; i < Tys.size(); ++i) { 500 Result += "." + getMangledTypeStr(Tys[i]); 501 } 502 return Result; 503 } 504 505 506 /// IIT_Info - These are enumerators that describe the entries returned by the 507 /// getIntrinsicInfoTableEntries function. 508 /// 509 /// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter! 510 enum IIT_Info { 511 // Common values should be encoded with 0-15. 512 IIT_Done = 0, 513 IIT_I1 = 1, 514 IIT_I8 = 2, 515 IIT_I16 = 3, 516 IIT_I32 = 4, 517 IIT_I64 = 5, 518 IIT_F16 = 6, 519 IIT_F32 = 7, 520 IIT_F64 = 8, 521 IIT_V2 = 9, 522 IIT_V4 = 10, 523 IIT_V8 = 11, 524 IIT_V16 = 12, 525 IIT_V32 = 13, 526 IIT_PTR = 14, 527 IIT_ARG = 15, 528 529 // Values from 16+ are only encodable with the inefficient encoding. 530 IIT_V64 = 16, 531 IIT_MMX = 17, 532 IIT_METADATA = 18, 533 IIT_EMPTYSTRUCT = 19, 534 IIT_STRUCT2 = 20, 535 IIT_STRUCT3 = 21, 536 IIT_STRUCT4 = 22, 537 IIT_STRUCT5 = 23, 538 IIT_EXTEND_ARG = 24, 539 IIT_TRUNC_ARG = 25, 540 IIT_ANYPTR = 26, 541 IIT_V1 = 27, 542 IIT_VARARG = 28, 543 IIT_HALF_VEC_ARG = 29, 544 IIT_SAME_VEC_WIDTH_ARG = 30, 545 IIT_PTR_TO_ARG = 31, 546 IIT_VEC_OF_PTRS_TO_ELT = 32 547 }; 548 549 550 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, 551 SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) { 552 IIT_Info Info = IIT_Info(Infos[NextElt++]); 553 unsigned StructElts = 2; 554 using namespace Intrinsic; 555 556 switch (Info) { 557 case IIT_Done: 558 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0)); 559 return; 560 case IIT_VARARG: 561 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0)); 562 return; 563 case IIT_MMX: 564 OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0)); 565 return; 566 case IIT_METADATA: 567 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0)); 568 return; 569 case IIT_F16: 570 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0)); 571 return; 572 case IIT_F32: 573 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0)); 574 return; 575 case IIT_F64: 576 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0)); 577 return; 578 case IIT_I1: 579 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1)); 580 return; 581 case IIT_I8: 582 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8)); 583 return; 584 case IIT_I16: 585 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16)); 586 return; 587 case IIT_I32: 588 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32)); 589 return; 590 case IIT_I64: 591 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64)); 592 return; 593 case IIT_V1: 594 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1)); 595 DecodeIITType(NextElt, Infos, OutputTable); 596 return; 597 case IIT_V2: 598 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2)); 599 DecodeIITType(NextElt, Infos, OutputTable); 600 return; 601 case IIT_V4: 602 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4)); 603 DecodeIITType(NextElt, Infos, OutputTable); 604 return; 605 case IIT_V8: 606 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8)); 607 DecodeIITType(NextElt, Infos, OutputTable); 608 return; 609 case IIT_V16: 610 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16)); 611 DecodeIITType(NextElt, Infos, OutputTable); 612 return; 613 case IIT_V32: 614 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32)); 615 DecodeIITType(NextElt, Infos, OutputTable); 616 return; 617 case IIT_V64: 618 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 64)); 619 DecodeIITType(NextElt, Infos, OutputTable); 620 return; 621 case IIT_PTR: 622 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0)); 623 DecodeIITType(NextElt, Infos, OutputTable); 624 return; 625 case IIT_ANYPTR: { // [ANYPTR addrspace, subtype] 626 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 627 Infos[NextElt++])); 628 DecodeIITType(NextElt, Infos, OutputTable); 629 return; 630 } 631 case IIT_ARG: { 632 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 633 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo)); 634 return; 635 } 636 case IIT_EXTEND_ARG: { 637 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 638 OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument, 639 ArgInfo)); 640 return; 641 } 642 case IIT_TRUNC_ARG: { 643 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 644 OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument, 645 ArgInfo)); 646 return; 647 } 648 case IIT_HALF_VEC_ARG: { 649 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 650 OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument, 651 ArgInfo)); 652 return; 653 } 654 case IIT_SAME_VEC_WIDTH_ARG: { 655 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 656 OutputTable.push_back(IITDescriptor::get(IITDescriptor::SameVecWidthArgument, 657 ArgInfo)); 658 return; 659 } 660 case IIT_PTR_TO_ARG: { 661 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 662 OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument, 663 ArgInfo)); 664 return; 665 } 666 case IIT_VEC_OF_PTRS_TO_ELT: { 667 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 668 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VecOfPtrsToElt, 669 ArgInfo)); 670 return; 671 } 672 case IIT_EMPTYSTRUCT: 673 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0)); 674 return; 675 case IIT_STRUCT5: ++StructElts; // FALL THROUGH. 676 case IIT_STRUCT4: ++StructElts; // FALL THROUGH. 677 case IIT_STRUCT3: ++StructElts; // FALL THROUGH. 678 case IIT_STRUCT2: { 679 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts)); 680 681 for (unsigned i = 0; i != StructElts; ++i) 682 DecodeIITType(NextElt, Infos, OutputTable); 683 return; 684 } 685 } 686 llvm_unreachable("unhandled"); 687 } 688 689 690 #define GET_INTRINSIC_GENERATOR_GLOBAL 691 #include "llvm/IR/Intrinsics.gen" 692 #undef GET_INTRINSIC_GENERATOR_GLOBAL 693 694 void Intrinsic::getIntrinsicInfoTableEntries(ID id, 695 SmallVectorImpl<IITDescriptor> &T){ 696 // Check to see if the intrinsic's type was expressible by the table. 697 unsigned TableVal = IIT_Table[id-1]; 698 699 // Decode the TableVal into an array of IITValues. 700 SmallVector<unsigned char, 8> IITValues; 701 ArrayRef<unsigned char> IITEntries; 702 unsigned NextElt = 0; 703 if ((TableVal >> 31) != 0) { 704 // This is an offset into the IIT_LongEncodingTable. 705 IITEntries = IIT_LongEncodingTable; 706 707 // Strip sentinel bit. 708 NextElt = (TableVal << 1) >> 1; 709 } else { 710 // Decode the TableVal into an array of IITValues. If the entry was encoded 711 // into a single word in the table itself, decode it now. 712 do { 713 IITValues.push_back(TableVal & 0xF); 714 TableVal >>= 4; 715 } while (TableVal); 716 717 IITEntries = IITValues; 718 NextElt = 0; 719 } 720 721 // Okay, decode the table into the output vector of IITDescriptors. 722 DecodeIITType(NextElt, IITEntries, T); 723 while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0) 724 DecodeIITType(NextElt, IITEntries, T); 725 } 726 727 728 static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos, 729 ArrayRef<Type*> Tys, LLVMContext &Context) { 730 using namespace Intrinsic; 731 IITDescriptor D = Infos.front(); 732 Infos = Infos.slice(1); 733 734 switch (D.Kind) { 735 case IITDescriptor::Void: return Type::getVoidTy(Context); 736 case IITDescriptor::VarArg: return Type::getVoidTy(Context); 737 case IITDescriptor::MMX: return Type::getX86_MMXTy(Context); 738 case IITDescriptor::Metadata: return Type::getMetadataTy(Context); 739 case IITDescriptor::Half: return Type::getHalfTy(Context); 740 case IITDescriptor::Float: return Type::getFloatTy(Context); 741 case IITDescriptor::Double: return Type::getDoubleTy(Context); 742 743 case IITDescriptor::Integer: 744 return IntegerType::get(Context, D.Integer_Width); 745 case IITDescriptor::Vector: 746 return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width); 747 case IITDescriptor::Pointer: 748 return PointerType::get(DecodeFixedType(Infos, Tys, Context), 749 D.Pointer_AddressSpace); 750 case IITDescriptor::Struct: { 751 Type *Elts[5]; 752 assert(D.Struct_NumElements <= 5 && "Can't handle this yet"); 753 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 754 Elts[i] = DecodeFixedType(Infos, Tys, Context); 755 return StructType::get(Context, makeArrayRef(Elts,D.Struct_NumElements)); 756 } 757 758 case IITDescriptor::Argument: 759 return Tys[D.getArgumentNumber()]; 760 case IITDescriptor::ExtendArgument: { 761 Type *Ty = Tys[D.getArgumentNumber()]; 762 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 763 return VectorType::getExtendedElementVectorType(VTy); 764 765 return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth()); 766 } 767 case IITDescriptor::TruncArgument: { 768 Type *Ty = Tys[D.getArgumentNumber()]; 769 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 770 return VectorType::getTruncatedElementVectorType(VTy); 771 772 IntegerType *ITy = cast<IntegerType>(Ty); 773 assert(ITy->getBitWidth() % 2 == 0); 774 return IntegerType::get(Context, ITy->getBitWidth() / 2); 775 } 776 case IITDescriptor::HalfVecArgument: 777 return VectorType::getHalfElementsVectorType(cast<VectorType>( 778 Tys[D.getArgumentNumber()])); 779 case IITDescriptor::SameVecWidthArgument: { 780 Type *EltTy = DecodeFixedType(Infos, Tys, Context); 781 Type *Ty = Tys[D.getArgumentNumber()]; 782 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) { 783 return VectorType::get(EltTy, VTy->getNumElements()); 784 } 785 llvm_unreachable("unhandled"); 786 } 787 case IITDescriptor::PtrToArgument: { 788 Type *Ty = Tys[D.getArgumentNumber()]; 789 return PointerType::getUnqual(Ty); 790 } 791 case IITDescriptor::VecOfPtrsToElt: { 792 Type *Ty = Tys[D.getArgumentNumber()]; 793 VectorType *VTy = dyn_cast<VectorType>(Ty); 794 if (!VTy) 795 llvm_unreachable("Expected an argument of Vector Type"); 796 Type *EltTy = VTy->getVectorElementType(); 797 return VectorType::get(PointerType::getUnqual(EltTy), 798 VTy->getNumElements()); 799 } 800 } 801 llvm_unreachable("unhandled"); 802 } 803 804 805 806 FunctionType *Intrinsic::getType(LLVMContext &Context, 807 ID id, ArrayRef<Type*> Tys) { 808 SmallVector<IITDescriptor, 8> Table; 809 getIntrinsicInfoTableEntries(id, Table); 810 811 ArrayRef<IITDescriptor> TableRef = Table; 812 Type *ResultTy = DecodeFixedType(TableRef, Tys, Context); 813 814 SmallVector<Type*, 8> ArgTys; 815 while (!TableRef.empty()) 816 ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context)); 817 818 // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg 819 // If we see void type as the type of the last argument, it is vararg intrinsic 820 if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) { 821 ArgTys.pop_back(); 822 return FunctionType::get(ResultTy, ArgTys, true); 823 } 824 return FunctionType::get(ResultTy, ArgTys, false); 825 } 826 827 bool Intrinsic::isOverloaded(ID id) { 828 #define GET_INTRINSIC_OVERLOAD_TABLE 829 #include "llvm/IR/Intrinsics.gen" 830 #undef GET_INTRINSIC_OVERLOAD_TABLE 831 } 832 833 /// This defines the "Intrinsic::getAttributes(ID id)" method. 834 #define GET_INTRINSIC_ATTRIBUTES 835 #include "llvm/IR/Intrinsics.gen" 836 #undef GET_INTRINSIC_ATTRIBUTES 837 838 Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) { 839 // There can never be multiple globals with the same name of different types, 840 // because intrinsics must be a specific type. 841 return 842 cast<Function>(M->getOrInsertFunction(getName(id, Tys), 843 getType(M->getContext(), id, Tys))); 844 } 845 846 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method. 847 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 848 #include "llvm/IR/Intrinsics.gen" 849 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 850 851 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method. 852 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN 853 #include "llvm/IR/Intrinsics.gen" 854 #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN 855 856 /// hasAddressTaken - returns true if there are any uses of this function 857 /// other than direct calls or invokes to it. 858 bool Function::hasAddressTaken(const User* *PutOffender) const { 859 for (const Use &U : uses()) { 860 const User *FU = U.getUser(); 861 if (isa<BlockAddress>(FU)) 862 continue; 863 if (!isa<CallInst>(FU) && !isa<InvokeInst>(FU)) 864 return PutOffender ? (*PutOffender = FU, true) : true; 865 ImmutableCallSite CS(cast<Instruction>(FU)); 866 if (!CS.isCallee(&U)) 867 return PutOffender ? (*PutOffender = FU, true) : true; 868 } 869 return false; 870 } 871 872 bool Function::isDefTriviallyDead() const { 873 // Check the linkage 874 if (!hasLinkOnceLinkage() && !hasLocalLinkage() && 875 !hasAvailableExternallyLinkage()) 876 return false; 877 878 // Check if the function is used by anything other than a blockaddress. 879 for (const User *U : users()) 880 if (!isa<BlockAddress>(U)) 881 return false; 882 883 return true; 884 } 885 886 /// callsFunctionThatReturnsTwice - Return true if the function has a call to 887 /// setjmp or other function that gcc recognizes as "returning twice". 888 bool Function::callsFunctionThatReturnsTwice() const { 889 for (const_inst_iterator 890 I = inst_begin(this), E = inst_end(this); I != E; ++I) { 891 ImmutableCallSite CS(&*I); 892 if (CS && CS.hasFnAttr(Attribute::ReturnsTwice)) 893 return true; 894 } 895 896 return false; 897 } 898 899 Constant *Function::getPrefixData() const { 900 assert(hasPrefixData()); 901 const LLVMContextImpl::PrefixDataMapTy &PDMap = 902 getContext().pImpl->PrefixDataMap; 903 assert(PDMap.find(this) != PDMap.end()); 904 return cast<Constant>(PDMap.find(this)->second->getReturnValue()); 905 } 906 907 void Function::setPrefixData(Constant *PrefixData) { 908 if (!PrefixData && !hasPrefixData()) 909 return; 910 911 unsigned SCData = getSubclassDataFromValue(); 912 LLVMContextImpl::PrefixDataMapTy &PDMap = getContext().pImpl->PrefixDataMap; 913 ReturnInst *&PDHolder = PDMap[this]; 914 if (PrefixData) { 915 if (PDHolder) 916 PDHolder->setOperand(0, PrefixData); 917 else 918 PDHolder = ReturnInst::Create(getContext(), PrefixData); 919 SCData |= (1<<1); 920 } else { 921 delete PDHolder; 922 PDMap.erase(this); 923 SCData &= ~(1<<1); 924 } 925 setValueSubclassData(SCData); 926 } 927 928 Constant *Function::getPrologueData() const { 929 assert(hasPrologueData()); 930 const LLVMContextImpl::PrologueDataMapTy &SOMap = 931 getContext().pImpl->PrologueDataMap; 932 assert(SOMap.find(this) != SOMap.end()); 933 return cast<Constant>(SOMap.find(this)->second->getReturnValue()); 934 } 935 936 void Function::setPrologueData(Constant *PrologueData) { 937 if (!PrologueData && !hasPrologueData()) 938 return; 939 940 unsigned PDData = getSubclassDataFromValue(); 941 LLVMContextImpl::PrologueDataMapTy &PDMap = getContext().pImpl->PrologueDataMap; 942 ReturnInst *&PDHolder = PDMap[this]; 943 if (PrologueData) { 944 if (PDHolder) 945 PDHolder->setOperand(0, PrologueData); 946 else 947 PDHolder = ReturnInst::Create(getContext(), PrologueData); 948 PDData |= (1<<2); 949 } else { 950 delete PDHolder; 951 PDMap.erase(this); 952 PDData &= ~(1<<2); 953 } 954 setValueSubclassData(PDData); 955 } 956