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