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" 34using namespace llvm; 35 36// Explicit instantiations of SymbolTableListTraits since some of the methods 37// are not in the public header file... 38template class llvm::SymbolTableListTraits<Argument>; 39template class llvm::SymbolTableListTraits<BasicBlock>; 40 41//===----------------------------------------------------------------------===// 42// Argument Implementation 43//===----------------------------------------------------------------------===// 44 45void Argument::anchor() { } 46 47Argument::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 56void 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. 62unsigned 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). 77bool 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. 90bool 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. 98bool Argument::hasInAllocaAttr() const { 99 if (!getType()->isPointerTy()) return false; 100 return getParent()->getAttributes(). 101 hasAttribute(getArgNo()+1, Attribute::InAlloca); 102} 103 104bool 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 111unsigned Argument::getParamAlignment() const { 112 assert(getType()->isPointerTy() && "Only pointers have alignments"); 113 return getParent()->getParamAlignment(getArgNo()+1); 114 115} 116 117uint64_t Argument::getDereferenceableBytes() const { 118 assert(getType()->isPointerTy() && 119 "Only pointers have dereferenceable bytes"); 120 return getParent()->getDereferenceableBytes(getArgNo()+1); 121} 122 123uint64_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. 131bool 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. 139bool 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. 147bool 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. 155bool 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. 163bool 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. 170bool 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. 177bool 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. 184bool 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. 192void 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. 202void 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 215bool Function::isMaterializable() const { 216 return getGlobalObjectSubClassData() & IsMaterializableBit; 217} 218 219void Function::setIsMaterializable(bool V) { 220 setGlobalObjectBit(IsMaterializableBit, V); 221} 222 223LLVMContext &Function::getContext() const { 224 return getType()->getContext(); 225} 226 227FunctionType *Function::getFunctionType() const { return Ty; } 228 229bool Function::isVarArg() const { 230 return getFunctionType()->isVarArg(); 231} 232 233Type *Function::getReturnType() const { 234 return getFunctionType()->getReturnType(); 235} 236 237void Function::removeFromParent() { 238 getParent()->getFunctionList().remove(getIterator()); 239} 240 241void Function::eraseFromParent() { 242 getParent()->getFunctionList().erase(getIterator()); 243} 244 245//===----------------------------------------------------------------------===// 246// Function Implementation 247//===----------------------------------------------------------------------===// 248 249Function::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 273Function::~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 284void 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 298size_t Function::arg_size() const { 299 return getFunctionType()->getNumParams(); 300} 301bool Function::arg_empty() const { 302 return getFunctionType()->getNumParams() == 0; 303} 304 305void 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// 317void 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 setValueSubclassData(getSubclassDataFromValue() & ~0xe); 333 } 334 335 // Metadata is stored in a side-table. 336 clearMetadata(); 337} 338 339void Function::addAttribute(unsigned i, Attribute::AttrKind attr) { 340 AttributeSet PAL = getAttributes(); 341 PAL = PAL.addAttribute(getContext(), i, attr); 342 setAttributes(PAL); 343} 344 345void Function::addAttributes(unsigned i, AttributeSet attrs) { 346 AttributeSet PAL = getAttributes(); 347 PAL = PAL.addAttributes(getContext(), i, attrs); 348 setAttributes(PAL); 349} 350 351void Function::removeAttributes(unsigned i, AttributeSet attrs) { 352 AttributeSet PAL = getAttributes(); 353 PAL = PAL.removeAttributes(getContext(), i, attrs); 354 setAttributes(PAL); 355} 356 357void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) { 358 AttributeSet PAL = getAttributes(); 359 PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes); 360 setAttributes(PAL); 361} 362 363void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) { 364 AttributeSet PAL = getAttributes(); 365 PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes); 366 setAttributes(PAL); 367} 368 369const std::string &Function::getGC() const { 370 assert(hasGC() && "Function has no collector"); 371 return getContext().getGC(*this); 372} 373 374void Function::setGC(const std::string Str) { 375 setValueSubclassDataBit(14, !Str.empty()); 376 getContext().setGC(*this, std::move(Str)); 377} 378 379void Function::clearGC() { 380 if (!hasGC()) 381 return; 382 getContext().deleteGC(*this); 383 setValueSubclassDataBit(14, false); 384} 385 386/// Copy all additional attributes (those not needed to create a Function) from 387/// the Function Src to this one. 388void Function::copyAttributesFrom(const GlobalValue *Src) { 389 GlobalObject::copyAttributesFrom(Src); 390 const Function *SrcF = dyn_cast<Function>(Src); 391 if (!SrcF) 392 return; 393 394 setCallingConv(SrcF->getCallingConv()); 395 setAttributes(SrcF->getAttributes()); 396 if (SrcF->hasGC()) 397 setGC(SrcF->getGC()); 398 else 399 clearGC(); 400 if (SrcF->hasPersonalityFn()) 401 setPersonalityFn(SrcF->getPersonalityFn()); 402 if (SrcF->hasPrefixData()) 403 setPrefixData(SrcF->getPrefixData()); 404 if (SrcF->hasPrologueData()) 405 setPrologueData(SrcF->getPrologueData()); 406} 407 408/// \brief This does the actual lookup of an intrinsic ID which 409/// matches the given function name. 410static Intrinsic::ID lookupIntrinsicID(const ValueName *ValName) { 411 unsigned Len = ValName->getKeyLength(); 412 const char *Name = ValName->getKeyData(); 413 414#define GET_FUNCTION_RECOGNIZER 415#include "llvm/IR/Intrinsics.gen" 416#undef GET_FUNCTION_RECOGNIZER 417 418 return Intrinsic::not_intrinsic; 419} 420 421void Function::recalculateIntrinsicID() { 422 const ValueName *ValName = this->getValueName(); 423 if (!ValName || !isIntrinsic()) { 424 IntID = Intrinsic::not_intrinsic; 425 return; 426 } 427 IntID = lookupIntrinsicID(ValName); 428} 429 430/// Returns a stable mangling for the type specified for use in the name 431/// mangling scheme used by 'any' types in intrinsic signatures. The mangling 432/// of named types is simply their name. Manglings for unnamed types consist 433/// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions) 434/// combined with the mangling of their component types. A vararg function 435/// type will have a suffix of 'vararg'. Since function types can contain 436/// other function types, we close a function type mangling with suffix 'f' 437/// which can't be confused with it's prefix. This ensures we don't have 438/// collisions between two unrelated function types. Otherwise, you might 439/// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.) 440/// Manglings of integers, floats, and vectors ('i', 'f', and 'v' prefix in most 441/// cases) fall back to the MVT codepath, where they could be mangled to 442/// 'x86mmx', for example; matching on derived types is not sufficient to mangle 443/// everything. 444static std::string getMangledTypeStr(Type* Ty) { 445 std::string Result; 446 if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) { 447 Result += "p" + llvm::utostr(PTyp->getAddressSpace()) + 448 getMangledTypeStr(PTyp->getElementType()); 449 } else if (ArrayType* ATyp = dyn_cast<ArrayType>(Ty)) { 450 Result += "a" + llvm::utostr(ATyp->getNumElements()) + 451 getMangledTypeStr(ATyp->getElementType()); 452 } else if (StructType* STyp = dyn_cast<StructType>(Ty)) { 453 assert(!STyp->isLiteral() && "TODO: implement literal types"); 454 Result += STyp->getName(); 455 } else if (FunctionType* FT = dyn_cast<FunctionType>(Ty)) { 456 Result += "f_" + getMangledTypeStr(FT->getReturnType()); 457 for (size_t i = 0; i < FT->getNumParams(); i++) 458 Result += getMangledTypeStr(FT->getParamType(i)); 459 if (FT->isVarArg()) 460 Result += "vararg"; 461 // Ensure nested function types are distinguishable. 462 Result += "f"; 463 } else if (isa<VectorType>(Ty)) 464 Result += "v" + utostr(Ty->getVectorNumElements()) + 465 getMangledTypeStr(Ty->getVectorElementType()); 466 else if (Ty) 467 Result += EVT::getEVT(Ty).getEVTString(); 468 return Result; 469} 470 471std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) { 472 assert(id < num_intrinsics && "Invalid intrinsic ID!"); 473 static const char * const Table[] = { 474 "not_intrinsic", 475#define GET_INTRINSIC_NAME_TABLE 476#include "llvm/IR/Intrinsics.gen" 477#undef GET_INTRINSIC_NAME_TABLE 478 }; 479 if (Tys.empty()) 480 return Table[id]; 481 std::string Result(Table[id]); 482 for (unsigned i = 0; i < Tys.size(); ++i) { 483 Result += "." + getMangledTypeStr(Tys[i]); 484 } 485 return Result; 486} 487 488 489/// IIT_Info - These are enumerators that describe the entries returned by the 490/// getIntrinsicInfoTableEntries function. 491/// 492/// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter! 493enum IIT_Info { 494 // Common values should be encoded with 0-15. 495 IIT_Done = 0, 496 IIT_I1 = 1, 497 IIT_I8 = 2, 498 IIT_I16 = 3, 499 IIT_I32 = 4, 500 IIT_I64 = 5, 501 IIT_F16 = 6, 502 IIT_F32 = 7, 503 IIT_F64 = 8, 504 IIT_V2 = 9, 505 IIT_V4 = 10, 506 IIT_V8 = 11, 507 IIT_V16 = 12, 508 IIT_V32 = 13, 509 IIT_PTR = 14, 510 IIT_ARG = 15, 511 512 // Values from 16+ are only encodable with the inefficient encoding. 513 IIT_V64 = 16, 514 IIT_MMX = 17, 515 IIT_TOKEN = 18, 516 IIT_METADATA = 19, 517 IIT_EMPTYSTRUCT = 20, 518 IIT_STRUCT2 = 21, 519 IIT_STRUCT3 = 22, 520 IIT_STRUCT4 = 23, 521 IIT_STRUCT5 = 24, 522 IIT_EXTEND_ARG = 25, 523 IIT_TRUNC_ARG = 26, 524 IIT_ANYPTR = 27, 525 IIT_V1 = 28, 526 IIT_VARARG = 29, 527 IIT_HALF_VEC_ARG = 30, 528 IIT_SAME_VEC_WIDTH_ARG = 31, 529 IIT_PTR_TO_ARG = 32, 530 IIT_VEC_OF_PTRS_TO_ELT = 33, 531 IIT_I128 = 34, 532 IIT_V512 = 35, 533 IIT_V1024 = 36 534}; 535 536 537static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, 538 SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) { 539 IIT_Info Info = IIT_Info(Infos[NextElt++]); 540 unsigned StructElts = 2; 541 using namespace Intrinsic; 542 543 switch (Info) { 544 case IIT_Done: 545 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0)); 546 return; 547 case IIT_VARARG: 548 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0)); 549 return; 550 case IIT_MMX: 551 OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0)); 552 return; 553 case IIT_TOKEN: 554 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0)); 555 return; 556 case IIT_METADATA: 557 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0)); 558 return; 559 case IIT_F16: 560 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0)); 561 return; 562 case IIT_F32: 563 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0)); 564 return; 565 case IIT_F64: 566 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0)); 567 return; 568 case IIT_I1: 569 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1)); 570 return; 571 case IIT_I8: 572 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8)); 573 return; 574 case IIT_I16: 575 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16)); 576 return; 577 case IIT_I32: 578 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32)); 579 return; 580 case IIT_I64: 581 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64)); 582 return; 583 case IIT_I128: 584 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128)); 585 return; 586 case IIT_V1: 587 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1)); 588 DecodeIITType(NextElt, Infos, OutputTable); 589 return; 590 case IIT_V2: 591 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2)); 592 DecodeIITType(NextElt, Infos, OutputTable); 593 return; 594 case IIT_V4: 595 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4)); 596 DecodeIITType(NextElt, Infos, OutputTable); 597 return; 598 case IIT_V8: 599 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8)); 600 DecodeIITType(NextElt, Infos, OutputTable); 601 return; 602 case IIT_V16: 603 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16)); 604 DecodeIITType(NextElt, Infos, OutputTable); 605 return; 606 case IIT_V32: 607 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32)); 608 DecodeIITType(NextElt, Infos, OutputTable); 609 return; 610 case IIT_V64: 611 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 64)); 612 DecodeIITType(NextElt, Infos, OutputTable); 613 return; 614 case IIT_V512: 615 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 512)); 616 DecodeIITType(NextElt, Infos, OutputTable); 617 return; 618 case IIT_V1024: 619 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1024)); 620 DecodeIITType(NextElt, Infos, OutputTable); 621 return; 622 case IIT_PTR: 623 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0)); 624 DecodeIITType(NextElt, Infos, OutputTable); 625 return; 626 case IIT_ANYPTR: { // [ANYPTR addrspace, subtype] 627 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 628 Infos[NextElt++])); 629 DecodeIITType(NextElt, Infos, OutputTable); 630 return; 631 } 632 case IIT_ARG: { 633 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 634 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo)); 635 return; 636 } 637 case IIT_EXTEND_ARG: { 638 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 639 OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument, 640 ArgInfo)); 641 return; 642 } 643 case IIT_TRUNC_ARG: { 644 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 645 OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument, 646 ArgInfo)); 647 return; 648 } 649 case IIT_HALF_VEC_ARG: { 650 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 651 OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument, 652 ArgInfo)); 653 return; 654 } 655 case IIT_SAME_VEC_WIDTH_ARG: { 656 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 657 OutputTable.push_back(IITDescriptor::get(IITDescriptor::SameVecWidthArgument, 658 ArgInfo)); 659 return; 660 } 661 case IIT_PTR_TO_ARG: { 662 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 663 OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument, 664 ArgInfo)); 665 return; 666 } 667 case IIT_VEC_OF_PTRS_TO_ELT: { 668 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 669 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VecOfPtrsToElt, 670 ArgInfo)); 671 return; 672 } 673 case IIT_EMPTYSTRUCT: 674 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0)); 675 return; 676 case IIT_STRUCT5: ++StructElts; // FALL THROUGH. 677 case IIT_STRUCT4: ++StructElts; // FALL THROUGH. 678 case IIT_STRUCT3: ++StructElts; // FALL THROUGH. 679 case IIT_STRUCT2: { 680 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts)); 681 682 for (unsigned i = 0; i != StructElts; ++i) 683 DecodeIITType(NextElt, Infos, OutputTable); 684 return; 685 } 686 } 687 llvm_unreachable("unhandled"); 688} 689 690 691#define GET_INTRINSIC_GENERATOR_GLOBAL 692#include "llvm/IR/Intrinsics.gen" 693#undef GET_INTRINSIC_GENERATOR_GLOBAL 694 695void Intrinsic::getIntrinsicInfoTableEntries(ID id, 696 SmallVectorImpl<IITDescriptor> &T){ 697 // Check to see if the intrinsic's type was expressible by the table. 698 unsigned TableVal = IIT_Table[id-1]; 699 700 // Decode the TableVal into an array of IITValues. 701 SmallVector<unsigned char, 8> IITValues; 702 ArrayRef<unsigned char> IITEntries; 703 unsigned NextElt = 0; 704 if ((TableVal >> 31) != 0) { 705 // This is an offset into the IIT_LongEncodingTable. 706 IITEntries = IIT_LongEncodingTable; 707 708 // Strip sentinel bit. 709 NextElt = (TableVal << 1) >> 1; 710 } else { 711 // Decode the TableVal into an array of IITValues. If the entry was encoded 712 // into a single word in the table itself, decode it now. 713 do { 714 IITValues.push_back(TableVal & 0xF); 715 TableVal >>= 4; 716 } while (TableVal); 717 718 IITEntries = IITValues; 719 NextElt = 0; 720 } 721 722 // Okay, decode the table into the output vector of IITDescriptors. 723 DecodeIITType(NextElt, IITEntries, T); 724 while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0) 725 DecodeIITType(NextElt, IITEntries, T); 726} 727 728 729static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos, 730 ArrayRef<Type*> Tys, LLVMContext &Context) { 731 using namespace Intrinsic; 732 IITDescriptor D = Infos.front(); 733 Infos = Infos.slice(1); 734 735 switch (D.Kind) { 736 case IITDescriptor::Void: return Type::getVoidTy(Context); 737 case IITDescriptor::VarArg: return Type::getVoidTy(Context); 738 case IITDescriptor::MMX: return Type::getX86_MMXTy(Context); 739 case IITDescriptor::Token: return Type::getTokenTy(Context); 740 case IITDescriptor::Metadata: return Type::getMetadataTy(Context); 741 case IITDescriptor::Half: return Type::getHalfTy(Context); 742 case IITDescriptor::Float: return Type::getFloatTy(Context); 743 case IITDescriptor::Double: return Type::getDoubleTy(Context); 744 745 case IITDescriptor::Integer: 746 return IntegerType::get(Context, D.Integer_Width); 747 case IITDescriptor::Vector: 748 return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width); 749 case IITDescriptor::Pointer: 750 return PointerType::get(DecodeFixedType(Infos, Tys, Context), 751 D.Pointer_AddressSpace); 752 case IITDescriptor::Struct: { 753 Type *Elts[5]; 754 assert(D.Struct_NumElements <= 5 && "Can't handle this yet"); 755 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 756 Elts[i] = DecodeFixedType(Infos, Tys, Context); 757 return StructType::get(Context, makeArrayRef(Elts,D.Struct_NumElements)); 758 } 759 760 case IITDescriptor::Argument: 761 return Tys[D.getArgumentNumber()]; 762 case IITDescriptor::ExtendArgument: { 763 Type *Ty = Tys[D.getArgumentNumber()]; 764 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 765 return VectorType::getExtendedElementVectorType(VTy); 766 767 return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth()); 768 } 769 case IITDescriptor::TruncArgument: { 770 Type *Ty = Tys[D.getArgumentNumber()]; 771 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 772 return VectorType::getTruncatedElementVectorType(VTy); 773 774 IntegerType *ITy = cast<IntegerType>(Ty); 775 assert(ITy->getBitWidth() % 2 == 0); 776 return IntegerType::get(Context, ITy->getBitWidth() / 2); 777 } 778 case IITDescriptor::HalfVecArgument: 779 return VectorType::getHalfElementsVectorType(cast<VectorType>( 780 Tys[D.getArgumentNumber()])); 781 case IITDescriptor::SameVecWidthArgument: { 782 Type *EltTy = DecodeFixedType(Infos, Tys, Context); 783 Type *Ty = Tys[D.getArgumentNumber()]; 784 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) { 785 return VectorType::get(EltTy, VTy->getNumElements()); 786 } 787 llvm_unreachable("unhandled"); 788 } 789 case IITDescriptor::PtrToArgument: { 790 Type *Ty = Tys[D.getArgumentNumber()]; 791 return PointerType::getUnqual(Ty); 792 } 793 case IITDescriptor::VecOfPtrsToElt: { 794 Type *Ty = Tys[D.getArgumentNumber()]; 795 VectorType *VTy = dyn_cast<VectorType>(Ty); 796 if (!VTy) 797 llvm_unreachable("Expected an argument of Vector Type"); 798 Type *EltTy = VTy->getVectorElementType(); 799 return VectorType::get(PointerType::getUnqual(EltTy), 800 VTy->getNumElements()); 801 } 802 } 803 llvm_unreachable("unhandled"); 804} 805 806 807 808FunctionType *Intrinsic::getType(LLVMContext &Context, 809 ID id, ArrayRef<Type*> Tys) { 810 SmallVector<IITDescriptor, 8> Table; 811 getIntrinsicInfoTableEntries(id, Table); 812 813 ArrayRef<IITDescriptor> TableRef = Table; 814 Type *ResultTy = DecodeFixedType(TableRef, Tys, Context); 815 816 SmallVector<Type*, 8> ArgTys; 817 while (!TableRef.empty()) 818 ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context)); 819 820 // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg 821 // If we see void type as the type of the last argument, it is vararg intrinsic 822 if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) { 823 ArgTys.pop_back(); 824 return FunctionType::get(ResultTy, ArgTys, true); 825 } 826 return FunctionType::get(ResultTy, ArgTys, false); 827} 828 829bool Intrinsic::isOverloaded(ID id) { 830#define GET_INTRINSIC_OVERLOAD_TABLE 831#include "llvm/IR/Intrinsics.gen" 832#undef GET_INTRINSIC_OVERLOAD_TABLE 833} 834 835bool Intrinsic::isLeaf(ID id) { 836 switch (id) { 837 default: 838 return true; 839 840 case Intrinsic::experimental_gc_statepoint: 841 case Intrinsic::experimental_patchpoint_void: 842 case Intrinsic::experimental_patchpoint_i64: 843 return false; 844 } 845} 846 847/// This defines the "Intrinsic::getAttributes(ID id)" method. 848#define GET_INTRINSIC_ATTRIBUTES 849#include "llvm/IR/Intrinsics.gen" 850#undef GET_INTRINSIC_ATTRIBUTES 851 852Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) { 853 // There can never be multiple globals with the same name of different types, 854 // because intrinsics must be a specific type. 855 return 856 cast<Function>(M->getOrInsertFunction(getName(id, Tys), 857 getType(M->getContext(), id, Tys))); 858} 859 860// This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method. 861#define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 862#include "llvm/IR/Intrinsics.gen" 863#undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 864 865// This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method. 866#define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN 867#include "llvm/IR/Intrinsics.gen" 868#undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN 869 870/// hasAddressTaken - returns true if there are any uses of this function 871/// other than direct calls or invokes to it. 872bool Function::hasAddressTaken(const User* *PutOffender) const { 873 for (const Use &U : uses()) { 874 const User *FU = U.getUser(); 875 if (isa<BlockAddress>(FU)) 876 continue; 877 if (!isa<CallInst>(FU) && !isa<InvokeInst>(FU)) 878 return PutOffender ? (*PutOffender = FU, true) : true; 879 ImmutableCallSite CS(cast<Instruction>(FU)); 880 if (!CS.isCallee(&U)) 881 return PutOffender ? (*PutOffender = FU, true) : true; 882 } 883 return false; 884} 885 886bool Function::isDefTriviallyDead() const { 887 // Check the linkage 888 if (!hasLinkOnceLinkage() && !hasLocalLinkage() && 889 !hasAvailableExternallyLinkage()) 890 return false; 891 892 // Check if the function is used by anything other than a blockaddress. 893 for (const User *U : users()) 894 if (!isa<BlockAddress>(U)) 895 return false; 896 897 return true; 898} 899 900/// callsFunctionThatReturnsTwice - Return true if the function has a call to 901/// setjmp or other function that gcc recognizes as "returning twice". 902bool Function::callsFunctionThatReturnsTwice() const { 903 for (const_inst_iterator 904 I = inst_begin(this), E = inst_end(this); I != E; ++I) { 905 ImmutableCallSite CS(&*I); 906 if (CS && CS.hasFnAttr(Attribute::ReturnsTwice)) 907 return true; 908 } 909 910 return false; 911} 912 913Constant *Function::getPersonalityFn() const { 914 assert(hasPersonalityFn() && getNumOperands()); 915 return cast<Constant>(Op<0>()); 916} 917 918void Function::setPersonalityFn(Constant *Fn) { 919 setHungoffOperand<0>(Fn); 920 setValueSubclassDataBit(3, Fn != nullptr); 921} 922 923Constant *Function::getPrefixData() const { 924 assert(hasPrefixData() && getNumOperands()); 925 return cast<Constant>(Op<1>()); 926} 927 928void Function::setPrefixData(Constant *PrefixData) { 929 setHungoffOperand<1>(PrefixData); 930 setValueSubclassDataBit(1, PrefixData != nullptr); 931} 932 933Constant *Function::getPrologueData() const { 934 assert(hasPrologueData() && getNumOperands()); 935 return cast<Constant>(Op<2>()); 936} 937 938void Function::setPrologueData(Constant *PrologueData) { 939 setHungoffOperand<2>(PrologueData); 940 setValueSubclassDataBit(2, PrologueData != nullptr); 941} 942 943void Function::allocHungoffUselist() { 944 // If we've already allocated a uselist, stop here. 945 if (getNumOperands()) 946 return; 947 948 allocHungoffUses(3, /*IsPhi=*/ false); 949 setNumHungOffUseOperands(3); 950 951 // Initialize the uselist with placeholder operands to allow traversal. 952 auto *CPN = ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0)); 953 Op<0>().set(CPN); 954 Op<1>().set(CPN); 955 Op<2>().set(CPN); 956} 957 958template <int Idx> 959void Function::setHungoffOperand(Constant *C) { 960 if (C) { 961 allocHungoffUselist(); 962 Op<Idx>().set(C); 963 } else if (getNumOperands()) { 964 Op<Idx>().set( 965 ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0))); 966 } 967} 968 969void Function::setValueSubclassDataBit(unsigned Bit, bool On) { 970 assert(Bit < 16 && "SubclassData contains only 16 bits"); 971 if (On) 972 setValueSubclassData(getSubclassDataFromValue() | (1 << Bit)); 973 else 974 setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit)); 975} 976 977void Function::setEntryCount(uint64_t Count) { 978 MDBuilder MDB(getContext()); 979 setMetadata(LLVMContext::MD_prof, MDB.createFunctionEntryCount(Count)); 980} 981 982Optional<uint64_t> Function::getEntryCount() const { 983 MDNode *MD = getMetadata(LLVMContext::MD_prof); 984 if (MD && MD->getOperand(0)) 985 if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) 986 if (MDS->getString().equals("function_entry_count")) { 987 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1)); 988 return CI->getValue().getZExtValue(); 989 } 990 return None; 991} 992