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