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 "SymbolTableListTraitsImpl.h" 16 #include "llvm/ADT/ArrayRef.h" 17 #include "llvm/ADT/DenseSet.h" 18 #include "llvm/ADT/None.h" 19 #include "llvm/ADT/STLExtras.h" 20 #include "llvm/ADT/SmallString.h" 21 #include "llvm/ADT/SmallVector.h" 22 #include "llvm/ADT/StringExtras.h" 23 #include "llvm/ADT/StringRef.h" 24 #include "llvm/IR/Argument.h" 25 #include "llvm/IR/Attributes.h" 26 #include "llvm/IR/BasicBlock.h" 27 #include "llvm/IR/CallSite.h" 28 #include "llvm/IR/Constant.h" 29 #include "llvm/IR/Constants.h" 30 #include "llvm/IR/DerivedTypes.h" 31 #include "llvm/IR/GlobalValue.h" 32 #include "llvm/IR/InstIterator.h" 33 #include "llvm/IR/Instruction.h" 34 #include "llvm/IR/Instructions.h" 35 #include "llvm/IR/IntrinsicInst.h" 36 #include "llvm/IR/Intrinsics.h" 37 #include "llvm/IR/LLVMContext.h" 38 #include "llvm/IR/MDBuilder.h" 39 #include "llvm/IR/Metadata.h" 40 #include "llvm/IR/Module.h" 41 #include "llvm/IR/SymbolTableListTraits.h" 42 #include "llvm/IR/Type.h" 43 #include "llvm/IR/Use.h" 44 #include "llvm/IR/User.h" 45 #include "llvm/IR/Value.h" 46 #include "llvm/IR/ValueSymbolTable.h" 47 #include "llvm/Support/Casting.h" 48 #include "llvm/Support/Compiler.h" 49 #include "llvm/Support/ErrorHandling.h" 50 #include <algorithm> 51 #include <cassert> 52 #include <cstddef> 53 #include <cstdint> 54 #include <cstring> 55 #include <string> 56 57 using namespace llvm; 58 using ProfileCount = Function::ProfileCount; 59 60 // Explicit instantiations of SymbolTableListTraits since some of the methods 61 // are not in the public header file... 62 template class llvm::SymbolTableListTraits<BasicBlock>; 63 64 //===----------------------------------------------------------------------===// 65 // Argument Implementation 66 //===----------------------------------------------------------------------===// 67 68 Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo) 69 : Value(Ty, Value::ArgumentVal), Parent(Par), ArgNo(ArgNo) { 70 setName(Name); 71 } 72 73 void Argument::setParent(Function *parent) { 74 Parent = parent; 75 } 76 77 bool Argument::hasNonNullAttr() const { 78 if (!getType()->isPointerTy()) return false; 79 if (getParent()->hasParamAttribute(getArgNo(), Attribute::NonNull)) 80 return true; 81 else if (getDereferenceableBytes() > 0 && 82 getType()->getPointerAddressSpace() == 0) 83 return true; 84 return false; 85 } 86 87 bool Argument::hasByValAttr() const { 88 if (!getType()->isPointerTy()) return false; 89 return hasAttribute(Attribute::ByVal); 90 } 91 92 bool Argument::hasSwiftSelfAttr() const { 93 return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftSelf); 94 } 95 96 bool Argument::hasSwiftErrorAttr() const { 97 return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftError); 98 } 99 100 bool Argument::hasInAllocaAttr() const { 101 if (!getType()->isPointerTy()) return false; 102 return hasAttribute(Attribute::InAlloca); 103 } 104 105 bool Argument::hasByValOrInAllocaAttr() const { 106 if (!getType()->isPointerTy()) return false; 107 AttributeList Attrs = getParent()->getAttributes(); 108 return Attrs.hasParamAttribute(getArgNo(), Attribute::ByVal) || 109 Attrs.hasParamAttribute(getArgNo(), Attribute::InAlloca); 110 } 111 112 unsigned Argument::getParamAlignment() const { 113 assert(getType()->isPointerTy() && "Only pointers have alignments"); 114 return getParent()->getParamAlignment(getArgNo()); 115 } 116 117 uint64_t Argument::getDereferenceableBytes() const { 118 assert(getType()->isPointerTy() && 119 "Only pointers have dereferenceable bytes"); 120 return getParent()->getParamDereferenceableBytes(getArgNo()); 121 } 122 123 uint64_t Argument::getDereferenceableOrNullBytes() const { 124 assert(getType()->isPointerTy() && 125 "Only pointers have dereferenceable bytes"); 126 return getParent()->getParamDereferenceableOrNullBytes(getArgNo()); 127 } 128 129 bool Argument::hasNestAttr() const { 130 if (!getType()->isPointerTy()) return false; 131 return hasAttribute(Attribute::Nest); 132 } 133 134 bool Argument::hasNoAliasAttr() const { 135 if (!getType()->isPointerTy()) return false; 136 return hasAttribute(Attribute::NoAlias); 137 } 138 139 bool Argument::hasNoCaptureAttr() const { 140 if (!getType()->isPointerTy()) return false; 141 return hasAttribute(Attribute::NoCapture); 142 } 143 144 bool Argument::hasStructRetAttr() const { 145 if (!getType()->isPointerTy()) return false; 146 return hasAttribute(Attribute::StructRet); 147 } 148 149 bool Argument::hasReturnedAttr() const { 150 return hasAttribute(Attribute::Returned); 151 } 152 153 bool Argument::hasZExtAttr() const { 154 return hasAttribute(Attribute::ZExt); 155 } 156 157 bool Argument::hasSExtAttr() const { 158 return hasAttribute(Attribute::SExt); 159 } 160 161 bool Argument::onlyReadsMemory() const { 162 AttributeList Attrs = getParent()->getAttributes(); 163 return Attrs.hasParamAttribute(getArgNo(), Attribute::ReadOnly) || 164 Attrs.hasParamAttribute(getArgNo(), Attribute::ReadNone); 165 } 166 167 void Argument::addAttrs(AttrBuilder &B) { 168 AttributeList AL = getParent()->getAttributes(); 169 AL = AL.addParamAttributes(Parent->getContext(), getArgNo(), B); 170 getParent()->setAttributes(AL); 171 } 172 173 void Argument::addAttr(Attribute::AttrKind Kind) { 174 getParent()->addParamAttr(getArgNo(), Kind); 175 } 176 177 void Argument::addAttr(Attribute Attr) { 178 getParent()->addParamAttr(getArgNo(), Attr); 179 } 180 181 void Argument::removeAttr(Attribute::AttrKind Kind) { 182 getParent()->removeParamAttr(getArgNo(), Kind); 183 } 184 185 bool Argument::hasAttribute(Attribute::AttrKind Kind) const { 186 return getParent()->hasParamAttribute(getArgNo(), Kind); 187 } 188 189 //===----------------------------------------------------------------------===// 190 // Helper Methods in Function 191 //===----------------------------------------------------------------------===// 192 193 LLVMContext &Function::getContext() const { 194 return getType()->getContext(); 195 } 196 197 void Function::removeFromParent() { 198 getParent()->getFunctionList().remove(getIterator()); 199 } 200 201 void Function::eraseFromParent() { 202 getParent()->getFunctionList().erase(getIterator()); 203 } 204 205 //===----------------------------------------------------------------------===// 206 // Function Implementation 207 //===----------------------------------------------------------------------===// 208 209 Function::Function(FunctionType *Ty, LinkageTypes Linkage, const Twine &name, 210 Module *ParentModule) 211 : GlobalObject(Ty, Value::FunctionVal, 212 OperandTraits<Function>::op_begin(this), 0, Linkage, name), 213 NumArgs(Ty->getNumParams()) { 214 assert(FunctionType::isValidReturnType(getReturnType()) && 215 "invalid return type"); 216 setGlobalObjectSubClassData(0); 217 218 // We only need a symbol table for a function if the context keeps value names 219 if (!getContext().shouldDiscardValueNames()) 220 SymTab = make_unique<ValueSymbolTable>(); 221 222 // If the function has arguments, mark them as lazily built. 223 if (Ty->getNumParams()) 224 setValueSubclassData(1); // Set the "has lazy arguments" bit. 225 226 if (ParentModule) 227 ParentModule->getFunctionList().push_back(this); 228 229 HasLLVMReservedName = getName().startswith("llvm."); 230 // Ensure intrinsics have the right parameter attributes. 231 // Note, the IntID field will have been set in Value::setName if this function 232 // name is a valid intrinsic ID. 233 if (IntID) 234 setAttributes(Intrinsic::getAttributes(getContext(), IntID)); 235 } 236 237 Function::~Function() { 238 dropAllReferences(); // After this it is safe to delete instructions. 239 240 // Delete all of the method arguments and unlink from symbol table... 241 if (Arguments) 242 clearArguments(); 243 244 // Remove the function from the on-the-side GC table. 245 clearGC(); 246 } 247 248 void Function::BuildLazyArguments() const { 249 // Create the arguments vector, all arguments start out unnamed. 250 auto *FT = getFunctionType(); 251 if (NumArgs > 0) { 252 Arguments = std::allocator<Argument>().allocate(NumArgs); 253 for (unsigned i = 0, e = NumArgs; i != e; ++i) { 254 Type *ArgTy = FT->getParamType(i); 255 assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!"); 256 new (Arguments + i) Argument(ArgTy, "", const_cast<Function *>(this), i); 257 } 258 } 259 260 // Clear the lazy arguments bit. 261 unsigned SDC = getSubclassDataFromValue(); 262 const_cast<Function*>(this)->setValueSubclassData(SDC &= ~(1<<0)); 263 assert(!hasLazyArguments()); 264 } 265 266 static MutableArrayRef<Argument> makeArgArray(Argument *Args, size_t Count) { 267 return MutableArrayRef<Argument>(Args, Count); 268 } 269 270 void Function::clearArguments() { 271 for (Argument &A : makeArgArray(Arguments, NumArgs)) { 272 A.setName(""); 273 A.~Argument(); 274 } 275 std::allocator<Argument>().deallocate(Arguments, NumArgs); 276 Arguments = nullptr; 277 } 278 279 void Function::stealArgumentListFrom(Function &Src) { 280 assert(isDeclaration() && "Expected no references to current arguments"); 281 282 // Drop the current arguments, if any, and set the lazy argument bit. 283 if (!hasLazyArguments()) { 284 assert(llvm::all_of(makeArgArray(Arguments, NumArgs), 285 [](const Argument &A) { return A.use_empty(); }) && 286 "Expected arguments to be unused in declaration"); 287 clearArguments(); 288 setValueSubclassData(getSubclassDataFromValue() | (1 << 0)); 289 } 290 291 // Nothing to steal if Src has lazy arguments. 292 if (Src.hasLazyArguments()) 293 return; 294 295 // Steal arguments from Src, and fix the lazy argument bits. 296 assert(arg_size() == Src.arg_size()); 297 Arguments = Src.Arguments; 298 Src.Arguments = nullptr; 299 for (Argument &A : makeArgArray(Arguments, NumArgs)) { 300 // FIXME: This does the work of transferNodesFromList inefficiently. 301 SmallString<128> Name; 302 if (A.hasName()) 303 Name = A.getName(); 304 if (!Name.empty()) 305 A.setName(""); 306 A.setParent(this); 307 if (!Name.empty()) 308 A.setName(Name); 309 } 310 311 setValueSubclassData(getSubclassDataFromValue() & ~(1 << 0)); 312 assert(!hasLazyArguments()); 313 Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0)); 314 } 315 316 // dropAllReferences() - This function causes all the subinstructions to "let 317 // go" of all references that they are maintaining. This allows one to 318 // 'delete' a whole class at a time, even though there may be circular 319 // references... first all references are dropped, and all use counts go to 320 // zero. Then everything is deleted for real. Note that no operations are 321 // valid on an object that has "dropped all references", except operator 322 // delete. 323 // 324 void Function::dropAllReferences() { 325 setIsMaterializable(false); 326 327 for (BasicBlock &BB : *this) 328 BB.dropAllReferences(); 329 330 // Delete all basic blocks. They are now unused, except possibly by 331 // blockaddresses, but BasicBlock's destructor takes care of those. 332 while (!BasicBlocks.empty()) 333 BasicBlocks.begin()->eraseFromParent(); 334 335 // Drop uses of any optional data (real or placeholder). 336 if (getNumOperands()) { 337 User::dropAllReferences(); 338 setNumHungOffUseOperands(0); 339 setValueSubclassData(getSubclassDataFromValue() & ~0xe); 340 } 341 342 // Metadata is stored in a side-table. 343 clearMetadata(); 344 } 345 346 void Function::addAttribute(unsigned i, Attribute::AttrKind Kind) { 347 AttributeList PAL = getAttributes(); 348 PAL = PAL.addAttribute(getContext(), i, Kind); 349 setAttributes(PAL); 350 } 351 352 void Function::addAttribute(unsigned i, Attribute Attr) { 353 AttributeList PAL = getAttributes(); 354 PAL = PAL.addAttribute(getContext(), i, Attr); 355 setAttributes(PAL); 356 } 357 358 void Function::addAttributes(unsigned i, const AttrBuilder &Attrs) { 359 AttributeList PAL = getAttributes(); 360 PAL = PAL.addAttributes(getContext(), i, Attrs); 361 setAttributes(PAL); 362 } 363 364 void Function::addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) { 365 AttributeList PAL = getAttributes(); 366 PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind); 367 setAttributes(PAL); 368 } 369 370 void Function::addParamAttr(unsigned ArgNo, Attribute Attr) { 371 AttributeList PAL = getAttributes(); 372 PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr); 373 setAttributes(PAL); 374 } 375 376 void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) { 377 AttributeList PAL = getAttributes(); 378 PAL = PAL.addParamAttributes(getContext(), ArgNo, Attrs); 379 setAttributes(PAL); 380 } 381 382 void Function::removeAttribute(unsigned i, Attribute::AttrKind Kind) { 383 AttributeList PAL = getAttributes(); 384 PAL = PAL.removeAttribute(getContext(), i, Kind); 385 setAttributes(PAL); 386 } 387 388 void Function::removeAttribute(unsigned i, StringRef Kind) { 389 AttributeList PAL = getAttributes(); 390 PAL = PAL.removeAttribute(getContext(), i, Kind); 391 setAttributes(PAL); 392 } 393 394 void Function::removeAttributes(unsigned i, const AttrBuilder &Attrs) { 395 AttributeList PAL = getAttributes(); 396 PAL = PAL.removeAttributes(getContext(), i, Attrs); 397 setAttributes(PAL); 398 } 399 400 void Function::removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) { 401 AttributeList PAL = getAttributes(); 402 PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind); 403 setAttributes(PAL); 404 } 405 406 void Function::removeParamAttr(unsigned ArgNo, StringRef Kind) { 407 AttributeList PAL = getAttributes(); 408 PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind); 409 setAttributes(PAL); 410 } 411 412 void Function::removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) { 413 AttributeList PAL = getAttributes(); 414 PAL = PAL.removeParamAttributes(getContext(), ArgNo, Attrs); 415 setAttributes(PAL); 416 } 417 418 void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) { 419 AttributeList PAL = getAttributes(); 420 PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes); 421 setAttributes(PAL); 422 } 423 424 void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) { 425 AttributeList PAL = getAttributes(); 426 PAL = PAL.addDereferenceableParamAttr(getContext(), ArgNo, Bytes); 427 setAttributes(PAL); 428 } 429 430 void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) { 431 AttributeList PAL = getAttributes(); 432 PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes); 433 setAttributes(PAL); 434 } 435 436 void Function::addDereferenceableOrNullParamAttr(unsigned ArgNo, 437 uint64_t Bytes) { 438 AttributeList PAL = getAttributes(); 439 PAL = PAL.addDereferenceableOrNullParamAttr(getContext(), ArgNo, Bytes); 440 setAttributes(PAL); 441 } 442 443 const std::string &Function::getGC() const { 444 assert(hasGC() && "Function has no collector"); 445 return getContext().getGC(*this); 446 } 447 448 void Function::setGC(std::string Str) { 449 setValueSubclassDataBit(14, !Str.empty()); 450 getContext().setGC(*this, std::move(Str)); 451 } 452 453 void Function::clearGC() { 454 if (!hasGC()) 455 return; 456 getContext().deleteGC(*this); 457 setValueSubclassDataBit(14, false); 458 } 459 460 /// Copy all additional attributes (those not needed to create a Function) from 461 /// the Function Src to this one. 462 void Function::copyAttributesFrom(const Function *Src) { 463 GlobalObject::copyAttributesFrom(Src); 464 setCallingConv(Src->getCallingConv()); 465 setAttributes(Src->getAttributes()); 466 if (Src->hasGC()) 467 setGC(Src->getGC()); 468 else 469 clearGC(); 470 if (Src->hasPersonalityFn()) 471 setPersonalityFn(Src->getPersonalityFn()); 472 if (Src->hasPrefixData()) 473 setPrefixData(Src->getPrefixData()); 474 if (Src->hasPrologueData()) 475 setPrologueData(Src->getPrologueData()); 476 } 477 478 /// Table of string intrinsic names indexed by enum value. 479 static const char * const IntrinsicNameTable[] = { 480 "not_intrinsic", 481 #define GET_INTRINSIC_NAME_TABLE 482 #include "llvm/IR/Intrinsics.inc" 483 #undef GET_INTRINSIC_NAME_TABLE 484 }; 485 486 /// Table of per-target intrinsic name tables. 487 #define GET_INTRINSIC_TARGET_DATA 488 #include "llvm/IR/Intrinsics.inc" 489 #undef GET_INTRINSIC_TARGET_DATA 490 491 /// Find the segment of \c IntrinsicNameTable for intrinsics with the same 492 /// target as \c Name, or the generic table if \c Name is not target specific. 493 /// 494 /// Returns the relevant slice of \c IntrinsicNameTable 495 static ArrayRef<const char *> findTargetSubtable(StringRef Name) { 496 assert(Name.startswith("llvm.")); 497 498 ArrayRef<IntrinsicTargetInfo> Targets(TargetInfos); 499 // Drop "llvm." and take the first dotted component. That will be the target 500 // if this is target specific. 501 StringRef Target = Name.drop_front(5).split('.').first; 502 auto It = std::lower_bound(Targets.begin(), Targets.end(), Target, 503 [](const IntrinsicTargetInfo &TI, 504 StringRef Target) { return TI.Name < Target; }); 505 // We've either found the target or just fall back to the generic set, which 506 // is always first. 507 const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0]; 508 return makeArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count); 509 } 510 511 /// This does the actual lookup of an intrinsic ID which 512 /// matches the given function name. 513 Intrinsic::ID Function::lookupIntrinsicID(StringRef Name) { 514 ArrayRef<const char *> NameTable = findTargetSubtable(Name); 515 int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name); 516 if (Idx == -1) 517 return Intrinsic::not_intrinsic; 518 519 // Intrinsic IDs correspond to the location in IntrinsicNameTable, but we have 520 // an index into a sub-table. 521 int Adjust = NameTable.data() - IntrinsicNameTable; 522 Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + Adjust); 523 524 // If the intrinsic is not overloaded, require an exact match. If it is 525 // overloaded, require either exact or prefix match. 526 const auto MatchSize = strlen(NameTable[Idx]); 527 assert(Name.size() >= MatchSize && "Expected either exact or prefix match"); 528 bool IsExactMatch = Name.size() == MatchSize; 529 return IsExactMatch || isOverloaded(ID) ? ID : Intrinsic::not_intrinsic; 530 } 531 532 void Function::recalculateIntrinsicID() { 533 StringRef Name = getName(); 534 if (!Name.startswith("llvm.")) { 535 HasLLVMReservedName = false; 536 IntID = Intrinsic::not_intrinsic; 537 return; 538 } 539 HasLLVMReservedName = true; 540 IntID = lookupIntrinsicID(Name); 541 } 542 543 /// Returns a stable mangling for the type specified for use in the name 544 /// mangling scheme used by 'any' types in intrinsic signatures. The mangling 545 /// of named types is simply their name. Manglings for unnamed types consist 546 /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions) 547 /// combined with the mangling of their component types. A vararg function 548 /// type will have a suffix of 'vararg'. Since function types can contain 549 /// other function types, we close a function type mangling with suffix 'f' 550 /// which can't be confused with it's prefix. This ensures we don't have 551 /// collisions between two unrelated function types. Otherwise, you might 552 /// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.) 553 /// 554 static std::string getMangledTypeStr(Type* Ty) { 555 std::string Result; 556 if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) { 557 Result += "p" + utostr(PTyp->getAddressSpace()) + 558 getMangledTypeStr(PTyp->getElementType()); 559 } else if (ArrayType* ATyp = dyn_cast<ArrayType>(Ty)) { 560 Result += "a" + utostr(ATyp->getNumElements()) + 561 getMangledTypeStr(ATyp->getElementType()); 562 } else if (StructType *STyp = dyn_cast<StructType>(Ty)) { 563 if (!STyp->isLiteral()) { 564 Result += "s_"; 565 Result += STyp->getName(); 566 } else { 567 Result += "sl_"; 568 for (auto Elem : STyp->elements()) 569 Result += getMangledTypeStr(Elem); 570 } 571 // Ensure nested structs are distinguishable. 572 Result += "s"; 573 } else if (FunctionType *FT = dyn_cast<FunctionType>(Ty)) { 574 Result += "f_" + getMangledTypeStr(FT->getReturnType()); 575 for (size_t i = 0; i < FT->getNumParams(); i++) 576 Result += getMangledTypeStr(FT->getParamType(i)); 577 if (FT->isVarArg()) 578 Result += "vararg"; 579 // Ensure nested function types are distinguishable. 580 Result += "f"; 581 } else if (isa<VectorType>(Ty)) { 582 Result += "v" + utostr(Ty->getVectorNumElements()) + 583 getMangledTypeStr(Ty->getVectorElementType()); 584 } else if (Ty) { 585 switch (Ty->getTypeID()) { 586 default: llvm_unreachable("Unhandled type"); 587 case Type::VoidTyID: Result += "isVoid"; break; 588 case Type::MetadataTyID: Result += "Metadata"; break; 589 case Type::HalfTyID: Result += "f16"; break; 590 case Type::FloatTyID: Result += "f32"; break; 591 case Type::DoubleTyID: Result += "f64"; break; 592 case Type::X86_FP80TyID: Result += "f80"; break; 593 case Type::FP128TyID: Result += "f128"; break; 594 case Type::PPC_FP128TyID: Result += "ppcf128"; break; 595 case Type::X86_MMXTyID: Result += "x86mmx"; break; 596 case Type::IntegerTyID: 597 Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth()); 598 break; 599 } 600 } 601 return Result; 602 } 603 604 StringRef Intrinsic::getName(ID id) { 605 assert(id < num_intrinsics && "Invalid intrinsic ID!"); 606 assert(!isOverloaded(id) && 607 "This version of getName does not support overloading"); 608 return IntrinsicNameTable[id]; 609 } 610 611 std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) { 612 assert(id < num_intrinsics && "Invalid intrinsic ID!"); 613 std::string Result(IntrinsicNameTable[id]); 614 for (Type *Ty : Tys) { 615 Result += "." + getMangledTypeStr(Ty); 616 } 617 return Result; 618 } 619 620 /// IIT_Info - These are enumerators that describe the entries returned by the 621 /// getIntrinsicInfoTableEntries function. 622 /// 623 /// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter! 624 enum IIT_Info { 625 // Common values should be encoded with 0-15. 626 IIT_Done = 0, 627 IIT_I1 = 1, 628 IIT_I8 = 2, 629 IIT_I16 = 3, 630 IIT_I32 = 4, 631 IIT_I64 = 5, 632 IIT_F16 = 6, 633 IIT_F32 = 7, 634 IIT_F64 = 8, 635 IIT_V2 = 9, 636 IIT_V4 = 10, 637 IIT_V8 = 11, 638 IIT_V16 = 12, 639 IIT_V32 = 13, 640 IIT_PTR = 14, 641 IIT_ARG = 15, 642 643 // Values from 16+ are only encodable with the inefficient encoding. 644 IIT_V64 = 16, 645 IIT_MMX = 17, 646 IIT_TOKEN = 18, 647 IIT_METADATA = 19, 648 IIT_EMPTYSTRUCT = 20, 649 IIT_STRUCT2 = 21, 650 IIT_STRUCT3 = 22, 651 IIT_STRUCT4 = 23, 652 IIT_STRUCT5 = 24, 653 IIT_EXTEND_ARG = 25, 654 IIT_TRUNC_ARG = 26, 655 IIT_ANYPTR = 27, 656 IIT_V1 = 28, 657 IIT_VARARG = 29, 658 IIT_HALF_VEC_ARG = 30, 659 IIT_SAME_VEC_WIDTH_ARG = 31, 660 IIT_PTR_TO_ARG = 32, 661 IIT_PTR_TO_ELT = 33, 662 IIT_VEC_OF_ANYPTRS_TO_ELT = 34, 663 IIT_I128 = 35, 664 IIT_V512 = 36, 665 IIT_V1024 = 37, 666 IIT_STRUCT6 = 38, 667 IIT_STRUCT7 = 39, 668 IIT_STRUCT8 = 40 669 }; 670 671 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, 672 SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) { 673 using namespace Intrinsic; 674 675 IIT_Info Info = IIT_Info(Infos[NextElt++]); 676 unsigned StructElts = 2; 677 678 switch (Info) { 679 case IIT_Done: 680 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0)); 681 return; 682 case IIT_VARARG: 683 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0)); 684 return; 685 case IIT_MMX: 686 OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0)); 687 return; 688 case IIT_TOKEN: 689 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0)); 690 return; 691 case IIT_METADATA: 692 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0)); 693 return; 694 case IIT_F16: 695 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0)); 696 return; 697 case IIT_F32: 698 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0)); 699 return; 700 case IIT_F64: 701 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0)); 702 return; 703 case IIT_I1: 704 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1)); 705 return; 706 case IIT_I8: 707 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8)); 708 return; 709 case IIT_I16: 710 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16)); 711 return; 712 case IIT_I32: 713 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32)); 714 return; 715 case IIT_I64: 716 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64)); 717 return; 718 case IIT_I128: 719 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128)); 720 return; 721 case IIT_V1: 722 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1)); 723 DecodeIITType(NextElt, Infos, OutputTable); 724 return; 725 case IIT_V2: 726 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2)); 727 DecodeIITType(NextElt, Infos, OutputTable); 728 return; 729 case IIT_V4: 730 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4)); 731 DecodeIITType(NextElt, Infos, OutputTable); 732 return; 733 case IIT_V8: 734 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8)); 735 DecodeIITType(NextElt, Infos, OutputTable); 736 return; 737 case IIT_V16: 738 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16)); 739 DecodeIITType(NextElt, Infos, OutputTable); 740 return; 741 case IIT_V32: 742 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32)); 743 DecodeIITType(NextElt, Infos, OutputTable); 744 return; 745 case IIT_V64: 746 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 64)); 747 DecodeIITType(NextElt, Infos, OutputTable); 748 return; 749 case IIT_V512: 750 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 512)); 751 DecodeIITType(NextElt, Infos, OutputTable); 752 return; 753 case IIT_V1024: 754 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1024)); 755 DecodeIITType(NextElt, Infos, OutputTable); 756 return; 757 case IIT_PTR: 758 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0)); 759 DecodeIITType(NextElt, Infos, OutputTable); 760 return; 761 case IIT_ANYPTR: { // [ANYPTR addrspace, subtype] 762 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 763 Infos[NextElt++])); 764 DecodeIITType(NextElt, Infos, OutputTable); 765 return; 766 } 767 case IIT_ARG: { 768 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 769 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo)); 770 return; 771 } 772 case IIT_EXTEND_ARG: { 773 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 774 OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument, 775 ArgInfo)); 776 return; 777 } 778 case IIT_TRUNC_ARG: { 779 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 780 OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument, 781 ArgInfo)); 782 return; 783 } 784 case IIT_HALF_VEC_ARG: { 785 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 786 OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument, 787 ArgInfo)); 788 return; 789 } 790 case IIT_SAME_VEC_WIDTH_ARG: { 791 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 792 OutputTable.push_back(IITDescriptor::get(IITDescriptor::SameVecWidthArgument, 793 ArgInfo)); 794 return; 795 } 796 case IIT_PTR_TO_ARG: { 797 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 798 OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument, 799 ArgInfo)); 800 return; 801 } 802 case IIT_PTR_TO_ELT: { 803 unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 804 OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToElt, ArgInfo)); 805 return; 806 } 807 case IIT_VEC_OF_ANYPTRS_TO_ELT: { 808 unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 809 unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 810 OutputTable.push_back( 811 IITDescriptor::get(IITDescriptor::VecOfAnyPtrsToElt, ArgNo, RefNo)); 812 return; 813 } 814 case IIT_EMPTYSTRUCT: 815 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0)); 816 return; 817 case IIT_STRUCT8: ++StructElts; LLVM_FALLTHROUGH; 818 case IIT_STRUCT7: ++StructElts; LLVM_FALLTHROUGH; 819 case IIT_STRUCT6: ++StructElts; LLVM_FALLTHROUGH; 820 case IIT_STRUCT5: ++StructElts; LLVM_FALLTHROUGH; 821 case IIT_STRUCT4: ++StructElts; LLVM_FALLTHROUGH; 822 case IIT_STRUCT3: ++StructElts; LLVM_FALLTHROUGH; 823 case IIT_STRUCT2: { 824 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts)); 825 826 for (unsigned i = 0; i != StructElts; ++i) 827 DecodeIITType(NextElt, Infos, OutputTable); 828 return; 829 } 830 } 831 llvm_unreachable("unhandled"); 832 } 833 834 #define GET_INTRINSIC_GENERATOR_GLOBAL 835 #include "llvm/IR/Intrinsics.inc" 836 #undef GET_INTRINSIC_GENERATOR_GLOBAL 837 838 void Intrinsic::getIntrinsicInfoTableEntries(ID id, 839 SmallVectorImpl<IITDescriptor> &T){ 840 // Check to see if the intrinsic's type was expressible by the table. 841 unsigned TableVal = IIT_Table[id-1]; 842 843 // Decode the TableVal into an array of IITValues. 844 SmallVector<unsigned char, 8> IITValues; 845 ArrayRef<unsigned char> IITEntries; 846 unsigned NextElt = 0; 847 if ((TableVal >> 31) != 0) { 848 // This is an offset into the IIT_LongEncodingTable. 849 IITEntries = IIT_LongEncodingTable; 850 851 // Strip sentinel bit. 852 NextElt = (TableVal << 1) >> 1; 853 } else { 854 // Decode the TableVal into an array of IITValues. If the entry was encoded 855 // into a single word in the table itself, decode it now. 856 do { 857 IITValues.push_back(TableVal & 0xF); 858 TableVal >>= 4; 859 } while (TableVal); 860 861 IITEntries = IITValues; 862 NextElt = 0; 863 } 864 865 // Okay, decode the table into the output vector of IITDescriptors. 866 DecodeIITType(NextElt, IITEntries, T); 867 while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0) 868 DecodeIITType(NextElt, IITEntries, T); 869 } 870 871 static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos, 872 ArrayRef<Type*> Tys, LLVMContext &Context) { 873 using namespace Intrinsic; 874 875 IITDescriptor D = Infos.front(); 876 Infos = Infos.slice(1); 877 878 switch (D.Kind) { 879 case IITDescriptor::Void: return Type::getVoidTy(Context); 880 case IITDescriptor::VarArg: return Type::getVoidTy(Context); 881 case IITDescriptor::MMX: return Type::getX86_MMXTy(Context); 882 case IITDescriptor::Token: return Type::getTokenTy(Context); 883 case IITDescriptor::Metadata: return Type::getMetadataTy(Context); 884 case IITDescriptor::Half: return Type::getHalfTy(Context); 885 case IITDescriptor::Float: return Type::getFloatTy(Context); 886 case IITDescriptor::Double: return Type::getDoubleTy(Context); 887 888 case IITDescriptor::Integer: 889 return IntegerType::get(Context, D.Integer_Width); 890 case IITDescriptor::Vector: 891 return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width); 892 case IITDescriptor::Pointer: 893 return PointerType::get(DecodeFixedType(Infos, Tys, Context), 894 D.Pointer_AddressSpace); 895 case IITDescriptor::Struct: { 896 SmallVector<Type *, 8> Elts; 897 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 898 Elts.push_back(DecodeFixedType(Infos, Tys, Context)); 899 return StructType::get(Context, Elts); 900 } 901 case IITDescriptor::Argument: 902 return Tys[D.getArgumentNumber()]; 903 case IITDescriptor::ExtendArgument: { 904 Type *Ty = Tys[D.getArgumentNumber()]; 905 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 906 return VectorType::getExtendedElementVectorType(VTy); 907 908 return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth()); 909 } 910 case IITDescriptor::TruncArgument: { 911 Type *Ty = Tys[D.getArgumentNumber()]; 912 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 913 return VectorType::getTruncatedElementVectorType(VTy); 914 915 IntegerType *ITy = cast<IntegerType>(Ty); 916 assert(ITy->getBitWidth() % 2 == 0); 917 return IntegerType::get(Context, ITy->getBitWidth() / 2); 918 } 919 case IITDescriptor::HalfVecArgument: 920 return VectorType::getHalfElementsVectorType(cast<VectorType>( 921 Tys[D.getArgumentNumber()])); 922 case IITDescriptor::SameVecWidthArgument: { 923 Type *EltTy = DecodeFixedType(Infos, Tys, Context); 924 Type *Ty = Tys[D.getArgumentNumber()]; 925 if (VectorType *VTy = dyn_cast<VectorType>(Ty)) { 926 return VectorType::get(EltTy, VTy->getNumElements()); 927 } 928 llvm_unreachable("unhandled"); 929 } 930 case IITDescriptor::PtrToArgument: { 931 Type *Ty = Tys[D.getArgumentNumber()]; 932 return PointerType::getUnqual(Ty); 933 } 934 case IITDescriptor::PtrToElt: { 935 Type *Ty = Tys[D.getArgumentNumber()]; 936 VectorType *VTy = dyn_cast<VectorType>(Ty); 937 if (!VTy) 938 llvm_unreachable("Expected an argument of Vector Type"); 939 Type *EltTy = VTy->getVectorElementType(); 940 return PointerType::getUnqual(EltTy); 941 } 942 case IITDescriptor::VecOfAnyPtrsToElt: 943 // Return the overloaded type (which determines the pointers address space) 944 return Tys[D.getOverloadArgNumber()]; 945 } 946 llvm_unreachable("unhandled"); 947 } 948 949 FunctionType *Intrinsic::getType(LLVMContext &Context, 950 ID id, ArrayRef<Type*> Tys) { 951 SmallVector<IITDescriptor, 8> Table; 952 getIntrinsicInfoTableEntries(id, Table); 953 954 ArrayRef<IITDescriptor> TableRef = Table; 955 Type *ResultTy = DecodeFixedType(TableRef, Tys, Context); 956 957 SmallVector<Type*, 8> ArgTys; 958 while (!TableRef.empty()) 959 ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context)); 960 961 // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg 962 // If we see void type as the type of the last argument, it is vararg intrinsic 963 if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) { 964 ArgTys.pop_back(); 965 return FunctionType::get(ResultTy, ArgTys, true); 966 } 967 return FunctionType::get(ResultTy, ArgTys, false); 968 } 969 970 bool Intrinsic::isOverloaded(ID id) { 971 #define GET_INTRINSIC_OVERLOAD_TABLE 972 #include "llvm/IR/Intrinsics.inc" 973 #undef GET_INTRINSIC_OVERLOAD_TABLE 974 } 975 976 bool Intrinsic::isLeaf(ID id) { 977 switch (id) { 978 default: 979 return true; 980 981 case Intrinsic::experimental_gc_statepoint: 982 case Intrinsic::experimental_patchpoint_void: 983 case Intrinsic::experimental_patchpoint_i64: 984 return false; 985 } 986 } 987 988 /// This defines the "Intrinsic::getAttributes(ID id)" method. 989 #define GET_INTRINSIC_ATTRIBUTES 990 #include "llvm/IR/Intrinsics.inc" 991 #undef GET_INTRINSIC_ATTRIBUTES 992 993 Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) { 994 // There can never be multiple globals with the same name of different types, 995 // because intrinsics must be a specific type. 996 return 997 cast<Function>(M->getOrInsertFunction(getName(id, Tys), 998 getType(M->getContext(), id, Tys))); 999 } 1000 1001 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method. 1002 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 1003 #include "llvm/IR/Intrinsics.inc" 1004 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 1005 1006 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method. 1007 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN 1008 #include "llvm/IR/Intrinsics.inc" 1009 #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN 1010 1011 bool Intrinsic::matchIntrinsicType(Type *Ty, ArrayRef<Intrinsic::IITDescriptor> &Infos, 1012 SmallVectorImpl<Type*> &ArgTys) { 1013 using namespace Intrinsic; 1014 1015 // If we ran out of descriptors, there are too many arguments. 1016 if (Infos.empty()) return true; 1017 IITDescriptor D = Infos.front(); 1018 Infos = Infos.slice(1); 1019 1020 switch (D.Kind) { 1021 case IITDescriptor::Void: return !Ty->isVoidTy(); 1022 case IITDescriptor::VarArg: return true; 1023 case IITDescriptor::MMX: return !Ty->isX86_MMXTy(); 1024 case IITDescriptor::Token: return !Ty->isTokenTy(); 1025 case IITDescriptor::Metadata: return !Ty->isMetadataTy(); 1026 case IITDescriptor::Half: return !Ty->isHalfTy(); 1027 case IITDescriptor::Float: return !Ty->isFloatTy(); 1028 case IITDescriptor::Double: return !Ty->isDoubleTy(); 1029 case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width); 1030 case IITDescriptor::Vector: { 1031 VectorType *VT = dyn_cast<VectorType>(Ty); 1032 return !VT || VT->getNumElements() != D.Vector_Width || 1033 matchIntrinsicType(VT->getElementType(), Infos, ArgTys); 1034 } 1035 case IITDescriptor::Pointer: { 1036 PointerType *PT = dyn_cast<PointerType>(Ty); 1037 return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace || 1038 matchIntrinsicType(PT->getElementType(), Infos, ArgTys); 1039 } 1040 1041 case IITDescriptor::Struct: { 1042 StructType *ST = dyn_cast<StructType>(Ty); 1043 if (!ST || ST->getNumElements() != D.Struct_NumElements) 1044 return true; 1045 1046 for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 1047 if (matchIntrinsicType(ST->getElementType(i), Infos, ArgTys)) 1048 return true; 1049 return false; 1050 } 1051 1052 case IITDescriptor::Argument: 1053 // Two cases here - If this is the second occurrence of an argument, verify 1054 // that the later instance matches the previous instance. 1055 if (D.getArgumentNumber() < ArgTys.size()) 1056 return Ty != ArgTys[D.getArgumentNumber()]; 1057 1058 // Otherwise, if this is the first instance of an argument, record it and 1059 // verify the "Any" kind. 1060 assert(D.getArgumentNumber() == ArgTys.size() && "Table consistency error"); 1061 ArgTys.push_back(Ty); 1062 1063 switch (D.getArgumentKind()) { 1064 case IITDescriptor::AK_Any: return false; // Success 1065 case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy(); 1066 case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy(); 1067 case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty); 1068 case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty); 1069 } 1070 llvm_unreachable("all argument kinds not covered"); 1071 1072 case IITDescriptor::ExtendArgument: { 1073 // This may only be used when referring to a previous vector argument. 1074 if (D.getArgumentNumber() >= ArgTys.size()) 1075 return true; 1076 1077 Type *NewTy = ArgTys[D.getArgumentNumber()]; 1078 if (VectorType *VTy = dyn_cast<VectorType>(NewTy)) 1079 NewTy = VectorType::getExtendedElementVectorType(VTy); 1080 else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy)) 1081 NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth()); 1082 else 1083 return true; 1084 1085 return Ty != NewTy; 1086 } 1087 case IITDescriptor::TruncArgument: { 1088 // This may only be used when referring to a previous vector argument. 1089 if (D.getArgumentNumber() >= ArgTys.size()) 1090 return true; 1091 1092 Type *NewTy = ArgTys[D.getArgumentNumber()]; 1093 if (VectorType *VTy = dyn_cast<VectorType>(NewTy)) 1094 NewTy = VectorType::getTruncatedElementVectorType(VTy); 1095 else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy)) 1096 NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2); 1097 else 1098 return true; 1099 1100 return Ty != NewTy; 1101 } 1102 case IITDescriptor::HalfVecArgument: 1103 // This may only be used when referring to a previous vector argument. 1104 return D.getArgumentNumber() >= ArgTys.size() || 1105 !isa<VectorType>(ArgTys[D.getArgumentNumber()]) || 1106 VectorType::getHalfElementsVectorType( 1107 cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty; 1108 case IITDescriptor::SameVecWidthArgument: { 1109 if (D.getArgumentNumber() >= ArgTys.size()) 1110 return true; 1111 VectorType * ReferenceType = 1112 dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]); 1113 VectorType *ThisArgType = dyn_cast<VectorType>(Ty); 1114 if (!ThisArgType || !ReferenceType || 1115 (ReferenceType->getVectorNumElements() != 1116 ThisArgType->getVectorNumElements())) 1117 return true; 1118 return matchIntrinsicType(ThisArgType->getVectorElementType(), 1119 Infos, ArgTys); 1120 } 1121 case IITDescriptor::PtrToArgument: { 1122 if (D.getArgumentNumber() >= ArgTys.size()) 1123 return true; 1124 Type * ReferenceType = ArgTys[D.getArgumentNumber()]; 1125 PointerType *ThisArgType = dyn_cast<PointerType>(Ty); 1126 return (!ThisArgType || ThisArgType->getElementType() != ReferenceType); 1127 } 1128 case IITDescriptor::PtrToElt: { 1129 if (D.getArgumentNumber() >= ArgTys.size()) 1130 return true; 1131 VectorType * ReferenceType = 1132 dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]); 1133 PointerType *ThisArgType = dyn_cast<PointerType>(Ty); 1134 1135 return (!ThisArgType || !ReferenceType || 1136 ThisArgType->getElementType() != ReferenceType->getElementType()); 1137 } 1138 case IITDescriptor::VecOfAnyPtrsToElt: { 1139 unsigned RefArgNumber = D.getRefArgNumber(); 1140 1141 // This may only be used when referring to a previous argument. 1142 if (RefArgNumber >= ArgTys.size()) 1143 return true; 1144 1145 // Record the overloaded type 1146 assert(D.getOverloadArgNumber() == ArgTys.size() && 1147 "Table consistency error"); 1148 ArgTys.push_back(Ty); 1149 1150 // Verify the overloaded type "matches" the Ref type. 1151 // i.e. Ty is a vector with the same width as Ref. 1152 // Composed of pointers to the same element type as Ref. 1153 VectorType *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]); 1154 VectorType *ThisArgVecTy = dyn_cast<VectorType>(Ty); 1155 if (!ThisArgVecTy || !ReferenceType || 1156 (ReferenceType->getVectorNumElements() != 1157 ThisArgVecTy->getVectorNumElements())) 1158 return true; 1159 PointerType *ThisArgEltTy = 1160 dyn_cast<PointerType>(ThisArgVecTy->getVectorElementType()); 1161 if (!ThisArgEltTy) 1162 return true; 1163 return ThisArgEltTy->getElementType() != 1164 ReferenceType->getVectorElementType(); 1165 } 1166 } 1167 llvm_unreachable("unhandled"); 1168 } 1169 1170 bool 1171 Intrinsic::matchIntrinsicVarArg(bool isVarArg, 1172 ArrayRef<Intrinsic::IITDescriptor> &Infos) { 1173 // If there are no descriptors left, then it can't be a vararg. 1174 if (Infos.empty()) 1175 return isVarArg; 1176 1177 // There should be only one descriptor remaining at this point. 1178 if (Infos.size() != 1) 1179 return true; 1180 1181 // Check and verify the descriptor. 1182 IITDescriptor D = Infos.front(); 1183 Infos = Infos.slice(1); 1184 if (D.Kind == IITDescriptor::VarArg) 1185 return !isVarArg; 1186 1187 return true; 1188 } 1189 1190 Optional<Function*> Intrinsic::remangleIntrinsicFunction(Function *F) { 1191 Intrinsic::ID ID = F->getIntrinsicID(); 1192 if (!ID) 1193 return None; 1194 1195 FunctionType *FTy = F->getFunctionType(); 1196 // Accumulate an array of overloaded types for the given intrinsic 1197 SmallVector<Type *, 4> ArgTys; 1198 { 1199 SmallVector<Intrinsic::IITDescriptor, 8> Table; 1200 getIntrinsicInfoTableEntries(ID, Table); 1201 ArrayRef<Intrinsic::IITDescriptor> TableRef = Table; 1202 1203 // If we encounter any problems matching the signature with the descriptor 1204 // just give up remangling. It's up to verifier to report the discrepancy. 1205 if (Intrinsic::matchIntrinsicType(FTy->getReturnType(), TableRef, ArgTys)) 1206 return None; 1207 for (auto Ty : FTy->params()) 1208 if (Intrinsic::matchIntrinsicType(Ty, TableRef, ArgTys)) 1209 return None; 1210 if (Intrinsic::matchIntrinsicVarArg(FTy->isVarArg(), TableRef)) 1211 return None; 1212 } 1213 1214 StringRef Name = F->getName(); 1215 if (Name == Intrinsic::getName(ID, ArgTys)) 1216 return None; 1217 1218 auto NewDecl = Intrinsic::getDeclaration(F->getParent(), ID, ArgTys); 1219 NewDecl->setCallingConv(F->getCallingConv()); 1220 assert(NewDecl->getFunctionType() == FTy && "Shouldn't change the signature"); 1221 return NewDecl; 1222 } 1223 1224 /// hasAddressTaken - returns true if there are any uses of this function 1225 /// other than direct calls or invokes to it. 1226 bool Function::hasAddressTaken(const User* *PutOffender) const { 1227 for (const Use &U : uses()) { 1228 const User *FU = U.getUser(); 1229 if (isa<BlockAddress>(FU)) 1230 continue; 1231 if (!isa<CallInst>(FU) && !isa<InvokeInst>(FU)) { 1232 if (PutOffender) 1233 *PutOffender = FU; 1234 return true; 1235 } 1236 ImmutableCallSite CS(cast<Instruction>(FU)); 1237 if (!CS.isCallee(&U)) { 1238 if (PutOffender) 1239 *PutOffender = FU; 1240 return true; 1241 } 1242 } 1243 return false; 1244 } 1245 1246 bool Function::isDefTriviallyDead() const { 1247 // Check the linkage 1248 if (!hasLinkOnceLinkage() && !hasLocalLinkage() && 1249 !hasAvailableExternallyLinkage()) 1250 return false; 1251 1252 // Check if the function is used by anything other than a blockaddress. 1253 for (const User *U : users()) 1254 if (!isa<BlockAddress>(U)) 1255 return false; 1256 1257 return true; 1258 } 1259 1260 /// callsFunctionThatReturnsTwice - Return true if the function has a call to 1261 /// setjmp or other function that gcc recognizes as "returning twice". 1262 bool Function::callsFunctionThatReturnsTwice() const { 1263 for (const_inst_iterator 1264 I = inst_begin(this), E = inst_end(this); I != E; ++I) { 1265 ImmutableCallSite CS(&*I); 1266 if (CS && CS.hasFnAttr(Attribute::ReturnsTwice)) 1267 return true; 1268 } 1269 1270 return false; 1271 } 1272 1273 Constant *Function::getPersonalityFn() const { 1274 assert(hasPersonalityFn() && getNumOperands()); 1275 return cast<Constant>(Op<0>()); 1276 } 1277 1278 void Function::setPersonalityFn(Constant *Fn) { 1279 setHungoffOperand<0>(Fn); 1280 setValueSubclassDataBit(3, Fn != nullptr); 1281 } 1282 1283 Constant *Function::getPrefixData() const { 1284 assert(hasPrefixData() && getNumOperands()); 1285 return cast<Constant>(Op<1>()); 1286 } 1287 1288 void Function::setPrefixData(Constant *PrefixData) { 1289 setHungoffOperand<1>(PrefixData); 1290 setValueSubclassDataBit(1, PrefixData != nullptr); 1291 } 1292 1293 Constant *Function::getPrologueData() const { 1294 assert(hasPrologueData() && getNumOperands()); 1295 return cast<Constant>(Op<2>()); 1296 } 1297 1298 void Function::setPrologueData(Constant *PrologueData) { 1299 setHungoffOperand<2>(PrologueData); 1300 setValueSubclassDataBit(2, PrologueData != nullptr); 1301 } 1302 1303 void Function::allocHungoffUselist() { 1304 // If we've already allocated a uselist, stop here. 1305 if (getNumOperands()) 1306 return; 1307 1308 allocHungoffUses(3, /*IsPhi=*/ false); 1309 setNumHungOffUseOperands(3); 1310 1311 // Initialize the uselist with placeholder operands to allow traversal. 1312 auto *CPN = ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0)); 1313 Op<0>().set(CPN); 1314 Op<1>().set(CPN); 1315 Op<2>().set(CPN); 1316 } 1317 1318 template <int Idx> 1319 void Function::setHungoffOperand(Constant *C) { 1320 if (C) { 1321 allocHungoffUselist(); 1322 Op<Idx>().set(C); 1323 } else if (getNumOperands()) { 1324 Op<Idx>().set( 1325 ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0))); 1326 } 1327 } 1328 1329 void Function::setValueSubclassDataBit(unsigned Bit, bool On) { 1330 assert(Bit < 16 && "SubclassData contains only 16 bits"); 1331 if (On) 1332 setValueSubclassData(getSubclassDataFromValue() | (1 << Bit)); 1333 else 1334 setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit)); 1335 } 1336 1337 void Function::setEntryCount(ProfileCount Count, 1338 const DenseSet<GlobalValue::GUID> *S) { 1339 assert(Count.hasValue()); 1340 #if !defined(NDEBUG) 1341 auto PrevCount = getEntryCount(); 1342 assert(!PrevCount.hasValue() || PrevCount.getType() == Count.getType()); 1343 #endif 1344 MDBuilder MDB(getContext()); 1345 setMetadata( 1346 LLVMContext::MD_prof, 1347 MDB.createFunctionEntryCount(Count.getCount(), Count.isSynthetic(), S)); 1348 } 1349 1350 void Function::setEntryCount(uint64_t Count, Function::ProfileCountType Type, 1351 const DenseSet<GlobalValue::GUID> *Imports) { 1352 setEntryCount(ProfileCount(Count, Type), Imports); 1353 } 1354 1355 ProfileCount Function::getEntryCount() const { 1356 MDNode *MD = getMetadata(LLVMContext::MD_prof); 1357 if (MD && MD->getOperand(0)) 1358 if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) { 1359 if (MDS->getString().equals("function_entry_count")) { 1360 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1)); 1361 uint64_t Count = CI->getValue().getZExtValue(); 1362 // A value of -1 is used for SamplePGO when there were no samples. 1363 // Treat this the same as unknown. 1364 if (Count == (uint64_t)-1) 1365 return ProfileCount::getInvalid(); 1366 return ProfileCount(Count, PCT_Real); 1367 } else if (MDS->getString().equals("synthetic_function_entry_count")) { 1368 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1)); 1369 uint64_t Count = CI->getValue().getZExtValue(); 1370 return ProfileCount(Count, PCT_Synthetic); 1371 } 1372 } 1373 return ProfileCount::getInvalid(); 1374 } 1375 1376 DenseSet<GlobalValue::GUID> Function::getImportGUIDs() const { 1377 DenseSet<GlobalValue::GUID> R; 1378 if (MDNode *MD = getMetadata(LLVMContext::MD_prof)) 1379 if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) 1380 if (MDS->getString().equals("function_entry_count")) 1381 for (unsigned i = 2; i < MD->getNumOperands(); i++) 1382 R.insert(mdconst::extract<ConstantInt>(MD->getOperand(i)) 1383 ->getValue() 1384 .getZExtValue()); 1385 return R; 1386 } 1387 1388 void Function::setSectionPrefix(StringRef Prefix) { 1389 MDBuilder MDB(getContext()); 1390 setMetadata(LLVMContext::MD_section_prefix, 1391 MDB.createFunctionSectionPrefix(Prefix)); 1392 } 1393 1394 Optional<StringRef> Function::getSectionPrefix() const { 1395 if (MDNode *MD = getMetadata(LLVMContext::MD_section_prefix)) { 1396 assert(dyn_cast<MDString>(MD->getOperand(0)) 1397 ->getString() 1398 .equals("function_section_prefix") && 1399 "Metadata not match"); 1400 return dyn_cast<MDString>(MD->getOperand(1))->getString(); 1401 } 1402 return None; 1403 } 1404