1 //===- llvm/Function.h - Class to represent a single function ---*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // This file contains the declaration of the Function class, which represents a
10 // single function/procedure in LLVM.
12 // A function basically consists of a list of basic blocks, a list of arguments,
13 // and a symbol table.
15 //===----------------------------------------------------------------------===//
17 #ifndef LLVM_IR_FUNCTION_H
18 #define LLVM_IR_FUNCTION_H
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"
49 class AssemblyAnnotationWriter;
54 template <typename T> class Optional;
59 class Function : public GlobalObject, public ilist_node<Function> {
61 using BasicBlockListType = SymbolTableList<BasicBlock>;
63 // BasicBlock iterators...
64 using iterator = BasicBlockListType::iterator;
65 using const_iterator = BasicBlockListType::const_iterator;
67 using arg_iterator = Argument *;
68 using const_arg_iterator = const Argument *;
71 // Important things that make up a function!
72 BasicBlockListType BasicBlocks; ///< The basic blocks
73 mutable Argument *Arguments = nullptr; ///< The formal arguments
75 std::unique_ptr<ValueSymbolTable>
76 SymTab; ///< Symbol table of args/instructions
77 AttributeList AttributeSets; ///< Parameter attributes
82 * bit 0 : HasLazyArguments
83 * bit 1 : HasPrefixData
84 * bit 2 : HasPrologueData
85 * bit 3 : HasPersonalityFn
86 * bits 4-13 : CallingConvention
88 * bits 15 : [reserved]
91 /// Bits from GlobalObject::GlobalObjectSubclassData.
93 /// Whether this function is materializable.
94 IsMaterializableBit = 0,
97 friend class SymbolTableListTraits<Function>;
99 /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
100 /// built on demand, so that the list isn't allocated until the first client
101 /// needs it. The hasLazyArguments predicate returns true if the arg list
102 /// hasn't been set up yet.
104 bool hasLazyArguments() const {
105 return getSubclassDataFromValue() & (1<<0);
109 void CheckLazyArguments() const {
110 if (hasLazyArguments())
111 BuildLazyArguments();
114 void BuildLazyArguments() const;
116 void clearArguments();
118 /// Function ctor - If the (optional) Module argument is specified, the
119 /// function is automatically inserted into the end of the function list for
122 Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
123 const Twine &N = "", Module *M = nullptr);
126 Function(const Function&) = delete;
127 void operator=(const Function&) = delete;
130 // This is here to help easily convert from FunctionT * (Function * or
131 // MachineFunction *) in BlockFrequencyInfoImpl to Function * by calling
132 // FunctionT->getFunction().
133 const Function &getFunction() const { return *this; }
135 static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
136 unsigned AddrSpace, const Twine &N = "",
137 Module *M = nullptr) {
138 return new Function(Ty, Linkage, AddrSpace, N, M);
141 // TODO: remove this once all users have been updated to pass an AddrSpace
142 static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
143 const Twine &N = "", Module *M = nullptr) {
144 return new Function(Ty, Linkage, static_cast<unsigned>(-1), N, M);
147 /// Creates a new function and attaches it to a module.
149 /// Places the function in the program address space as specified
150 /// by the module's data layout.
151 static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
152 const Twine &N, Module &M);
154 // Provide fast operand accessors.
155 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
157 /// Returns the number of non-debug IR instructions in this function.
158 /// This is equivalent to the sum of the sizes of each basic block contained
159 /// within this function.
160 unsigned getInstructionCount() const;
162 /// Returns the FunctionType for me.
163 FunctionType *getFunctionType() const {
164 return cast<FunctionType>(getValueType());
167 /// Returns the type of the ret val.
168 Type *getReturnType() const { return getFunctionType()->getReturnType(); }
170 /// getContext - Return a reference to the LLVMContext associated with this
172 LLVMContext &getContext() const;
174 /// isVarArg - Return true if this function takes a variable number of
176 bool isVarArg() const { return getFunctionType()->isVarArg(); }
178 bool isMaterializable() const {
179 return getGlobalObjectSubClassData() & (1 << IsMaterializableBit);
181 void setIsMaterializable(bool V) {
182 unsigned Mask = 1 << IsMaterializableBit;
183 setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) |
187 /// getIntrinsicID - This method returns the ID number of the specified
188 /// function, or Intrinsic::not_intrinsic if the function is not an
189 /// intrinsic, or if the pointer is null. This value is always defined to be
190 /// zero to allow easy checking for whether a function is intrinsic or not.
191 /// The particular intrinsic functions which correspond to this value are
192 /// defined in llvm/Intrinsics.h.
193 Intrinsic::ID getIntrinsicID() const LLVM_READONLY { return IntID; }
195 /// isIntrinsic - Returns true if the function's name starts with "llvm.".
196 /// It's possible for this function to return true while getIntrinsicID()
197 /// returns Intrinsic::not_intrinsic!
198 bool isIntrinsic() const { return HasLLVMReservedName; }
200 static Intrinsic::ID lookupIntrinsicID(StringRef Name);
202 /// Recalculate the ID for this function if it is an Intrinsic defined
203 /// in llvm/Intrinsics.h. Sets the intrinsic ID to Intrinsic::not_intrinsic
204 /// if the name of this function does not match an intrinsic in that header.
205 /// Note, this method does not need to be called directly, as it is called
206 /// from Value::setName() whenever the name of this function changes.
207 void recalculateIntrinsicID();
209 /// getCallingConv()/setCallingConv(CC) - These method get and set the
210 /// calling convention of this function. The enum values for the known
211 /// calling conventions are defined in CallingConv.h.
212 CallingConv::ID getCallingConv() const {
213 return static_cast<CallingConv::ID>((getSubclassDataFromValue() >> 4) &
216 void setCallingConv(CallingConv::ID CC) {
217 auto ID = static_cast<unsigned>(CC);
218 assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
219 setValueSubclassData((getSubclassDataFromValue() & 0xc00f) | (ID << 4));
222 /// Return the attribute list for this Function.
223 AttributeList getAttributes() const { return AttributeSets; }
225 /// Set the attribute list for this Function.
226 void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; }
228 /// Add function attributes to this function.
229 void addFnAttr(Attribute::AttrKind Kind) {
230 addAttribute(AttributeList::FunctionIndex, Kind);
233 /// Add function attributes to this function.
234 void addFnAttr(StringRef Kind, StringRef Val = StringRef()) {
235 addAttribute(AttributeList::FunctionIndex,
236 Attribute::get(getContext(), Kind, Val));
239 /// Add function attributes to this function.
240 void addFnAttr(Attribute Attr) {
241 addAttribute(AttributeList::FunctionIndex, Attr);
244 /// Remove function attributes from this function.
245 void removeFnAttr(Attribute::AttrKind Kind) {
246 removeAttribute(AttributeList::FunctionIndex, Kind);
249 /// Remove function attribute from this function.
250 void removeFnAttr(StringRef Kind) {
251 setAttributes(getAttributes().removeAttribute(
252 getContext(), AttributeList::FunctionIndex, Kind));
255 enum ProfileCountType { PCT_Invalid, PCT_Real, PCT_Synthetic };
257 /// Class to represent profile counts.
259 /// This class represents both real and synthetic profile counts.
263 ProfileCountType PCT;
264 static ProfileCount Invalid;
267 ProfileCount() : Count(-1), PCT(PCT_Invalid) {}
268 ProfileCount(uint64_t Count, ProfileCountType PCT)
269 : Count(Count), PCT(PCT) {}
270 bool hasValue() const { return PCT != PCT_Invalid; }
271 uint64_t getCount() const { return Count; }
272 ProfileCountType getType() const { return PCT; }
273 bool isSynthetic() const { return PCT == PCT_Synthetic; }
274 explicit operator bool() { return hasValue(); }
275 bool operator!() const { return !hasValue(); }
276 // Update the count retaining the same profile count type.
277 ProfileCount &setCount(uint64_t C) {
281 static ProfileCount getInvalid() { return ProfileCount(-1, PCT_Invalid); }
284 /// Set the entry count for this function.
286 /// Entry count is the number of times this function was executed based on
287 /// pgo data. \p Imports points to a set of GUIDs that needs to
288 /// be imported by the function for sample PGO, to enable the same inlines as
289 /// the profiled optimized binary.
290 void setEntryCount(ProfileCount Count,
291 const DenseSet<GlobalValue::GUID> *Imports = nullptr);
293 /// A convenience wrapper for setting entry count
294 void setEntryCount(uint64_t Count, ProfileCountType Type = PCT_Real,
295 const DenseSet<GlobalValue::GUID> *Imports = nullptr);
297 /// Get the entry count for this function.
299 /// Entry count is the number of times the function was executed.
300 /// When AllowSynthetic is false, only pgo_data will be returned.
301 ProfileCount getEntryCount(bool AllowSynthetic = false) const;
303 /// Return true if the function is annotated with profile data.
305 /// Presence of entry counts from a profile run implies the function has
306 /// profile annotations. If IncludeSynthetic is false, only return true
307 /// when the profile data is real.
308 bool hasProfileData(bool IncludeSynthetic = false) const {
309 return getEntryCount(IncludeSynthetic).hasValue();
312 /// Returns the set of GUIDs that needs to be imported to the function for
313 /// sample PGO, to enable the same inlines as the profiled optimized binary.
314 DenseSet<GlobalValue::GUID> getImportGUIDs() const;
316 /// Set the section prefix for this function.
317 void setSectionPrefix(StringRef Prefix);
319 /// Get the section prefix for this function.
320 Optional<StringRef> getSectionPrefix() const;
322 /// Return true if the function has the attribute.
323 bool hasFnAttribute(Attribute::AttrKind Kind) const {
324 return AttributeSets.hasFnAttribute(Kind);
327 /// Return true if the function has the attribute.
328 bool hasFnAttribute(StringRef Kind) const {
329 return AttributeSets.hasFnAttribute(Kind);
332 /// Return the attribute for the given attribute kind.
333 Attribute getFnAttribute(Attribute::AttrKind Kind) const {
334 return getAttribute(AttributeList::FunctionIndex, Kind);
337 /// Return the attribute for the given attribute kind.
338 Attribute getFnAttribute(StringRef Kind) const {
339 return getAttribute(AttributeList::FunctionIndex, Kind);
342 /// Return the stack alignment for the function.
343 unsigned getFnStackAlignment() const {
344 if (!hasFnAttribute(Attribute::StackAlignment))
347 AttributeSets.getStackAlignment(AttributeList::FunctionIndex))
352 /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
353 /// to use during code generation.
355 return getSubclassDataFromValue() & (1<<14);
357 const std::string &getGC() const;
358 void setGC(std::string Str);
361 /// adds the attribute to the list of attributes.
362 void addAttribute(unsigned i, Attribute::AttrKind Kind);
364 /// adds the attribute to the list of attributes.
365 void addAttribute(unsigned i, Attribute Attr);
367 /// adds the attributes to the list of attributes.
368 void addAttributes(unsigned i, const AttrBuilder &Attrs);
370 /// adds the attribute to the list of attributes for the given arg.
371 void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
373 /// adds the attribute to the list of attributes for the given arg.
374 void addParamAttr(unsigned ArgNo, Attribute Attr);
376 /// adds the attributes to the list of attributes for the given arg.
377 void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);
379 /// removes the attribute from the list of attributes.
380 void removeAttribute(unsigned i, Attribute::AttrKind Kind);
382 /// removes the attribute from the list of attributes.
383 void removeAttribute(unsigned i, StringRef Kind);
385 /// removes the attributes from the list of attributes.
386 void removeAttributes(unsigned i, const AttrBuilder &Attrs);
388 /// removes the attribute from the list of attributes.
389 void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
391 /// removes the attribute from the list of attributes.
392 void removeParamAttr(unsigned ArgNo, StringRef Kind);
394 /// removes the attribute from the list of attributes.
395 void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);
397 /// check if an attributes is in the list of attributes.
398 bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const {
399 return getAttributes().hasAttribute(i, Kind);
402 /// check if an attributes is in the list of attributes.
403 bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const {
404 return getAttributes().hasParamAttribute(ArgNo, Kind);
407 /// gets the specified attribute from the list of attributes.
408 Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const {
409 return getAttributes().getParamAttr(ArgNo, Kind);
412 /// gets the attribute from the list of attributes.
413 Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
414 return AttributeSets.getAttribute(i, Kind);
417 /// gets the attribute from the list of attributes.
418 Attribute getAttribute(unsigned i, StringRef Kind) const {
419 return AttributeSets.getAttribute(i, Kind);
422 /// adds the dereferenceable attribute to the list of attributes.
423 void addDereferenceableAttr(unsigned i, uint64_t Bytes);
425 /// adds the dereferenceable attribute to the list of attributes for
427 void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes);
429 /// adds the dereferenceable_or_null attribute to the list of
431 void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes);
433 /// adds the dereferenceable_or_null attribute to the list of
434 /// attributes for the given arg.
435 void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes);
437 /// Extract the alignment for a call or parameter (0=unknown).
438 /// FIXME: Remove this function once transition to Align is over.
439 /// Use getParamAlign() instead.
440 unsigned getParamAlignment(unsigned ArgNo) const {
441 if (const auto MA = getParamAlign(ArgNo))
446 MaybeAlign getParamAlign(unsigned ArgNo) const {
447 return AttributeSets.getParamAlignment(ArgNo);
450 /// Extract the byval type for a parameter.
451 Type *getParamByValType(unsigned ArgNo) const {
452 Type *Ty = AttributeSets.getParamByValType(ArgNo);
453 return Ty ? Ty : (arg_begin() + ArgNo)->getType()->getPointerElementType();
456 /// Extract the number of dereferenceable bytes for a call or
457 /// parameter (0=unknown).
458 /// @param i AttributeList index, referring to a return value or argument.
459 uint64_t getDereferenceableBytes(unsigned i) const {
460 return AttributeSets.getDereferenceableBytes(i);
463 /// Extract the number of dereferenceable bytes for a parameter.
464 /// @param ArgNo Index of an argument, with 0 being the first function arg.
465 uint64_t getParamDereferenceableBytes(unsigned ArgNo) const {
466 return AttributeSets.getParamDereferenceableBytes(ArgNo);
469 /// Extract the number of dereferenceable_or_null bytes for a call or
470 /// parameter (0=unknown).
471 /// @param i AttributeList index, referring to a return value or argument.
472 uint64_t getDereferenceableOrNullBytes(unsigned i) const {
473 return AttributeSets.getDereferenceableOrNullBytes(i);
476 /// Extract the number of dereferenceable_or_null bytes for a
478 /// @param ArgNo AttributeList ArgNo, referring to an argument.
479 uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
480 return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo);
483 /// Determine if the function does not access memory.
484 bool doesNotAccessMemory() const {
485 return hasFnAttribute(Attribute::ReadNone);
487 void setDoesNotAccessMemory() {
488 addFnAttr(Attribute::ReadNone);
491 /// Determine if the function does not access or only reads memory.
492 bool onlyReadsMemory() const {
493 return doesNotAccessMemory() || hasFnAttribute(Attribute::ReadOnly);
495 void setOnlyReadsMemory() {
496 addFnAttr(Attribute::ReadOnly);
499 /// Determine if the function does not access or only writes memory.
500 bool doesNotReadMemory() const {
501 return doesNotAccessMemory() || hasFnAttribute(Attribute::WriteOnly);
503 void setDoesNotReadMemory() {
504 addFnAttr(Attribute::WriteOnly);
507 /// Determine if the call can access memmory only using pointers based
508 /// on its arguments.
509 bool onlyAccessesArgMemory() const {
510 return hasFnAttribute(Attribute::ArgMemOnly);
512 void setOnlyAccessesArgMemory() { addFnAttr(Attribute::ArgMemOnly); }
514 /// Determine if the function may only access memory that is
515 /// inaccessible from the IR.
516 bool onlyAccessesInaccessibleMemory() const {
517 return hasFnAttribute(Attribute::InaccessibleMemOnly);
519 void setOnlyAccessesInaccessibleMemory() {
520 addFnAttr(Attribute::InaccessibleMemOnly);
523 /// Determine if the function may only access memory that is
524 /// either inaccessible from the IR or pointed to by its arguments.
525 bool onlyAccessesInaccessibleMemOrArgMem() const {
526 return hasFnAttribute(Attribute::InaccessibleMemOrArgMemOnly);
528 void setOnlyAccessesInaccessibleMemOrArgMem() {
529 addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
532 /// Determine if the function cannot return.
533 bool doesNotReturn() const {
534 return hasFnAttribute(Attribute::NoReturn);
536 void setDoesNotReturn() {
537 addFnAttr(Attribute::NoReturn);
540 /// Determine if the function should not perform indirect branch tracking.
541 bool doesNoCfCheck() const { return hasFnAttribute(Attribute::NoCfCheck); }
543 /// Determine if the function cannot unwind.
544 bool doesNotThrow() const {
545 return hasFnAttribute(Attribute::NoUnwind);
547 void setDoesNotThrow() {
548 addFnAttr(Attribute::NoUnwind);
551 /// Determine if the call cannot be duplicated.
552 bool cannotDuplicate() const {
553 return hasFnAttribute(Attribute::NoDuplicate);
555 void setCannotDuplicate() {
556 addFnAttr(Attribute::NoDuplicate);
559 /// Determine if the call is convergent.
560 bool isConvergent() const {
561 return hasFnAttribute(Attribute::Convergent);
563 void setConvergent() {
564 addFnAttr(Attribute::Convergent);
566 void setNotConvergent() {
567 removeFnAttr(Attribute::Convergent);
570 /// Determine if the call has sideeffects.
571 bool isSpeculatable() const {
572 return hasFnAttribute(Attribute::Speculatable);
574 void setSpeculatable() {
575 addFnAttr(Attribute::Speculatable);
578 /// Determine if the call might deallocate memory.
579 bool doesNotFreeMemory() const {
580 return onlyReadsMemory() || hasFnAttribute(Attribute::NoFree);
582 void setDoesNotFreeMemory() {
583 addFnAttr(Attribute::NoFree);
586 /// Determine if the function is known not to recurse, directly or
588 bool doesNotRecurse() const {
589 return hasFnAttribute(Attribute::NoRecurse);
591 void setDoesNotRecurse() {
592 addFnAttr(Attribute::NoRecurse);
595 /// True if the ABI mandates (or the user requested) that this
596 /// function be in a unwind table.
597 bool hasUWTable() const {
598 return hasFnAttribute(Attribute::UWTable);
600 void setHasUWTable() {
601 addFnAttr(Attribute::UWTable);
604 /// True if this function needs an unwind table.
605 bool needsUnwindTableEntry() const {
606 return hasUWTable() || !doesNotThrow() || hasPersonalityFn();
609 /// Determine if the function returns a structure through first
610 /// or second pointer argument.
611 bool hasStructRetAttr() const {
612 return AttributeSets.hasParamAttribute(0, Attribute::StructRet) ||
613 AttributeSets.hasParamAttribute(1, Attribute::StructRet);
616 /// Determine if the parameter or return value is marked with NoAlias
618 bool returnDoesNotAlias() const {
619 return AttributeSets.hasAttribute(AttributeList::ReturnIndex,
622 void setReturnDoesNotAlias() {
623 addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
626 /// Do not optimize this function (-O0).
627 bool hasOptNone() const { return hasFnAttribute(Attribute::OptimizeNone); }
629 /// Optimize this function for minimum size (-Oz).
630 bool hasMinSize() const { return hasFnAttribute(Attribute::MinSize); }
632 /// Optimize this function for size (-Os) or minimum size (-Oz).
633 bool hasOptSize() const {
634 return hasFnAttribute(Attribute::OptimizeForSize) || hasMinSize();
637 /// copyAttributesFrom - copy all additional attributes (those not needed to
638 /// create a Function) from the Function Src to this one.
639 void copyAttributesFrom(const Function *Src);
641 /// deleteBody - This method deletes the body of the function, and converts
642 /// the linkage to external.
646 setLinkage(ExternalLinkage);
649 /// removeFromParent - This method unlinks 'this' from the containing module,
650 /// but does not delete it.
652 void removeFromParent();
654 /// eraseFromParent - This method unlinks 'this' from the containing module
657 void eraseFromParent();
659 /// Steal arguments from another function.
661 /// Drop this function's arguments and splice in the ones from \c Src.
662 /// Requires that this has no function body.
663 void stealArgumentListFrom(Function &Src);
665 /// Get the underlying elements of the Function... the basic block list is
666 /// empty for external functions.
668 const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
669 BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
671 static BasicBlockListType Function::*getSublistAccess(BasicBlock*) {
672 return &Function::BasicBlocks;
675 const BasicBlock &getEntryBlock() const { return front(); }
676 BasicBlock &getEntryBlock() { return front(); }
678 //===--------------------------------------------------------------------===//
679 // Symbol Table Accessing functions...
681 /// getSymbolTable() - Return the symbol table if any, otherwise nullptr.
683 inline ValueSymbolTable *getValueSymbolTable() { return SymTab.get(); }
684 inline const ValueSymbolTable *getValueSymbolTable() const {
688 //===--------------------------------------------------------------------===//
689 // BasicBlock iterator forwarding functions
691 iterator begin() { return BasicBlocks.begin(); }
692 const_iterator begin() const { return BasicBlocks.begin(); }
693 iterator end () { return BasicBlocks.end(); }
694 const_iterator end () const { return BasicBlocks.end(); }
696 size_t size() const { return BasicBlocks.size(); }
697 bool empty() const { return BasicBlocks.empty(); }
698 const BasicBlock &front() const { return BasicBlocks.front(); }
699 BasicBlock &front() { return BasicBlocks.front(); }
700 const BasicBlock &back() const { return BasicBlocks.back(); }
701 BasicBlock &back() { return BasicBlocks.back(); }
703 /// @name Function Argument Iteration
706 arg_iterator arg_begin() {
707 CheckLazyArguments();
710 const_arg_iterator arg_begin() const {
711 CheckLazyArguments();
715 arg_iterator arg_end() {
716 CheckLazyArguments();
717 return Arguments + NumArgs;
719 const_arg_iterator arg_end() const {
720 CheckLazyArguments();
721 return Arguments + NumArgs;
724 Argument* getArg(unsigned i) const {
725 assert (i < NumArgs && "getArg() out of range!");
726 CheckLazyArguments();
727 return Arguments + i;
730 iterator_range<arg_iterator> args() {
731 return make_range(arg_begin(), arg_end());
733 iterator_range<const_arg_iterator> args() const {
734 return make_range(arg_begin(), arg_end());
739 size_t arg_size() const { return NumArgs; }
740 bool arg_empty() const { return arg_size() == 0; }
742 /// Check whether this function has a personality function.
743 bool hasPersonalityFn() const {
744 return getSubclassDataFromValue() & (1<<3);
747 /// Get the personality function associated with this function.
748 Constant *getPersonalityFn() const;
749 void setPersonalityFn(Constant *Fn);
751 /// Check whether this function has prefix data.
752 bool hasPrefixData() const {
753 return getSubclassDataFromValue() & (1<<1);
756 /// Get the prefix data associated with this function.
757 Constant *getPrefixData() const;
758 void setPrefixData(Constant *PrefixData);
760 /// Check whether this function has prologue data.
761 bool hasPrologueData() const {
762 return getSubclassDataFromValue() & (1<<2);
765 /// Get the prologue data associated with this function.
766 Constant *getPrologueData() const;
767 void setPrologueData(Constant *PrologueData);
769 /// Print the function to an output stream with an optional
770 /// AssemblyAnnotationWriter.
771 void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr,
772 bool ShouldPreserveUseListOrder = false,
773 bool IsForDebug = false) const;
775 /// viewCFG - This function is meant for use from the debugger. You can just
776 /// say 'call F->viewCFG()' and a ghostview window should pop up from the
777 /// program, displaying the CFG of the current function with the code for each
778 /// basic block inside. This depends on there being a 'dot' and 'gv' program
781 void viewCFG() const;
783 /// viewCFGOnly - This function is meant for use from the debugger. It works
784 /// just like viewCFG, but it does not include the contents of basic blocks
785 /// into the nodes, just the label. If you are only interested in the CFG
786 /// this can make the graph smaller.
788 void viewCFGOnly() const;
790 /// Methods for support type inquiry through isa, cast, and dyn_cast:
791 static bool classof(const Value *V) {
792 return V->getValueID() == Value::FunctionVal;
795 /// dropAllReferences() - This method causes all the subinstructions to "let
796 /// go" of all references that they are maintaining. This allows one to
797 /// 'delete' a whole module at a time, even though there may be circular
798 /// references... first all references are dropped, and all use counts go to
799 /// zero. Then everything is deleted for real. Note that no operations are
800 /// valid on an object that has "dropped all references", except operator
803 /// Since no other object in the module can have references into the body of a
804 /// function, dropping all references deletes the entire body of the function,
805 /// including any contained basic blocks.
807 void dropAllReferences();
809 /// hasAddressTaken - returns true if there are any uses of this function
810 /// other than direct calls or invokes to it, or blockaddress expressions.
811 /// Optionally passes back an offending user for diagnostic purposes.
813 bool hasAddressTaken(const User** = nullptr) const;
815 /// isDefTriviallyDead - Return true if it is trivially safe to remove
816 /// this function definition from the module (because it isn't externally
817 /// visible, does not have its address taken, and has no callers). To make
818 /// this more accurate, call removeDeadConstantUsers first.
819 bool isDefTriviallyDead() const;
821 /// callsFunctionThatReturnsTwice - Return true if the function has a call to
822 /// setjmp or other function that gcc recognizes as "returning twice".
823 bool callsFunctionThatReturnsTwice() const;
825 /// Set the attached subprogram.
827 /// Calls \a setMetadata() with \a LLVMContext::MD_dbg.
828 void setSubprogram(DISubprogram *SP);
830 /// Get the attached subprogram.
832 /// Calls \a getMetadata() with \a LLVMContext::MD_dbg and casts the result
833 /// to \a DISubprogram.
834 DISubprogram *getSubprogram() const;
836 /// Returns true if we should emit debug info for profiling.
837 bool isDebugInfoForProfiling() const;
839 /// Check if null pointer dereferencing is considered undefined behavior for
841 /// Return value: false => null pointer dereference is undefined.
842 /// Return value: true => null pointer dereference is not undefined.
843 bool nullPointerIsDefined() const;
846 void allocHungoffUselist();
847 template<int Idx> void setHungoffOperand(Constant *C);
849 /// Shadow Value::setValueSubclassData with a private forwarding method so
850 /// that subclasses cannot accidentally use it.
851 void setValueSubclassData(unsigned short D) {
852 Value::setValueSubclassData(D);
854 void setValueSubclassDataBit(unsigned Bit, bool On);
857 /// Check whether null pointer dereferencing is considered undefined behavior
858 /// for a given function or an address space.
859 /// Null pointer access in non-zero address space is not considered undefined.
860 /// Return value: false => null pointer dereference is undefined.
861 /// Return value: true => null pointer dereference is not undefined.
862 bool NullPointerIsDefined(const Function *F, unsigned AS = 0);
865 struct OperandTraits<Function> : public HungoffOperandTraits<3> {};
867 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Function, Value)
869 } // end namespace llvm
871 #endif // LLVM_IR_FUNCTION_H