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