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