LLVM  8.0.0svn
Function.h
Go to the documentation of this file.
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"
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"
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:
63 
64  // BasicBlock iterators...
67 
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 
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:
105  bool hasLazyArguments() const {
106  return getSubclassDataFromValue() & (1<<0);
107  }
108 
109 private:
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().
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.
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.
165  return cast<FunctionType>(getValueType());
166  }
167 
168  /// Returns the type of the ret val.
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.
177  bool isVarArg() const { return getFunctionType()->isVarArg(); }
178 
179  bool isMaterializable() const {
180  return getGlobalObjectSubClassData() & (1 << IsMaterializableBit);
181  }
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.
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!
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.
214  return static_cast<CallingConv::ID>((getSubclassDataFromValue() >> 4) &
216  }
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.
224  AttributeList getAttributes() const { return AttributeSets; }
225 
226  /// Set the attribute list for this Function.
227  void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; }
228 
229  /// Add function attributes to this function.
231  addAttribute(AttributeList::FunctionIndex, Kind);
232  }
233 
234  /// Add function attributes to this function.
236  addAttribute(AttributeList::FunctionIndex,
237  Attribute::get(getContext(), Kind, Val));
238  }
239 
240  /// Add function attributes to this function.
241  void addFnAttr(Attribute Attr) {
242  addAttribute(AttributeList::FunctionIndex, Attr);
243  }
244 
245  /// Remove function attributes from this function.
247  removeAttribute(AttributeList::FunctionIndex, Kind);
248  }
249 
250  /// Remove function attribute from this function.
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:
268  ProfileCount() : Count(-1), PCT(PCT_Invalid) {}
269  ProfileCount(uint64_t Count, ProfileCountType PCT)
270  : Count(Count), PCT(PCT) {}
271  bool hasValue() const { return PCT != PCT_Invalid; }
272  uint64_t getCount() const { return Count; }
273  ProfileCountType getType() const { return PCT; }
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.
278  ProfileCount &setCount(uint64_t C) {
279  Count = C;
280  return *this;
281  }
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.
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.
322  return AttributeSets.hasFnAttribute(Kind);
323  }
324 
325  /// Return true if the function has the attribute.
326  bool hasFnAttribute(StringRef Kind) const {
327  return AttributeSets.hasFnAttribute(Kind);
328  }
329 
330  /// Return the attribute for the given attribute kind.
332  return getAttribute(AttributeList::FunctionIndex, Kind);
333  }
334 
335  /// Return the attribute for the given attribute kind.
337  return getAttribute(AttributeList::FunctionIndex, Kind);
338  }
339 
340  /// Return the stack alignment for the function.
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.
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.
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.
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.
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.
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).
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.
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.
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.
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.
455  uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
456  return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo);
457  }
458 
459  /// Determine if the function does not access memory.
460  bool doesNotAccessMemory() const {
461  return hasFnAttribute(Attribute::ReadNone);
462  }
464  addFnAttr(Attribute::ReadNone);
465  }
466 
467  /// Determine if the function does not access or only reads memory.
468  bool onlyReadsMemory() const {
469  return doesNotAccessMemory() || hasFnAttribute(Attribute::ReadOnly);
470  }
472  addFnAttr(Attribute::ReadOnly);
473  }
474 
475  /// Determine if the function does not access or only writes memory.
476  bool doesNotReadMemory() const {
477  return doesNotAccessMemory() || hasFnAttribute(Attribute::WriteOnly);
478  }
480  addFnAttr(Attribute::WriteOnly);
481  }
482 
483  /// Determine if the call can access memmory only using pointers based
484  /// on its arguments.
485  bool onlyAccessesArgMemory() const {
486  return hasFnAttribute(Attribute::ArgMemOnly);
487  }
488  void setOnlyAccessesArgMemory() { addFnAttr(Attribute::ArgMemOnly); }
489 
490  /// Determine if the function may only access memory that is
491  /// inaccessible from the IR.
493  return hasFnAttribute(Attribute::InaccessibleMemOnly);
494  }
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.
502  return hasFnAttribute(Attribute::InaccessibleMemOrArgMemOnly);
503  }
505  addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
506  }
507 
508  /// Determine if the function cannot return.
509  bool doesNotReturn() const {
510  return hasFnAttribute(Attribute::NoReturn);
511  }
513  addFnAttr(Attribute::NoReturn);
514  }
515 
516  /// Determine if the function should not perform indirect branch tracking.
517  bool doesNoCfCheck() const { return hasFnAttribute(Attribute::NoCfCheck); }
518 
519  /// Determine if the function cannot unwind.
520  bool doesNotThrow() const {
521  return hasFnAttribute(Attribute::NoUnwind);
522  }
524  addFnAttr(Attribute::NoUnwind);
525  }
526 
527  /// Determine if the call cannot be duplicated.
528  bool cannotDuplicate() const {
529  return hasFnAttribute(Attribute::NoDuplicate);
530  }
532  addFnAttr(Attribute::NoDuplicate);
533  }
534 
535  /// Determine if the call is convergent.
536  bool isConvergent() const {
537  return hasFnAttribute(Attribute::Convergent);
538  }
539  void setConvergent() {
540  addFnAttr(Attribute::Convergent);
541  }
543  removeFnAttr(Attribute::Convergent);
544  }
545 
546  /// Determine if the call has sideeffects.
547  bool isSpeculatable() const {
548  return hasFnAttribute(Attribute::Speculatable);
549  }
551  addFnAttr(Attribute::Speculatable);
552  }
553 
554  /// Determine if the function is known not to recurse, directly or
555  /// indirectly.
556  bool doesNotRecurse() const {
557  return hasFnAttribute(Attribute::NoRecurse);
558  }
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.
565  bool hasUWTable() const {
566  return hasFnAttribute(Attribute::UWTable);
567  }
568  void setHasUWTable() {
569  addFnAttr(Attribute::UWTable);
570  }
571 
572  /// True if this function needs an unwind table.
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.
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.
586  bool returnDoesNotAlias() const {
587  return AttributeSets.hasAttribute(AttributeList::ReturnIndex,
589  }
592  }
593 
594  /// Optimize this function for minimum size (-Oz).
595  bool optForMinSize() const { return hasFnAttribute(Attribute::MinSize); }
596 
597  /// Optimize this function for size (-Os) or minimum size (-Oz).
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  ///
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  ///
633  const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
634  BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
635 
637  return &Function::BasicBlocks;
638  }
639 
640  const BasicBlock &getEntryBlock() const { return front(); }
641  BasicBlock &getEntryBlock() { return front(); }
642 
643  //===--------------------------------------------------------------------===//
644  // Symbol Table Accessing functions...
645 
646  /// getSymbolTable() - Return the symbol table if any, otherwise nullptr.
647  ///
648  inline ValueSymbolTable *getValueSymbolTable() { return SymTab.get(); }
649  inline const ValueSymbolTable *getValueSymbolTable() const {
650  return SymTab.get();
651  }
652 
653  //===--------------------------------------------------------------------===//
654  // BasicBlock iterator forwarding functions
655  //
656  iterator begin() { return BasicBlocks.begin(); }
657  const_iterator begin() const { return BasicBlocks.begin(); }
658  iterator end () { return BasicBlocks.end(); }
659  const_iterator end () const { return BasicBlocks.end(); }
660 
661  size_t size() const { return BasicBlocks.size(); }
662  bool empty() const { return BasicBlocks.empty(); }
663  const BasicBlock &front() const { return BasicBlocks.front(); }
664  BasicBlock &front() { return BasicBlocks.front(); }
665  const BasicBlock &back() const { return BasicBlocks.back(); }
666  BasicBlock &back() { return BasicBlocks.back(); }
667 
668 /// @name Function Argument Iteration
669 /// @{
670 
672  CheckLazyArguments();
673  return Arguments;
674  }
676  CheckLazyArguments();
677  return Arguments;
678  }
679 
681  CheckLazyArguments();
682  return Arguments + NumArgs;
683  }
685  CheckLazyArguments();
686  return Arguments + NumArgs;
687  }
688 
690  return make_range(arg_begin(), arg_end());
691  }
693  return make_range(arg_begin(), arg_end());
694  }
695 
696 /// @}
697 
698  size_t arg_size() const { return NumArgs; }
699  bool arg_empty() const { return arg_size() == 0; }
700 
701  /// Check whether this function has a personality function.
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.
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.
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:
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.
810  void setValueSubclassData(unsigned short 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 <>
825 
827 
828 } // end namespace llvm
829 
830 #endif // LLVM_IR_FUNCTION_H
size_t size() const
Definition: Function.h:661
const Function & getFunction() const
Definition: Function.h:134
bool isVarArg() const
isVarArg - Return true if this function takes a variable number of arguments.
Definition: Function.h:177
bool onlyReadsMemory() const
Determine if the function does not access or only reads memory.
Definition: Function.h:468
uint64_t CallInst * C
bool isIntrinsic() const
isIntrinsic - Returns true if the function&#39;s name starts with "llvm.".
Definition: Function.h:199
void setConvergent()
Definition: Function.h:539
This class provides a symbol table of name/value pairs.
Type
MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...
Definition: MsgPackReader.h:49
bool empty() const
Definition: Function.h:662
unsigned getFnStackAlignment() const
Return the stack alignment for the function.
Definition: Function.h:341
const_iterator begin() const
Definition: Function.h:657
This class represents an incoming formal argument to a Function.
Definition: Argument.h:30
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:464
bool isSpeculatable() const
Determine if the call has sideeffects.
Definition: Function.h:547
uint64_t getParamDereferenceableBytes(unsigned ArgNo) const
Extract the number of dereferenceable bytes for a parameter.
Definition: Function.h:441
This class represents lattice values for constants.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
iterator end()
Definition: Function.h:658
Implements a dense probed hash-table based set.
Definition: DenseSet.h:250
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
unsigned getParamAlignment(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: Function.h:428
bool hasFnAttribute(StringRef Kind) const
Return true if the function has the attribute.
Definition: Function.h:326
The two locations do not alias at all.
Definition: AliasAnalysis.h:85
const BasicBlock & back() const
Definition: Function.h:665
void setDoesNotRecurse()
Definition: Function.h:559
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:720
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:321
arg_iterator arg_end()
Definition: Function.h:680
F(f)
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
void setDoesNotReadMemory()
Definition: Function.h:479
void setDoesNotThrow()
Definition: Function.h:523
bool hasStructRetAttr() const
Determine if the function returns a structure through first or second pointer argument.
Definition: Function.h:579
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:711
amdgpu Simplify well known AMD library false Value Value const Twine & Name
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
uint64_t getDereferenceableBytes(unsigned Index) const
Get the number of dereferenceable bytes (or zero if unknown).
uint64_t getDereferenceableBytes(unsigned i) const
Extract the number of dereferenceable bytes for a call or parameter (0=unknown).
Definition: Function.h:435
bool hasUWTable() const
True if the ABI mandates (or the user requested) that this function be in a unwind table...
Definition: Function.h:565
This file contains the simple types necessary to represent the attributes associated with functions a...
Attribute getAttribute(unsigned i, StringRef Kind) const
gets the attribute from the list of attributes.
Definition: Function.h:408
bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
check if an attributes is in the list of attributes.
Definition: Function.h:398
The highest possible calling convention ID. Must be some 2^k - 1.
Definition: CallingConv.h:227
bool onlyAccessesInaccessibleMemory() const
Determine if the function may only access memory that is inaccessible from the IR.
Definition: Function.h:492
AttributeList getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
Subprogram description.
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
Class to represent function types.
Definition: DerivedTypes.h:103
static BasicBlockListType Function::* getSublistAccess(BasicBlock *)
Definition: Function.h:636
bool arg_empty() const
Definition: Function.h:699
bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const
check if an attributes is in the list of attributes.
Definition: Function.h:393
uint64_t getDereferenceableOrNullBytes(unsigned Index) const
Get the number of dereferenceable_or_null bytes (or zero if unknown).
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:224
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:702
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
iterator begin()
Definition: Function.h:656
void setSpeculatable()
Definition: Function.h:550
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Extract the number of dereferenceable_or_null bytes for a parameter.
Definition: Function.h:455
void setIsMaterializable(bool V)
Definition: Function.h:182
void setOnlyAccessesArgMemory()
Definition: Function.h:488
bool doesNotAccessMemory() const
Determine if the function does not access memory.
Definition: Function.h:460
uint64_t getDereferenceableOrNullBytes(unsigned i) const
Extract the number of dereferenceable_or_null bytes for a call or parameter (0=unknown).
Definition: Function.h:448
const BasicBlock & getEntryBlock() const
Definition: Function.h:640
bool cannotDuplicate() const
Determine if the call cannot be duplicated.
Definition: Function.h:528
unsigned getStackAlignment(unsigned Index) const
Get the stack alignment.
void setCallingConv(CallingConv::ID CC)
Definition: Function.h:217
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.h:169
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:136
void setOnlyReadsMemory()
Definition: Function.h:471
uint64_t getCount() const
Definition: Function.h:272
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
void deleteBody()
deleteBody - This method deletes the body of the function, and converts the linkage to external...
Definition: Function.h:609
This is an important base class in LLVM.
Definition: Constant.h:42
bool returnDoesNotAlias() const
Determine if the parameter or return value is marked with NoAlias attribute.
Definition: Function.h:586
BasicBlock & getEntryBlock()
Definition: Function.h:641
BasicBlock & front()
Definition: Function.h:664
void addFnAttr(StringRef Kind, StringRef Val=StringRef())
Add function attributes to this function.
Definition: Function.h:235
AMDGPU Lower Kernel Arguments
BasicBlock & back()
Definition: Function.h:666
bool doesNotReturn() const
Determine if the function cannot return.
Definition: Function.h:509
iterator_range< const_arg_iterator > args() const
Definition: Function.h:692
bool optForSize() const
Optimize this function for size (-Os) or minimum size (-Oz).
Definition: Function.h:598
size_t arg_size() const
Definition: Function.h:698
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
arg_iterator arg_begin()
Definition: Function.h:671
void setHasUWTable()
Definition: Function.h:568
bool isMaterializable() const
Definition: Function.h:179
#define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS)
Macro for generating in-class operand accessor declarations.
Attribute getAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return the attribute object that exists at the given index.
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&... Args)
Definition: DIBuilder.cpp:746
Class to represent profile counts.
Definition: Function.h:261
void setCannotDuplicate()
Definition: Function.h:531
void addFnAttr(Attribute Attr)
Add function attributes to this function.
Definition: Function.h:241
BasicBlockListType & getBasicBlockList()
Definition: Function.h:634
bool doesNotRecurse() const
Determine if the function is known not to recurse, directly or indirectly.
Definition: Function.h:556
bool doesNotThrow() const
Determine if the function cannot unwind.
Definition: Function.h:520
ProfileCount & setCount(uint64_t C)
Definition: Function.h:278
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Iterator for intrusive lists based on ilist_node.
bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
Equivalent to hasAttribute(ArgNo + FirstArgIndex, Kind).
void setDoesNotReturn()
Definition: Function.h:512
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:213
void setOnlyAccessesInaccessibleMemOrArgMem()
Definition: Function.h:504
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static ProfileCount getInvalid()
Definition: Function.h:282
void setNotConvergent()
Definition: Function.h:542
ProfileCount(uint64_t Count, ProfileCountType PCT)
Definition: Function.h:269
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
Definition: Function.cpp:1440
void setOnlyAccessesInaccessibleMemory()
Definition: Function.h:495
void setValueSubclassData(unsigned short D)
Definition: Value.h:656
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:227
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:194
ValueSymbolTable * getValueSymbolTable()
getSymbolTable() - Return the symbol table if any, otherwise nullptr.
Definition: Function.h:648
bool needsUnwindTableEntry() const
True if this function needs an unwind table.
Definition: Function.h:573
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:164
A range adaptor for a pair of iterators.
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Function.h:750
uint64_t getParamDereferenceableBytes(unsigned ArgNo) const
Get the number of dereferenceable bytes (or zero if unknown) of an arg.
Definition: Attributes.h:610
const_arg_iterator arg_end() const
Definition: Function.h:684
could "use" a pointer
Function::ProfileCount ProfileCount
Definition: Function.cpp:58
unsigned getParamAlignment(unsigned ArgNo) const
Return the alignment for the specified function parameter.
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.h:349
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Get the number of dereferenceable_or_null bytes (or zero if unknown) of an arg.
Definition: Attributes.h:620
void setDoesNotAccessMemory()
Definition: Function.h:463
#define N
#define LLVM_READONLY
Definition: Compiler.h:184
bool optForMinSize() const
Optimize this function for minimum size (-Oz).
Definition: Function.h:595
bool onlyAccessesArgMemory() const
Determine if the call can access memmory only using pointers based on its arguments.
Definition: Function.h:485
bool doesNotReadMemory() const
Determine if the function does not access or only writes memory.
Definition: Function.h:476
Compile-time customization of User operands.
Definition: User.h:43
bool onlyAccessesInaccessibleMemOrArgMem() const
Determine if the function may only access memory that is either inaccessible from the IR or pointed t...
Definition: Function.h:501
const_arg_iterator arg_begin() const
Definition: Function.h:675
const BasicBlockListType & getBasicBlockList() const
Get the underlying elements of the Function...
Definition: Function.h:633
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
Definition: Attributes.cpp:81
const ValueSymbolTable * getValueSymbolTable() const
Definition: Function.h:649
void removeFnAttr(Attribute::AttrKind Kind)
Remove function attributes from this function.
Definition: Function.h:246
const unsigned Kind
bool hasFnAttribute(Attribute::AttrKind Kind) const
Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but may be faster. ...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
const BasicBlock & front() const
Definition: Function.h:663
aarch64 promote const
LLVM Value Representation.
Definition: Value.h:73
HungoffOperandTraits - determine the allocation regime of the Use array when it is not a prefix to th...
Definition: OperandTraits.h:96
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:81
ProfileCountType getType() const
Definition: Function.h:273
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Definition: Function.h:331
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
Definition: Function.h:230
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const
gets the attribute from the list of attributes.
Definition: Function.h:403
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:143
Attribute getFnAttribute(StringRef Kind) const
Return the attribute for the given attribute kind.
Definition: Function.h:336
bool doesNoCfCheck() const
Determine if the function should not perform indirect branch tracking.
Definition: Function.h:517
const_iterator end() const
Definition: Function.h:659
bool isConvergent() const
Determine if the call is convergent.
Definition: Function.h:536
bool hasProfileData() const
Return true if the function is annotated with profile data.
Definition: Function.h:308
void removeFnAttr(StringRef Kind)
Remove function attribute from this function.
Definition: Function.h:251
bool hasLazyArguments() const
hasLazyArguments/CheckLazyArguments - The argument list of a function is built on demand...
Definition: Function.h:105
iterator_range< arg_iterator > args()
Definition: Function.h:689
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:70
void setReturnDoesNotAlias()
Definition: Function.h:590