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