1 //===- llvm/Function.h - Class to represent a single function ---*- C++ -*-===// 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 contains the declaration of the Function class, which represents a 11 // single function/procedure in LLVM. 12 // 13 // A function basically consists of a list of basic blocks, a list of arguments, 14 // and a symbol table. 15 // 16 //===----------------------------------------------------------------------===// 17 18 #ifndef LLVM_IR_FUNCTION_H 19 #define LLVM_IR_FUNCTION_H 20 21 #include "llvm/ADT/DenseSet.h" 22 #include "llvm/ADT/StringRef.h" 23 #include "llvm/ADT/Twine.h" 24 #include "llvm/ADT/ilist_node.h" 25 #include "llvm/ADT/iterator_range.h" 26 #include "llvm/IR/Argument.h" 27 #include "llvm/IR/Attributes.h" 28 #include "llvm/IR/BasicBlock.h" 29 #include "llvm/IR/CallingConv.h" 30 #include "llvm/IR/DerivedTypes.h" 31 #include "llvm/IR/GlobalObject.h" 32 #include "llvm/IR/GlobalValue.h" 33 #include "llvm/IR/OperandTraits.h" 34 #include "llvm/IR/SymbolTableListTraits.h" 35 #include "llvm/IR/Value.h" 36 #include "llvm/Support/Casting.h" 37 #include "llvm/Support/Compiler.h" 38 #include <cassert> 39 #include <cstddef> 40 #include <cstdint> 41 #include <memory> 42 #include <string> 43 44 namespace llvm { 45 46 namespace Intrinsic { 47 enum ID : unsigned; 48 } 49 50 class AssemblyAnnotationWriter; 51 class Constant; 52 class DISubprogram; 53 class LLVMContext; 54 class Module; 55 template <typename T> class Optional; 56 class raw_ostream; 57 class Type; 58 class User; 59 60 class Function : public GlobalObject, public ilist_node<Function> { 61 public: 62 using BasicBlockListType = SymbolTableList<BasicBlock>; 63 64 // BasicBlock iterators... 65 using iterator = BasicBlockListType::iterator; 66 using const_iterator = BasicBlockListType::const_iterator; 67 68 using arg_iterator = Argument *; 69 using const_arg_iterator = const Argument *; 70 71 private: 72 // Important things that make up a function! 73 BasicBlockListType BasicBlocks; ///< The basic blocks 74 mutable Argument *Arguments = nullptr; ///< The formal arguments 75 size_t NumArgs; 76 std::unique_ptr<ValueSymbolTable> 77 SymTab; ///< Symbol table of args/instructions 78 AttributeList AttributeSets; ///< Parameter attributes 79 80 /* 81 * Value::SubclassData 82 * 83 * bit 0 : HasLazyArguments 84 * bit 1 : HasPrefixData 85 * bit 2 : HasPrologueData 86 * bit 3 : HasPersonalityFn 87 * bits 4-13 : CallingConvention 88 * bits 14 : HasGC 89 * bits 15 : [reserved] 90 */ 91 92 /// Bits from GlobalObject::GlobalObjectSubclassData. 93 enum { 94 /// Whether this function is materializable. 95 IsMaterializableBit = 0, 96 }; 97 98 friend class SymbolTableListTraits<Function>; 99 100 /// hasLazyArguments/CheckLazyArguments - The argument list of a function is 101 /// built on demand, so that the list isn't allocated until the first client 102 /// needs it. The hasLazyArguments predicate returns true if the arg list 103 /// hasn't been set up yet. 104 public: hasLazyArguments()105 bool hasLazyArguments() const { 106 return getSubclassDataFromValue() & (1<<0); 107 } 108 109 private: CheckLazyArguments()110 void CheckLazyArguments() const { 111 if (hasLazyArguments()) 112 BuildLazyArguments(); 113 } 114 115 void BuildLazyArguments() const; 116 117 void clearArguments(); 118 119 /// Function ctor - If the (optional) Module argument is specified, the 120 /// function is automatically inserted into the end of the function list for 121 /// the module. 122 /// 123 Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, 124 const Twine &N = "", Module *M = nullptr); 125 126 public: 127 Function(const Function&) = delete; 128 void operator=(const Function&) = delete; 129 ~Function(); 130 131 // This is here to help easily convert from FunctionT * (Function * or 132 // MachineFunction *) in BlockFrequencyInfoImpl to Function * by calling 133 // FunctionT->getFunction(). getFunction()134 const Function &getFunction() const { return *this; } 135 136 static Function *Create(FunctionType *Ty, LinkageTypes Linkage, 137 unsigned AddrSpace, const Twine &N = "", 138 Module *M = nullptr) { 139 return new Function(Ty, Linkage, AddrSpace, N, M); 140 } 141 142 // TODO: remove this once all users have been updated to pass an AddrSpace 143 static Function *Create(FunctionType *Ty, LinkageTypes Linkage, 144 const Twine &N = "", Module *M = nullptr) { 145 return new Function(Ty, Linkage, static_cast<unsigned>(-1), N, M); 146 } 147 148 /// Creates a new function and attaches it to a module. 149 /// 150 /// Places the function in the program address space as specified 151 /// by the module's data layout. 152 static Function *Create(FunctionType *Ty, LinkageTypes Linkage, 153 const Twine &N, Module &M); 154 155 // Provide fast operand accessors. 156 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 157 158 /// Returns the number of non-debug IR instructions in this function. 159 /// This is equivalent to the sum of the sizes of each basic block contained 160 /// within this function. 161 unsigned getInstructionCount() const; 162 163 /// Returns the FunctionType for me. getFunctionType()164 FunctionType *getFunctionType() const { 165 return cast<FunctionType>(getValueType()); 166 } 167 168 /// Returns the type of the ret val. getReturnType()169 Type *getReturnType() const { return getFunctionType()->getReturnType(); } 170 171 /// getContext - Return a reference to the LLVMContext associated with this 172 /// function. 173 LLVMContext &getContext() const; 174 175 /// isVarArg - Return true if this function takes a variable number of 176 /// arguments. isVarArg()177 bool isVarArg() const { return getFunctionType()->isVarArg(); } 178 isMaterializable()179 bool isMaterializable() const { 180 return getGlobalObjectSubClassData() & (1 << IsMaterializableBit); 181 } setIsMaterializable(bool V)182 void setIsMaterializable(bool V) { 183 unsigned Mask = 1 << IsMaterializableBit; 184 setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) | 185 (V ? Mask : 0u)); 186 } 187 188 /// getIntrinsicID - This method returns the ID number of the specified 189 /// function, or Intrinsic::not_intrinsic if the function is not an 190 /// intrinsic, or if the pointer is null. This value is always defined to be 191 /// zero to allow easy checking for whether a function is intrinsic or not. 192 /// The particular intrinsic functions which correspond to this value are 193 /// defined in llvm/Intrinsics.h. getIntrinsicID()194 Intrinsic::ID getIntrinsicID() const LLVM_READONLY { return IntID; } 195 196 /// isIntrinsic - Returns true if the function's name starts with "llvm.". 197 /// It's possible for this function to return true while getIntrinsicID() 198 /// returns Intrinsic::not_intrinsic! isIntrinsic()199 bool isIntrinsic() const { return HasLLVMReservedName; } 200 201 static Intrinsic::ID lookupIntrinsicID(StringRef Name); 202 203 /// Recalculate the ID for this function if it is an Intrinsic defined 204 /// in llvm/Intrinsics.h. Sets the intrinsic ID to Intrinsic::not_intrinsic 205 /// if the name of this function does not match an intrinsic in that header. 206 /// Note, this method does not need to be called directly, as it is called 207 /// from Value::setName() whenever the name of this function changes. 208 void recalculateIntrinsicID(); 209 210 /// getCallingConv()/setCallingConv(CC) - These method get and set the 211 /// calling convention of this function. The enum values for the known 212 /// calling conventions are defined in CallingConv.h. getCallingConv()213 CallingConv::ID getCallingConv() const { 214 return static_cast<CallingConv::ID>((getSubclassDataFromValue() >> 4) & 215 CallingConv::MaxID); 216 } setCallingConv(CallingConv::ID CC)217 void setCallingConv(CallingConv::ID CC) { 218 auto ID = static_cast<unsigned>(CC); 219 assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention"); 220 setValueSubclassData((getSubclassDataFromValue() & 0xc00f) | (ID << 4)); 221 } 222 223 /// Return the attribute list for this Function. getAttributes()224 AttributeList getAttributes() const { return AttributeSets; } 225 226 /// Set the attribute list for this Function. setAttributes(AttributeList Attrs)227 void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; } 228 229 /// Add function attributes to this function. addFnAttr(Attribute::AttrKind Kind)230 void addFnAttr(Attribute::AttrKind Kind) { 231 addAttribute(AttributeList::FunctionIndex, Kind); 232 } 233 234 /// Add function attributes to this function. 235 void addFnAttr(StringRef Kind, StringRef Val = StringRef()) { 236 addAttribute(AttributeList::FunctionIndex, 237 Attribute::get(getContext(), Kind, Val)); 238 } 239 240 /// Add function attributes to this function. addFnAttr(Attribute Attr)241 void addFnAttr(Attribute Attr) { 242 addAttribute(AttributeList::FunctionIndex, Attr); 243 } 244 245 /// Remove function attributes from this function. removeFnAttr(Attribute::AttrKind Kind)246 void removeFnAttr(Attribute::AttrKind Kind) { 247 removeAttribute(AttributeList::FunctionIndex, Kind); 248 } 249 250 /// Remove function attribute from this function. removeFnAttr(StringRef Kind)251 void removeFnAttr(StringRef Kind) { 252 setAttributes(getAttributes().removeAttribute( 253 getContext(), AttributeList::FunctionIndex, Kind)); 254 } 255 256 enum ProfileCountType { PCT_Invalid, PCT_Real, PCT_Synthetic }; 257 258 /// Class to represent profile counts. 259 /// 260 /// This class represents both real and synthetic profile counts. 261 class ProfileCount { 262 private: 263 uint64_t Count; 264 ProfileCountType PCT; 265 static ProfileCount Invalid; 266 267 public: ProfileCount()268 ProfileCount() : Count(-1), PCT(PCT_Invalid) {} ProfileCount(uint64_t Count,ProfileCountType PCT)269 ProfileCount(uint64_t Count, ProfileCountType PCT) 270 : Count(Count), PCT(PCT) {} hasValue()271 bool hasValue() const { return PCT != PCT_Invalid; } getCount()272 uint64_t getCount() const { return Count; } getType()273 ProfileCountType getType() const { return PCT; } isSynthetic()274 bool isSynthetic() const { return PCT == PCT_Synthetic; } 275 explicit operator bool() { return hasValue(); } 276 bool operator!() const { return !hasValue(); } 277 // Update the count retaining the same profile count type. setCount(uint64_t C)278 ProfileCount &setCount(uint64_t C) { 279 Count = C; 280 return *this; 281 } getInvalid()282 static ProfileCount getInvalid() { return ProfileCount(-1, PCT_Invalid); } 283 }; 284 285 /// Set the entry count for this function. 286 /// 287 /// Entry count is the number of times this function was executed based on 288 /// pgo data. \p Imports points to a set of GUIDs that needs to 289 /// be imported by the function for sample PGO, to enable the same inlines as 290 /// the profiled optimized binary. 291 void setEntryCount(ProfileCount Count, 292 const DenseSet<GlobalValue::GUID> *Imports = nullptr); 293 294 /// A convenience wrapper for setting entry count 295 void setEntryCount(uint64_t Count, ProfileCountType Type = PCT_Real, 296 const DenseSet<GlobalValue::GUID> *Imports = nullptr); 297 298 /// Get the entry count for this function. 299 /// 300 /// Entry count is the number of times the function was executed based on 301 /// pgo data. 302 ProfileCount getEntryCount() const; 303 304 /// Return true if the function is annotated with profile data. 305 /// 306 /// Presence of entry counts from a profile run implies the function has 307 /// profile annotations. hasProfileData()308 bool hasProfileData() const { return getEntryCount().hasValue(); } 309 310 /// Returns the set of GUIDs that needs to be imported to the function for 311 /// sample PGO, to enable the same inlines as the profiled optimized binary. 312 DenseSet<GlobalValue::GUID> getImportGUIDs() const; 313 314 /// Set the section prefix for this function. 315 void setSectionPrefix(StringRef Prefix); 316 317 /// Get the section prefix for this function. 318 Optional<StringRef> getSectionPrefix() const; 319 320 /// Return true if the function has the attribute. hasFnAttribute(Attribute::AttrKind Kind)321 bool hasFnAttribute(Attribute::AttrKind Kind) const { 322 return AttributeSets.hasFnAttribute(Kind); 323 } 324 325 /// Return true if the function has the attribute. hasFnAttribute(StringRef Kind)326 bool hasFnAttribute(StringRef Kind) const { 327 return AttributeSets.hasFnAttribute(Kind); 328 } 329 330 /// Return the attribute for the given attribute kind. getFnAttribute(Attribute::AttrKind Kind)331 Attribute getFnAttribute(Attribute::AttrKind Kind) const { 332 return getAttribute(AttributeList::FunctionIndex, Kind); 333 } 334 335 /// Return the attribute for the given attribute kind. getFnAttribute(StringRef Kind)336 Attribute getFnAttribute(StringRef Kind) const { 337 return getAttribute(AttributeList::FunctionIndex, Kind); 338 } 339 340 /// Return the stack alignment for the function. getFnStackAlignment()341 unsigned getFnStackAlignment() const { 342 if (!hasFnAttribute(Attribute::StackAlignment)) 343 return 0; 344 return AttributeSets.getStackAlignment(AttributeList::FunctionIndex); 345 } 346 347 /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm 348 /// to use during code generation. hasGC()349 bool hasGC() const { 350 return getSubclassDataFromValue() & (1<<14); 351 } 352 const std::string &getGC() const; 353 void setGC(std::string Str); 354 void clearGC(); 355 356 /// adds the attribute to the list of attributes. 357 void addAttribute(unsigned i, Attribute::AttrKind Kind); 358 359 /// adds the attribute to the list of attributes. 360 void addAttribute(unsigned i, Attribute Attr); 361 362 /// adds the attributes to the list of attributes. 363 void addAttributes(unsigned i, const AttrBuilder &Attrs); 364 365 /// adds the attribute to the list of attributes for the given arg. 366 void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind); 367 368 /// adds the attribute to the list of attributes for the given arg. 369 void addParamAttr(unsigned ArgNo, Attribute Attr); 370 371 /// adds the attributes to the list of attributes for the given arg. 372 void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs); 373 374 /// removes the attribute from the list of attributes. 375 void removeAttribute(unsigned i, Attribute::AttrKind Kind); 376 377 /// removes the attribute from the list of attributes. 378 void removeAttribute(unsigned i, StringRef Kind); 379 380 /// removes the attributes from the list of attributes. 381 void removeAttributes(unsigned i, const AttrBuilder &Attrs); 382 383 /// removes the attribute from the list of attributes. 384 void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind); 385 386 /// removes the attribute from the list of attributes. 387 void removeParamAttr(unsigned ArgNo, StringRef Kind); 388 389 /// removes the attribute from the list of attributes. 390 void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs); 391 392 /// check if an attributes is in the list of attributes. hasAttribute(unsigned i,Attribute::AttrKind Kind)393 bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const { 394 return getAttributes().hasAttribute(i, Kind); 395 } 396 397 /// check if an attributes is in the list of attributes. hasParamAttribute(unsigned ArgNo,Attribute::AttrKind Kind)398 bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const { 399 return getAttributes().hasParamAttribute(ArgNo, Kind); 400 } 401 402 /// gets the attribute from the list of attributes. getAttribute(unsigned i,Attribute::AttrKind Kind)403 Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const { 404 return AttributeSets.getAttribute(i, Kind); 405 } 406 407 /// gets the attribute from the list of attributes. getAttribute(unsigned i,StringRef Kind)408 Attribute getAttribute(unsigned i, StringRef Kind) const { 409 return AttributeSets.getAttribute(i, Kind); 410 } 411 412 /// adds the dereferenceable attribute to the list of attributes. 413 void addDereferenceableAttr(unsigned i, uint64_t Bytes); 414 415 /// adds the dereferenceable attribute to the list of attributes for 416 /// the given arg. 417 void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes); 418 419 /// adds the dereferenceable_or_null attribute to the list of 420 /// attributes. 421 void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes); 422 423 /// adds the dereferenceable_or_null attribute to the list of 424 /// attributes for the given arg. 425 void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes); 426 427 /// Extract the alignment for a call or parameter (0=unknown). getParamAlignment(unsigned ArgNo)428 unsigned getParamAlignment(unsigned ArgNo) const { 429 return AttributeSets.getParamAlignment(ArgNo); 430 } 431 432 /// Extract the number of dereferenceable bytes for a call or 433 /// parameter (0=unknown). 434 /// @param i AttributeList index, referring to a return value or argument. getDereferenceableBytes(unsigned i)435 uint64_t getDereferenceableBytes(unsigned i) const { 436 return AttributeSets.getDereferenceableBytes(i); 437 } 438 439 /// Extract the number of dereferenceable bytes for a parameter. 440 /// @param ArgNo Index of an argument, with 0 being the first function arg. getParamDereferenceableBytes(unsigned ArgNo)441 uint64_t getParamDereferenceableBytes(unsigned ArgNo) const { 442 return AttributeSets.getParamDereferenceableBytes(ArgNo); 443 } 444 445 /// Extract the number of dereferenceable_or_null bytes for a call or 446 /// parameter (0=unknown). 447 /// @param i AttributeList index, referring to a return value or argument. getDereferenceableOrNullBytes(unsigned i)448 uint64_t getDereferenceableOrNullBytes(unsigned i) const { 449 return AttributeSets.getDereferenceableOrNullBytes(i); 450 } 451 452 /// Extract the number of dereferenceable_or_null bytes for a 453 /// parameter. 454 /// @param ArgNo AttributeList ArgNo, referring to an argument. getParamDereferenceableOrNullBytes(unsigned ArgNo)455 uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const { 456 return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo); 457 } 458 459 /// Determine if the function does not access memory. doesNotAccessMemory()460 bool doesNotAccessMemory() const { 461 return hasFnAttribute(Attribute::ReadNone); 462 } setDoesNotAccessMemory()463 void setDoesNotAccessMemory() { 464 addFnAttr(Attribute::ReadNone); 465 } 466 467 /// Determine if the function does not access or only reads memory. onlyReadsMemory()468 bool onlyReadsMemory() const { 469 return doesNotAccessMemory() || hasFnAttribute(Attribute::ReadOnly); 470 } setOnlyReadsMemory()471 void setOnlyReadsMemory() { 472 addFnAttr(Attribute::ReadOnly); 473 } 474 475 /// Determine if the function does not access or only writes memory. doesNotReadMemory()476 bool doesNotReadMemory() const { 477 return doesNotAccessMemory() || hasFnAttribute(Attribute::WriteOnly); 478 } setDoesNotReadMemory()479 void setDoesNotReadMemory() { 480 addFnAttr(Attribute::WriteOnly); 481 } 482 483 /// Determine if the call can access memmory only using pointers based 484 /// on its arguments. onlyAccessesArgMemory()485 bool onlyAccessesArgMemory() const { 486 return hasFnAttribute(Attribute::ArgMemOnly); 487 } setOnlyAccessesArgMemory()488 void setOnlyAccessesArgMemory() { addFnAttr(Attribute::ArgMemOnly); } 489 490 /// Determine if the function may only access memory that is 491 /// inaccessible from the IR. onlyAccessesInaccessibleMemory()492 bool onlyAccessesInaccessibleMemory() const { 493 return hasFnAttribute(Attribute::InaccessibleMemOnly); 494 } setOnlyAccessesInaccessibleMemory()495 void setOnlyAccessesInaccessibleMemory() { 496 addFnAttr(Attribute::InaccessibleMemOnly); 497 } 498 499 /// Determine if the function may only access memory that is 500 /// either inaccessible from the IR or pointed to by its arguments. onlyAccessesInaccessibleMemOrArgMem()501 bool onlyAccessesInaccessibleMemOrArgMem() const { 502 return hasFnAttribute(Attribute::InaccessibleMemOrArgMemOnly); 503 } setOnlyAccessesInaccessibleMemOrArgMem()504 void setOnlyAccessesInaccessibleMemOrArgMem() { 505 addFnAttr(Attribute::InaccessibleMemOrArgMemOnly); 506 } 507 508 /// Determine if the function cannot return. doesNotReturn()509 bool doesNotReturn() const { 510 return hasFnAttribute(Attribute::NoReturn); 511 } setDoesNotReturn()512 void setDoesNotReturn() { 513 addFnAttr(Attribute::NoReturn); 514 } 515 516 /// Determine if the function should not perform indirect branch tracking. doesNoCfCheck()517 bool doesNoCfCheck() const { return hasFnAttribute(Attribute::NoCfCheck); } 518 519 /// Determine if the function cannot unwind. doesNotThrow()520 bool doesNotThrow() const { 521 return hasFnAttribute(Attribute::NoUnwind); 522 } setDoesNotThrow()523 void setDoesNotThrow() { 524 addFnAttr(Attribute::NoUnwind); 525 } 526 527 /// Determine if the call cannot be duplicated. cannotDuplicate()528 bool cannotDuplicate() const { 529 return hasFnAttribute(Attribute::NoDuplicate); 530 } setCannotDuplicate()531 void setCannotDuplicate() { 532 addFnAttr(Attribute::NoDuplicate); 533 } 534 535 /// Determine if the call is convergent. isConvergent()536 bool isConvergent() const { 537 return hasFnAttribute(Attribute::Convergent); 538 } setConvergent()539 void setConvergent() { 540 addFnAttr(Attribute::Convergent); 541 } setNotConvergent()542 void setNotConvergent() { 543 removeFnAttr(Attribute::Convergent); 544 } 545 546 /// Determine if the call has sideeffects. isSpeculatable()547 bool isSpeculatable() const { 548 return hasFnAttribute(Attribute::Speculatable); 549 } setSpeculatable()550 void setSpeculatable() { 551 addFnAttr(Attribute::Speculatable); 552 } 553 554 /// Determine if the function is known not to recurse, directly or 555 /// indirectly. doesNotRecurse()556 bool doesNotRecurse() const { 557 return hasFnAttribute(Attribute::NoRecurse); 558 } setDoesNotRecurse()559 void setDoesNotRecurse() { 560 addFnAttr(Attribute::NoRecurse); 561 } 562 563 /// True if the ABI mandates (or the user requested) that this 564 /// function be in a unwind table. hasUWTable()565 bool hasUWTable() const { 566 return hasFnAttribute(Attribute::UWTable); 567 } setHasUWTable()568 void setHasUWTable() { 569 addFnAttr(Attribute::UWTable); 570 } 571 572 /// True if this function needs an unwind table. needsUnwindTableEntry()573 bool needsUnwindTableEntry() const { 574 return hasUWTable() || !doesNotThrow() || hasPersonalityFn(); 575 } 576 577 /// Determine if the function returns a structure through first 578 /// or second pointer argument. hasStructRetAttr()579 bool hasStructRetAttr() const { 580 return AttributeSets.hasParamAttribute(0, Attribute::StructRet) || 581 AttributeSets.hasParamAttribute(1, Attribute::StructRet); 582 } 583 584 /// Determine if the parameter or return value is marked with NoAlias 585 /// attribute. returnDoesNotAlias()586 bool returnDoesNotAlias() const { 587 return AttributeSets.hasAttribute(AttributeList::ReturnIndex, 588 Attribute::NoAlias); 589 } setReturnDoesNotAlias()590 void setReturnDoesNotAlias() { 591 addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias); 592 } 593 594 /// Optimize this function for minimum size (-Oz). optForMinSize()595 bool optForMinSize() const { return hasFnAttribute(Attribute::MinSize); } 596 597 /// Optimize this function for size (-Os) or minimum size (-Oz). optForSize()598 bool optForSize() const { 599 return hasFnAttribute(Attribute::OptimizeForSize) || optForMinSize(); 600 } 601 602 /// copyAttributesFrom - copy all additional attributes (those not needed to 603 /// create a Function) from the Function Src to this one. 604 void copyAttributesFrom(const Function *Src); 605 606 /// deleteBody - This method deletes the body of the function, and converts 607 /// the linkage to external. 608 /// deleteBody()609 void deleteBody() { 610 dropAllReferences(); 611 setLinkage(ExternalLinkage); 612 } 613 614 /// removeFromParent - This method unlinks 'this' from the containing module, 615 /// but does not delete it. 616 /// 617 void removeFromParent(); 618 619 /// eraseFromParent - This method unlinks 'this' from the containing module 620 /// and deletes it. 621 /// 622 void eraseFromParent(); 623 624 /// Steal arguments from another function. 625 /// 626 /// Drop this function's arguments and splice in the ones from \c Src. 627 /// Requires that this has no function body. 628 void stealArgumentListFrom(Function &Src); 629 630 /// Get the underlying elements of the Function... the basic block list is 631 /// empty for external functions. 632 /// getBasicBlockList()633 const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; } getBasicBlockList()634 BasicBlockListType &getBasicBlockList() { return BasicBlocks; } 635 getSublistAccess(BasicBlock *)636 static BasicBlockListType Function::*getSublistAccess(BasicBlock*) { 637 return &Function::BasicBlocks; 638 } 639 getEntryBlock()640 const BasicBlock &getEntryBlock() const { return front(); } getEntryBlock()641 BasicBlock &getEntryBlock() { return front(); } 642 643 //===--------------------------------------------------------------------===// 644 // Symbol Table Accessing functions... 645 646 /// getSymbolTable() - Return the symbol table if any, otherwise nullptr. 647 /// getValueSymbolTable()648 inline ValueSymbolTable *getValueSymbolTable() { return SymTab.get(); } getValueSymbolTable()649 inline const ValueSymbolTable *getValueSymbolTable() const { 650 return SymTab.get(); 651 } 652 653 //===--------------------------------------------------------------------===// 654 // BasicBlock iterator forwarding functions 655 // begin()656 iterator begin() { return BasicBlocks.begin(); } begin()657 const_iterator begin() const { return BasicBlocks.begin(); } end()658 iterator end () { return BasicBlocks.end(); } end()659 const_iterator end () const { return BasicBlocks.end(); } 660 size()661 size_t size() const { return BasicBlocks.size(); } empty()662 bool empty() const { return BasicBlocks.empty(); } front()663 const BasicBlock &front() const { return BasicBlocks.front(); } front()664 BasicBlock &front() { return BasicBlocks.front(); } back()665 const BasicBlock &back() const { return BasicBlocks.back(); } back()666 BasicBlock &back() { return BasicBlocks.back(); } 667 668 /// @name Function Argument Iteration 669 /// @{ 670 arg_begin()671 arg_iterator arg_begin() { 672 CheckLazyArguments(); 673 return Arguments; 674 } arg_begin()675 const_arg_iterator arg_begin() const { 676 CheckLazyArguments(); 677 return Arguments; 678 } 679 arg_end()680 arg_iterator arg_end() { 681 CheckLazyArguments(); 682 return Arguments + NumArgs; 683 } arg_end()684 const_arg_iterator arg_end() const { 685 CheckLazyArguments(); 686 return Arguments + NumArgs; 687 } 688 args()689 iterator_range<arg_iterator> args() { 690 return make_range(arg_begin(), arg_end()); 691 } args()692 iterator_range<const_arg_iterator> args() const { 693 return make_range(arg_begin(), arg_end()); 694 } 695 696 /// @} 697 arg_size()698 size_t arg_size() const { return NumArgs; } arg_empty()699 bool arg_empty() const { return arg_size() == 0; } 700 701 /// Check whether this function has a personality function. hasPersonalityFn()702 bool hasPersonalityFn() const { 703 return getSubclassDataFromValue() & (1<<3); 704 } 705 706 /// Get the personality function associated with this function. 707 Constant *getPersonalityFn() const; 708 void setPersonalityFn(Constant *Fn); 709 710 /// Check whether this function has prefix data. hasPrefixData()711 bool hasPrefixData() const { 712 return getSubclassDataFromValue() & (1<<1); 713 } 714 715 /// Get the prefix data associated with this function. 716 Constant *getPrefixData() const; 717 void setPrefixData(Constant *PrefixData); 718 719 /// Check whether this function has prologue data. hasPrologueData()720 bool hasPrologueData() const { 721 return getSubclassDataFromValue() & (1<<2); 722 } 723 724 /// Get the prologue data associated with this function. 725 Constant *getPrologueData() const; 726 void setPrologueData(Constant *PrologueData); 727 728 /// Print the function to an output stream with an optional 729 /// AssemblyAnnotationWriter. 730 void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr, 731 bool ShouldPreserveUseListOrder = false, 732 bool IsForDebug = false) const; 733 734 /// viewCFG - This function is meant for use from the debugger. You can just 735 /// say 'call F->viewCFG()' and a ghostview window should pop up from the 736 /// program, displaying the CFG of the current function with the code for each 737 /// basic block inside. This depends on there being a 'dot' and 'gv' program 738 /// in your path. 739 /// 740 void viewCFG() const; 741 742 /// viewCFGOnly - This function is meant for use from the debugger. It works 743 /// just like viewCFG, but it does not include the contents of basic blocks 744 /// into the nodes, just the label. If you are only interested in the CFG 745 /// this can make the graph smaller. 746 /// 747 void viewCFGOnly() const; 748 749 /// Methods for support type inquiry through isa, cast, and dyn_cast: classof(const Value * V)750 static bool classof(const Value *V) { 751 return V->getValueID() == Value::FunctionVal; 752 } 753 754 /// dropAllReferences() - This method causes all the subinstructions to "let 755 /// go" of all references that they are maintaining. This allows one to 756 /// 'delete' a whole module at a time, even though there may be circular 757 /// references... first all references are dropped, and all use counts go to 758 /// zero. Then everything is deleted for real. Note that no operations are 759 /// valid on an object that has "dropped all references", except operator 760 /// delete. 761 /// 762 /// Since no other object in the module can have references into the body of a 763 /// function, dropping all references deletes the entire body of the function, 764 /// including any contained basic blocks. 765 /// 766 void dropAllReferences(); 767 768 /// hasAddressTaken - returns true if there are any uses of this function 769 /// other than direct calls or invokes to it, or blockaddress expressions. 770 /// Optionally passes back an offending user for diagnostic purposes. 771 /// 772 bool hasAddressTaken(const User** = nullptr) const; 773 774 /// isDefTriviallyDead - Return true if it is trivially safe to remove 775 /// this function definition from the module (because it isn't externally 776 /// visible, does not have its address taken, and has no callers). To make 777 /// this more accurate, call removeDeadConstantUsers first. 778 bool isDefTriviallyDead() const; 779 780 /// callsFunctionThatReturnsTwice - Return true if the function has a call to 781 /// setjmp or other function that gcc recognizes as "returning twice". 782 bool callsFunctionThatReturnsTwice() const; 783 784 /// Set the attached subprogram. 785 /// 786 /// Calls \a setMetadata() with \a LLVMContext::MD_dbg. 787 void setSubprogram(DISubprogram *SP); 788 789 /// Get the attached subprogram. 790 /// 791 /// Calls \a getMetadata() with \a LLVMContext::MD_dbg and casts the result 792 /// to \a DISubprogram. 793 DISubprogram *getSubprogram() const; 794 795 /// Returns true if we should emit debug info for profiling. 796 bool isDebugInfoForProfiling() const; 797 798 /// Check if null pointer dereferencing is considered undefined behavior for 799 /// the function. 800 /// Return value: false => null pointer dereference is undefined. 801 /// Return value: true => null pointer dereference is not undefined. 802 bool nullPointerIsDefined() const; 803 804 private: 805 void allocHungoffUselist(); 806 template<int Idx> void setHungoffOperand(Constant *C); 807 808 /// Shadow Value::setValueSubclassData with a private forwarding method so 809 /// that subclasses cannot accidentally use it. setValueSubclassData(unsigned short D)810 void setValueSubclassData(unsigned short D) { 811 Value::setValueSubclassData(D); 812 } 813 void setValueSubclassDataBit(unsigned Bit, bool On); 814 }; 815 816 /// Check whether null pointer dereferencing is considered undefined behavior 817 /// for a given function or an address space. 818 /// Null pointer access in non-zero address space is not considered undefined. 819 /// Return value: false => null pointer dereference is undefined. 820 /// Return value: true => null pointer dereference is not undefined. 821 bool NullPointerIsDefined(const Function *F, unsigned AS = 0); 822 823 template <> 824 struct OperandTraits<Function> : public HungoffOperandTraits<3> {}; 825 826 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Function, Value) 827 828 } // end namespace llvm 829 830 #endif // LLVM_IR_FUNCTION_H 831