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>; 39 template class llvm::SymbolTableListTraits<BasicBlock>; 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 return getParent()->getAttributes(). 158 hasAttribute(getArgNo()+1, Attribute::StructRet); 159 } 160 161 /// hasReturnedAttr - Return true if this argument has the returned attribute on 162 /// it in its containing function. 163 bool Argument::hasReturnedAttr() const { 164 return getParent()->getAttributes(). 165 hasAttribute(getArgNo()+1, Attribute::Returned); 166 } 167 168 /// hasZExtAttr - Return true if this argument has the zext attribute on it in 169 /// its containing function. 170 bool Argument::hasZExtAttr() const { 171 return getParent()->getAttributes(). 172 hasAttribute(getArgNo()+1, Attribute::ZExt); 173 } 174 175 /// hasSExtAttr Return true if this argument has the sext attribute on it in its 176 /// containing function. 177 bool Argument::hasSExtAttr() const { 178 return getParent()->getAttributes(). 179 hasAttribute(getArgNo()+1, Attribute::SExt); 180 } 181 182 /// Return true if this argument has the readonly or readnone attribute on it 183 /// in its containing function. 184 bool Argument::onlyReadsMemory() const { 185 return getParent()->getAttributes(). 186 hasAttribute(getArgNo()+1, Attribute::ReadOnly) || 187 getParent()->getAttributes(). 188 hasAttribute(getArgNo()+1, Attribute::ReadNone); 189 } 190 191 /// addAttr - Add attributes to an argument. 192 void Argument::addAttr(AttributeSet AS) { 193 assert(AS.getNumSlots() <= 1 && 194 "Trying to add more than one attribute set to an argument!"); 195 AttrBuilder B(AS, AS.getSlotIndex(0)); 196 getParent()->addAttributes(getArgNo() + 1, 197 AttributeSet::get(Parent->getContext(), 198 getArgNo() + 1, B)); 199 } 200 201 /// removeAttr - Remove attributes from an argument. 202 void Argument::removeAttr(AttributeSet AS) { 203 assert(AS.getNumSlots() <= 1 && 204 "Trying to remove more than one attribute set from an argument!"); 205 AttrBuilder B(AS, AS.getSlotIndex(0)); 206 getParent()->removeAttributes(getArgNo() + 1, 207 AttributeSet::get(Parent->getContext(), 208 getArgNo() + 1, B)); 209 } 210 211 //===----------------------------------------------------------------------===// 212 // Helper Methods in Function 213 //===----------------------------------------------------------------------===// 214 215 bool Function::isMaterializable() const { 216 return getGlobalObjectSubClassData() & IsMaterializableBit; 217 } 218 219 void Function::setIsMaterializable(bool V) { 220 setGlobalObjectBit(IsMaterializableBit, V); 221 } 222 223 LLVMContext &Function::getContext() const { 224 return getType()->getContext(); 225 } 226 227 FunctionType *Function::getFunctionType() const { return Ty; } 228 229 bool Function::isVarArg() const { 230 return getFunctionType()->isVarArg(); 231 } 232 233 Type *Function::getReturnType() const { 234 return getFunctionType()->getReturnType(); 235 } 236 237 void Function::removeFromParent() { 238 getParent()->getFunctionList().remove(getIterator()); 239 } 240 241 void Function::eraseFromParent() { 242 getParent()->getFunctionList().erase(getIterator()); 243 } 244 245 //===----------------------------------------------------------------------===// 246 // Function Implementation 247 //===----------------------------------------------------------------------===// 248 249 Function::Function(FunctionType *Ty, LinkageTypes Linkage, const Twine &name, 250 Module *ParentModule) 251 : GlobalObject(Ty, Value::FunctionVal, 252 OperandTraits<Function>::op_begin(this), 0, Linkage, name), 253 Ty(Ty) { 254 assert(FunctionType::isValidReturnType(getReturnType()) && 255 "invalid return type"); 256 setGlobalObjectSubClassData(0); 257 SymTab = new ValueSymbolTable(); 258 259 // If the function has arguments, mark them as lazily built. 260 if (Ty->getNumParams()) 261 setValueSubclassData(1); // Set the "has lazy arguments" bit. 262 263 if (ParentModule) 264 ParentModule->getFunctionList().push_back(this); 265 266 // Ensure intrinsics have the right parameter attributes. 267 // Note, the IntID field will have been set in Value::setName if this function 268 // name is a valid intrinsic ID. 269 if (IntID) 270 setAttributes(Intrinsic::getAttributes(getContext(), IntID)); 271 } 272 273 Function::~Function() { 274 dropAllReferences(); // After this it is safe to delete instructions. 275 276 // Delete all of the method arguments and unlink from symbol table... 277 ArgumentList.clear(); 278 delete SymTab; 279 280 // Remove the function from the on-the-side GC table. 281 clearGC(); 282 } 283 284 void Function::BuildLazyArguments() const { 285 // Create the arguments vector, all arguments start out unnamed. 286 FunctionType *FT = getFunctionType(); 287 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 288 assert(!FT->getParamType(i)->isVoidTy() && 289 "Cannot have void typed arguments!"); 290 ArgumentList.push_back(new Argument(FT->getParamType(i))); 291 } 292 293 // Clear the lazy arguments bit. 294 unsigned SDC = getSubclassDataFromValue(); 295 const_cast<Function*>(this)->setValueSubclassData(SDC &= ~(1<<0)); 296 } 297 298 size_t Function::arg_size() const { 299 return getFunctionType()->getNumParams(); 300 } 301 bool Function::arg_empty() const { 302 return getFunctionType()->getNumParams() == 0; 303 } 304 305 void Function::setParent(Module *parent) { 306 Parent = parent; 307 } 308 309 // dropAllReferences() - This function causes all the subinstructions to "let 310 // go" of all references that they are maintaining. This allows one to 311 // 'delete' a whole class at a time, even though there may be circular 312 // references... first all references are dropped, and all use counts go to 313 // zero. Then everything is deleted for real. Note that no operations are 314 // valid on an object that has "dropped all references", except operator 315 // delete. 316 // 317 void Function::dropAllReferences() { 318 setIsMaterializable(false); 319 320 for (iterator I = begin(), E = end(); I != E; ++I) 321 I->dropAllReferences(); 322 323 // Delete all basic blocks. They are now unused, except possibly by 324 // blockaddresses, but BasicBlock's destructor takes care of those. 325 while (!BasicBlocks.empty()) 326 BasicBlocks.begin()->eraseFromParent(); 327 328 // Drop uses of any optional data (real or placeholder). 329 if (getNumOperands()) { 330 User::dropAllReferences(); 331 setNumHungOffUseOperands(0); 332 } 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 /// Copy all additional attributes (those not needed to create a Function) from 412 /// the Function Src to this one. 413 void Function::copyAttributesFrom(const GlobalValue *Src) { 414 GlobalObject::copyAttributesFrom(Src); 415 const Function *SrcF = dyn_cast<Function>(Src); 416 if (!SrcF) 417 return; 418 419 setCallingConv(SrcF->getCallingConv()); 420 setAttributes(SrcF->getAttributes()); 421 if (SrcF->hasGC()) 422 setGC(SrcF->getGC()); 423 else 424 clearGC(); 425 if (SrcF->hasPersonalityFn()) 426 setPersonalityFn(SrcF->getPersonalityFn()); 427 if (SrcF->hasPrefixData()) 428 setPrefixData(SrcF->getPrefixData()); 429 if (SrcF->hasPrologueData()) 430 setPrologueData(SrcF->getPrologueData()); 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 (isa<VectorType>(Ty)) 489 Result += "v" + utostr(Ty->getVectorNumElements()) + 490 getMangledTypeStr(Ty->getVectorElementType()); 491 else if (Ty) 492 Result += EVT::getEVT(Ty).getEVTString(); 493 return Result; 494 } 495 496 std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) { 497 assert(id < num_intrinsics && "Invalid intrinsic ID!"); 498 static const char * const Table[] = { 499 "not_intrinsic", 500 #define GET_INTRINSIC_NAME_TABLE 501 #include "llvm/IR/Intrinsics.gen" 502 #undef GET_INTRINSIC_NAME_TABLE 503 }; 504 if (Tys.empty()) 505 return Table[id]; 506 std::string Result(Table[id]); 507 for (unsigned i = 0; i < Tys.size(); ++i) { 508 Result += "." + getMangledTypeStr(Tys[i]); 509 } 510 return Result; 511 } 512 513 514 /// IIT_Info - These are enumerators that describe the entries returned by the 515 /// getIntrinsicInfoTableEntries function. 516 /// 517 /// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter! 518 enum IIT_Info { 519 // Common values should be encoded with 0-15. 520 IIT_Done = 0, 521 IIT_I1 = 1, 522 IIT_I8 = 2, 523 IIT_I16 = 3, 524 IIT_I32 = 4, 525 IIT_I64 = 5, 526 IIT_F16 = 6, 527 IIT_F32 = 7, 528 IIT_F64 = 8, 529 IIT_V2 = 9, 530 IIT_V4 = 10, 531 IIT_V8 = 11, 532 IIT_V16 = 12, 533 IIT_V32 = 13, 534 IIT_PTR = 14, 535 IIT_ARG = 15, 536 537 // Values from 16+ are only encodable with the inefficient encoding. 538 IIT_V64 = 16, 539 IIT_MMX = 17, 540 IIT_TOKEN = 18, 541 IIT_METADATA = 19, 542 IIT_EMPTYSTRUCT = 20, 543 IIT_STRUCT2 = 21, 544 IIT_STRUCT3 = 22, 545 IIT_STRUCT4 = 23, 546 IIT_STRUCT5 = 24, 547 IIT_EXTEND_ARG = 25, 548 IIT_TRUNC_ARG = 26, 549 IIT_ANYPTR = 27, 550 IIT_V1 = 28, 551 IIT_VARARG = 29, 552 IIT_HALF_VEC_ARG = 30, 553 IIT_SAME_VEC_WIDTH_ARG = 31, 554 IIT_PTR_TO_ARG = 32, 555 IIT_VEC_OF_PTRS_TO_ELT = 33, 556 IIT_I128 = 34, 557 IIT_V512 = 35, 558 IIT_V1024 = 36 559 }; 560 561 562 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, 563 SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) { 564 IIT_Info Info = IIT_Info(Infos[NextElt++]); 565 unsigned StructElts = 2; 566 using namespace Intrinsic; 567 568 switch (Info) { 569 case IIT_Done: 570 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0)); 571 return; 572 case IIT_VARARG: 573 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0)); 574 return; 575 case IIT_MMX: 576 OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0)); 577 return; 578 case IIT_TOKEN: 579 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0)); 580 return; 581 case IIT_METADATA: 582 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0)); 583 return; 584 case IIT_F16: 585 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0)); 586 return; 587 case IIT_F32: 588 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0)); 589 return; 590 case IIT_F64: 591 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0)); 592 return; 593 case IIT_I1: 594 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1)); 595 return; 596 case IIT_I8: 597 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8)); 598 return; 599 case IIT_I16: 600 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16)); 601 return; 602 case IIT_I32: 603 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32)); 604 return; 605 case IIT_I64: 606 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64)); 607 return; 608 case IIT_I128: 609 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128)); 610 return; 611 case IIT_V1: 612 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1)); 613 DecodeIITType(NextElt, Infos, OutputTable); 614 return; 615 case IIT_V2: 616 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2)); 617 DecodeIITType(NextElt, Infos, OutputTable); 618 return; 619 case IIT_V4: 620 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4)); 621 DecodeIITType(NextElt, Infos, OutputTable); 622 return; 623 case IIT_V8: 624 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8)); 625 DecodeIITType(NextElt, Infos, OutputTable); 626 return; 627 case IIT_V16: 628 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16)); 629 DecodeIITType(NextElt, Infos, OutputTable); 630 return; 631 case IIT_V32: 632 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32)); 633 DecodeIITType(NextElt, Infos, OutputTable); 634 return; 635 case IIT_V64: 636 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 64)); 637 DecodeIITType(NextElt, Infos, OutputTable); 638 return; 639 case IIT_V512: 640 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 512)); 641 DecodeIITType(NextElt, Infos, OutputTable); 642 return; 643 case IIT_V1024: 644 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1024)); 645 DecodeIITType(NextElt, Infos, OutputTable); 646 return; 647 case IIT_PTR: 648 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0)); 649 DecodeIITType(NextElt, Infos, OutputTable); 650 return; 651 case IIT_ANYPTR: { // [ANYPTR addrspace, subtype] 652 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 653 Infos[NextElt++])); 654 DecodeIITType(NextElt, Infos, OutputTable); 655 return; 656 } 657 case IIT_ARG: { 658 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 659 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo)); 660 return; 661 } 662 case IIT_EXTEND_ARG: { 663 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 664 OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument, 665 ArgInfo)); 666 return; 667 } 668 case IIT_TRUNC_ARG: { 669 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 670 OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument, 671 ArgInfo)); 672 return; 673 } 674 case IIT_HALF_VEC_ARG: { 675 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 676 OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument, 677 ArgInfo)); 678 return; 679 } 680 case IIT_SAME_VEC_WIDTH_ARG: { 681 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 682 OutputTable.push_back(IITDescriptor::get(IITDescriptor::SameVecWidthArgument, 683 ArgInfo)); 684 return; 685 } 686 case IIT_PTR_TO_ARG: { 687 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 688 OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument, 689 ArgInfo)); 690 return; 691 } 692 case IIT_VEC_OF_PTRS_TO_ELT: { 693 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 694 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VecOfPtrsToElt, 695 ArgInfo)); 696 return; 697 } 698 case IIT_EMPTYSTRUCT: 699 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0)); 700 return; 701 case IIT_STRUCT5: ++StructElts; // FALL THROUGH. 702 case IIT_STRUCT4: ++StructElts; // FALL THROUGH. 703 case IIT_STRUCT3: ++StructElts; // FALL THROUGH. 704 case IIT_STRUCT2: { 705 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts)); 706 707 for (unsigned i = 0; i != StructElts; ++i) 708 DecodeIITType(NextElt, Infos, OutputTable); 709 return; 710 } 711 } 712 llvm_unreachable("unhandled"); 713 } 714 715 716 #define GET_INTRINSIC_GENERATOR_GLOBAL 717 #include "llvm/IR/Intrinsics.gen" 718 #undef GET_INTRINSIC_GENERATOR_GLOBAL 719 720 void Intrinsic::getIntrinsicInfoTableEntries(ID id, 721 SmallVectorImpl<IITDescriptor> &T){ 722 // Check to see if the intrinsic's type was expressible by the table. 723 unsigned TableVal = IIT_Table[id-1]; 724 725 // Decode the TableVal into an array of IITValues. 726 SmallVector<unsigned char, 8> IITValues; 727 ArrayRef<unsigned char> IITEntries; 728 unsigned NextElt = 0; 729 if ((TableVal >> 31) != 0) { 730 // This is an offset into the IIT_LongEncodingTable. 731 IITEntries = IIT_LongEncodingTable; 732 733 // Strip sentinel bit. 734 NextElt = (TableVal << 1) >> 1; 735 } else { 736 // Decode the TableVal into an array of IITValues. If the entry was encoded 737 // into a single word in the table itself, decode it now. 738 do { 739 IITValues.push_back(TableVal & 0xF); 740 TableVal >>= 4; 741 } while (TableVal); 742 743 IITEntries = IITValues; 744 NextElt = 0; 745 } 746 747 // Okay, decode the table into the output vector of IITDescriptors. 748 DecodeIITType(NextElt, IITEntries, T); 749 while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0) 750 DecodeIITType(NextElt, IITEntries, T); 751 } 752 753 754 static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos, 755 ArrayRef<Type*> Tys, LLVMContext &Context) { 756 using namespace Intrinsic; 757 IITDescriptor D = Infos.front(); 758 Infos = Infos.slice(1); 759 760 switch (D.Kind) { 761 case IITDescriptor::Void: return Type::getVoidTy(Context); 762 case IITDescriptor::VarArg: return Type::getVoidTy(Context); 763 case IITDescriptor::MMX: return Type::getX86_MMXTy(Context); 764 case IITDescriptor::Token: return Type::getTokenTy(Context); 765 case IITDescriptor::Metadata: return Type::getMetadataTy(Context); 766 case IITDescriptor::Half: return Type::getHalfTy(Context); 767 case IITDescriptor::Float: return Type::getFloatTy(Context); 768 case IITDescriptor::Double: return Type::getDoubleTy(Context); 769 770 case IITDescriptor::Integer: 771 return IntegerType::get(Context, D.Integer_Width); 772 case IITDescriptor::Vector: 773 return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width); 774 case IITDescriptor::Pointer: 775 return PointerType::get(DecodeFixedType(Infos, Tys, Context), 776 D.Pointer_AddressSpace); 777 case IITDescriptor::Struct: { 778 Type *Elts[5]; 779 assert(D.Struct_NumElements <= 5 && "Can't handle this yet"); 780 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 781 Elts[i] = DecodeFixedType(Infos, Tys, Context); 782 return StructType::get(Context, makeArrayRef(Elts,D.Struct_NumElements)); 783 } 784 785 case IITDescriptor::Argument: 786 return Tys[D.getArgumentNumber()]; 787 case IITDescriptor::ExtendArgument: { 788 Type *Ty = Tys[D.getArgumentNumber()]; 789 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 790 return VectorType::getExtendedElementVectorType(VTy); 791 792 return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth()); 793 } 794 case IITDescriptor::TruncArgument: { 795 Type *Ty = Tys[D.getArgumentNumber()]; 796 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 797 return VectorType::getTruncatedElementVectorType(VTy); 798 799 IntegerType *ITy = cast<IntegerType>(Ty); 800 assert(ITy->getBitWidth() % 2 == 0); 801 return IntegerType::get(Context, ITy->getBitWidth() / 2); 802 } 803 case IITDescriptor::HalfVecArgument: 804 return VectorType::getHalfElementsVectorType(cast<VectorType>( 805 Tys[D.getArgumentNumber()])); 806 case IITDescriptor::SameVecWidthArgument: { 807 Type *EltTy = DecodeFixedType(Infos, Tys, Context); 808 Type *Ty = Tys[D.getArgumentNumber()]; 809 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) { 810 return VectorType::get(EltTy, VTy->getNumElements()); 811 } 812 llvm_unreachable("unhandled"); 813 } 814 case IITDescriptor::PtrToArgument: { 815 Type *Ty = Tys[D.getArgumentNumber()]; 816 return PointerType::getUnqual(Ty); 817 } 818 case IITDescriptor::VecOfPtrsToElt: { 819 Type *Ty = Tys[D.getArgumentNumber()]; 820 VectorType *VTy = dyn_cast<VectorType>(Ty); 821 if (!VTy) 822 llvm_unreachable("Expected an argument of Vector Type"); 823 Type *EltTy = VTy->getVectorElementType(); 824 return VectorType::get(PointerType::getUnqual(EltTy), 825 VTy->getNumElements()); 826 } 827 } 828 llvm_unreachable("unhandled"); 829 } 830 831 832 833 FunctionType *Intrinsic::getType(LLVMContext &Context, 834 ID id, ArrayRef<Type*> Tys) { 835 SmallVector<IITDescriptor, 8> Table; 836 getIntrinsicInfoTableEntries(id, Table); 837 838 ArrayRef<IITDescriptor> TableRef = Table; 839 Type *ResultTy = DecodeFixedType(TableRef, Tys, Context); 840 841 SmallVector<Type*, 8> ArgTys; 842 while (!TableRef.empty()) 843 ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context)); 844 845 // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg 846 // If we see void type as the type of the last argument, it is vararg intrinsic 847 if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) { 848 ArgTys.pop_back(); 849 return FunctionType::get(ResultTy, ArgTys, true); 850 } 851 return FunctionType::get(ResultTy, ArgTys, false); 852 } 853 854 bool Intrinsic::isOverloaded(ID id) { 855 #define GET_INTRINSIC_OVERLOAD_TABLE 856 #include "llvm/IR/Intrinsics.gen" 857 #undef GET_INTRINSIC_OVERLOAD_TABLE 858 } 859 860 bool Intrinsic::isLeaf(ID id) { 861 switch (id) { 862 default: 863 return true; 864 865 case Intrinsic::experimental_gc_statepoint: 866 case Intrinsic::experimental_patchpoint_void: 867 case Intrinsic::experimental_patchpoint_i64: 868 return false; 869 } 870 } 871 872 /// This defines the "Intrinsic::getAttributes(ID id)" method. 873 #define GET_INTRINSIC_ATTRIBUTES 874 #include "llvm/IR/Intrinsics.gen" 875 #undef GET_INTRINSIC_ATTRIBUTES 876 877 Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) { 878 // There can never be multiple globals with the same name of different types, 879 // because intrinsics must be a specific type. 880 return 881 cast<Function>(M->getOrInsertFunction(getName(id, Tys), 882 getType(M->getContext(), id, Tys))); 883 } 884 885 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method. 886 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 887 #include "llvm/IR/Intrinsics.gen" 888 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 889 890 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method. 891 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN 892 #include "llvm/IR/Intrinsics.gen" 893 #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN 894 895 /// hasAddressTaken - returns true if there are any uses of this function 896 /// other than direct calls or invokes to it. 897 bool Function::hasAddressTaken(const User* *PutOffender) const { 898 for (const Use &U : uses()) { 899 const User *FU = U.getUser(); 900 if (isa<BlockAddress>(FU)) 901 continue; 902 if (!isa<CallInst>(FU) && !isa<InvokeInst>(FU)) 903 return PutOffender ? (*PutOffender = FU, true) : true; 904 ImmutableCallSite CS(cast<Instruction>(FU)); 905 if (!CS.isCallee(&U)) 906 return PutOffender ? (*PutOffender = FU, true) : true; 907 } 908 return false; 909 } 910 911 bool Function::isDefTriviallyDead() const { 912 // Check the linkage 913 if (!hasLinkOnceLinkage() && !hasLocalLinkage() && 914 !hasAvailableExternallyLinkage()) 915 return false; 916 917 // Check if the function is used by anything other than a blockaddress. 918 for (const User *U : users()) 919 if (!isa<BlockAddress>(U)) 920 return false; 921 922 return true; 923 } 924 925 /// callsFunctionThatReturnsTwice - Return true if the function has a call to 926 /// setjmp or other function that gcc recognizes as "returning twice". 927 bool Function::callsFunctionThatReturnsTwice() const { 928 for (const_inst_iterator 929 I = inst_begin(this), E = inst_end(this); I != E; ++I) { 930 ImmutableCallSite CS(&*I); 931 if (CS && CS.hasFnAttr(Attribute::ReturnsTwice)) 932 return true; 933 } 934 935 return false; 936 } 937 938 Constant *Function::getPersonalityFn() const { 939 assert(hasPersonalityFn() && getNumOperands()); 940 return cast<Constant>(Op<0>()); 941 } 942 943 void Function::setPersonalityFn(Constant *Fn) { 944 if (Fn) 945 setHungoffOperand<0>(Fn); 946 setValueSubclassDataBit(3, Fn != nullptr); 947 } 948 949 Constant *Function::getPrefixData() const { 950 assert(hasPrefixData() && getNumOperands()); 951 return cast<Constant>(Op<1>()); 952 } 953 954 void Function::setPrefixData(Constant *PrefixData) { 955 if (PrefixData) 956 setHungoffOperand<1>(PrefixData); 957 setValueSubclassDataBit(1, PrefixData != nullptr); 958 } 959 960 Constant *Function::getPrologueData() const { 961 assert(hasPrologueData() && getNumOperands()); 962 return cast<Constant>(Op<2>()); 963 } 964 965 void Function::setPrologueData(Constant *PrologueData) { 966 if (PrologueData) 967 setHungoffOperand<2>(PrologueData); 968 setValueSubclassDataBit(2, PrologueData != nullptr); 969 } 970 971 void Function::allocHungoffUselist() { 972 // If we've already allocated a uselist, stop here. 973 if (getNumOperands()) 974 return; 975 976 allocHungoffUses(3, /*IsPhi=*/ false); 977 setNumHungOffUseOperands(3); 978 979 // Initialize the uselist with placeholder operands to allow traversal. 980 auto *CPN = ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0)); 981 Op<0>().set(CPN); 982 Op<1>().set(CPN); 983 Op<2>().set(CPN); 984 } 985 986 template <int Idx> 987 void Function::setHungoffOperand(Constant *C) { 988 assert(C && "Cannot set hungoff operand to nullptr"); 989 allocHungoffUselist(); 990 Op<Idx>().set(C); 991 } 992 993 void Function::setValueSubclassDataBit(unsigned Bit, bool On) { 994 assert(Bit < 16 && "SubclassData contains only 16 bits"); 995 if (On) 996 setValueSubclassData(getSubclassDataFromValue() | (1 << Bit)); 997 else 998 setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit)); 999 } 1000 1001 void Function::setEntryCount(uint64_t Count) { 1002 MDBuilder MDB(getContext()); 1003 setMetadata(LLVMContext::MD_prof, MDB.createFunctionEntryCount(Count)); 1004 } 1005 1006 Optional<uint64_t> Function::getEntryCount() const { 1007 MDNode *MD = getMetadata(LLVMContext::MD_prof); 1008 if (MD && MD->getOperand(0)) 1009 if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) 1010 if (MDS->getString().equals("function_entry_count")) { 1011 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1)); 1012 return CI->getValue().getZExtValue(); 1013 } 1014 return None; 1015 } 1016