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  return AttributeSets.getStackAlignment(AttributeList::FunctionIndex);
347  }
348 
349  /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
350  /// to use during code generation.
351  bool hasGC() const {
352  return getSubclassDataFromValue() & (1<<14);
353  }
354  const std::string &getGC() const;
355  void setGC(std::string Str);
356  void clearGC();
357 
358  /// adds the attribute to the list of attributes.
359  void addAttribute(unsigned i, Attribute::AttrKind Kind);
360 
361  /// adds the attribute to the list of attributes.
362  void addAttribute(unsigned i, Attribute Attr);
363 
364  /// adds the attributes to the list of attributes.
365  void addAttributes(unsigned i, const AttrBuilder &Attrs);
366 
367  /// adds the attribute to the list of attributes for the given arg.
368  void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
369 
370  /// adds the attribute to the list of attributes for the given arg.
371  void addParamAttr(unsigned ArgNo, Attribute Attr);
372 
373  /// adds the attributes to the list of attributes for the given arg.
374  void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);
375 
376  /// removes the attribute from the list of attributes.
377  void removeAttribute(unsigned i, Attribute::AttrKind Kind);
378 
379  /// removes the attribute from the list of attributes.
380  void removeAttribute(unsigned i, StringRef Kind);
381 
382  /// removes the attributes from the list of attributes.
383  void removeAttributes(unsigned i, const AttrBuilder &Attrs);
384 
385  /// removes the attribute from the list of attributes.
386  void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
387 
388  /// removes the attribute from the list of attributes.
389  void removeParamAttr(unsigned ArgNo, StringRef Kind);
390 
391  /// removes the attribute from the list of attributes.
392  void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);
393 
394  /// check if an attributes is in the list of attributes.
395  bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const {
396  return getAttributes().hasAttribute(i, Kind);
397  }
398 
399  /// check if an attributes is in the list of attributes.
400  bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const {
401  return getAttributes().hasParamAttribute(ArgNo, Kind);
402  }
403 
404  /// gets the specified attribute from the list of attributes.
405  Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const {
406  return getAttributes().getParamAttr(ArgNo, Kind);
407  }
408 
409  /// gets the attribute from the list of attributes.
410  Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
411  return AttributeSets.getAttribute(i, Kind);
412  }
413 
414  /// gets the attribute from the list of attributes.
415  Attribute getAttribute(unsigned i, StringRef Kind) const {
416  return AttributeSets.getAttribute(i, Kind);
417  }
418 
419  /// adds the dereferenceable attribute to the list of attributes.
420  void addDereferenceableAttr(unsigned i, uint64_t Bytes);
421 
422  /// adds the dereferenceable attribute to the list of attributes for
423  /// the given arg.
424  void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes);
425 
426  /// adds the dereferenceable_or_null attribute to the list of
427  /// attributes.
428  void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes);
429 
430  /// adds the dereferenceable_or_null attribute to the list of
431  /// attributes for the given arg.
432  void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes);
433 
434  /// Extract the alignment for a call or parameter (0=unknown).
435  unsigned getParamAlignment(unsigned ArgNo) const {
436  return AttributeSets.getParamAlignment(ArgNo);
437  }
438 
439  /// Extract the byval type for a parameter.
440  Type *getParamByValType(unsigned ArgNo) const {
441  Type *Ty = AttributeSets.getParamByValType(ArgNo);
442  return Ty ? Ty : (arg_begin() + ArgNo)->getType()->getPointerElementType();
443  }
444 
445  /// Extract the number of dereferenceable bytes for a call or
446  /// parameter (0=unknown).
447  /// @param i AttributeList index, referring to a return value or argument.
448  uint64_t getDereferenceableBytes(unsigned i) const {
449  return AttributeSets.getDereferenceableBytes(i);
450  }
451 
452  /// Extract the number of dereferenceable bytes for a parameter.
453  /// @param ArgNo Index of an argument, with 0 being the first function arg.
454  uint64_t getParamDereferenceableBytes(unsigned ArgNo) const {
455  return AttributeSets.getParamDereferenceableBytes(ArgNo);
456  }
457 
458  /// Extract the number of dereferenceable_or_null bytes for a call or
459  /// parameter (0=unknown).
460  /// @param i AttributeList index, referring to a return value or argument.
461  uint64_t getDereferenceableOrNullBytes(unsigned i) const {
462  return AttributeSets.getDereferenceableOrNullBytes(i);
463  }
464 
465  /// Extract the number of dereferenceable_or_null bytes for a
466  /// parameter.
467  /// @param ArgNo AttributeList ArgNo, referring to an argument.
468  uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
469  return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo);
470  }
471 
472  /// Determine if the function does not access memory.
473  bool doesNotAccessMemory() const {
474  return hasFnAttribute(Attribute::ReadNone);
475  }
477  addFnAttr(Attribute::ReadNone);
478  }
479 
480  /// Determine if the function does not access or only reads memory.
481  bool onlyReadsMemory() const {
482  return doesNotAccessMemory() || hasFnAttribute(Attribute::ReadOnly);
483  }
485  addFnAttr(Attribute::ReadOnly);
486  }
487 
488  /// Determine if the function does not access or only writes memory.
489  bool doesNotReadMemory() const {
490  return doesNotAccessMemory() || hasFnAttribute(Attribute::WriteOnly);
491  }
493  addFnAttr(Attribute::WriteOnly);
494  }
495 
496  /// Determine if the call can access memmory only using pointers based
497  /// on its arguments.
498  bool onlyAccessesArgMemory() const {
499  return hasFnAttribute(Attribute::ArgMemOnly);
500  }
501  void setOnlyAccessesArgMemory() { addFnAttr(Attribute::ArgMemOnly); }
502 
503  /// Determine if the function may only access memory that is
504  /// inaccessible from the IR.
506  return hasFnAttribute(Attribute::InaccessibleMemOnly);
507  }
509  addFnAttr(Attribute::InaccessibleMemOnly);
510  }
511 
512  /// Determine if the function may only access memory that is
513  /// either inaccessible from the IR or pointed to by its arguments.
515  return hasFnAttribute(Attribute::InaccessibleMemOrArgMemOnly);
516  }
518  addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
519  }
520 
521  /// Determine if the function cannot return.
522  bool doesNotReturn() const {
523  return hasFnAttribute(Attribute::NoReturn);
524  }
526  addFnAttr(Attribute::NoReturn);
527  }
528 
529  /// Determine if the function should not perform indirect branch tracking.
530  bool doesNoCfCheck() const { return hasFnAttribute(Attribute::NoCfCheck); }
531 
532  /// Determine if the function cannot unwind.
533  bool doesNotThrow() const {
534  return hasFnAttribute(Attribute::NoUnwind);
535  }
537  addFnAttr(Attribute::NoUnwind);
538  }
539 
540  /// Determine if the call cannot be duplicated.
541  bool cannotDuplicate() const {
542  return hasFnAttribute(Attribute::NoDuplicate);
543  }
545  addFnAttr(Attribute::NoDuplicate);
546  }
547 
548  /// Determine if the call is convergent.
549  bool isConvergent() const {
550  return hasFnAttribute(Attribute::Convergent);
551  }
552  void setConvergent() {
553  addFnAttr(Attribute::Convergent);
554  }
556  removeFnAttr(Attribute::Convergent);
557  }
558 
559  /// Determine if the call has sideeffects.
560  bool isSpeculatable() const {
561  return hasFnAttribute(Attribute::Speculatable);
562  }
564  addFnAttr(Attribute::Speculatable);
565  }
566 
567  /// Determine if the call might deallocate memory.
568  bool doesNotFreeMemory() const {
569  return onlyReadsMemory() || hasFnAttribute(Attribute::NoFree);
570  }
572  addFnAttr(Attribute::NoFree);
573  }
574 
575  /// Determine if the function is known not to recurse, directly or
576  /// indirectly.
577  bool doesNotRecurse() const {
578  return hasFnAttribute(Attribute::NoRecurse);
579  }
581  addFnAttr(Attribute::NoRecurse);
582  }
583 
584  /// True if the ABI mandates (or the user requested) that this
585  /// function be in a unwind table.
586  bool hasUWTable() const {
587  return hasFnAttribute(Attribute::UWTable);
588  }
589  void setHasUWTable() {
590  addFnAttr(Attribute::UWTable);
591  }
592 
593  /// True if this function needs an unwind table.
594  bool needsUnwindTableEntry() const {
595  return hasUWTable() || !doesNotThrow() || hasPersonalityFn();
596  }
597 
598  /// Determine if the function returns a structure through first
599  /// or second pointer argument.
600  bool hasStructRetAttr() const {
601  return AttributeSets.hasParamAttribute(0, Attribute::StructRet) ||
602  AttributeSets.hasParamAttribute(1, Attribute::StructRet);
603  }
604 
605  /// Determine if the parameter or return value is marked with NoAlias
606  /// attribute.
607  bool returnDoesNotAlias() const {
608  return AttributeSets.hasAttribute(AttributeList::ReturnIndex,
610  }
613  }
614 
615  /// Do not optimize this function (-O0).
616  bool hasOptNone() const { return hasFnAttribute(Attribute::OptimizeNone); }
617 
618  /// Optimize this function for minimum size (-Oz).
619  bool hasMinSize() const { return hasFnAttribute(Attribute::MinSize); }
620 
621  /// Optimize this function for size (-Os) or minimum size (-Oz).
622  bool hasOptSize() const {
623  return hasFnAttribute(Attribute::OptimizeForSize) || hasMinSize();
624  }
625 
626  /// copyAttributesFrom - copy all additional attributes (those not needed to
627  /// create a Function) from the Function Src to this one.
628  void copyAttributesFrom(const Function *Src);
629 
630  /// deleteBody - This method deletes the body of the function, and converts
631  /// the linkage to external.
632  ///
633  void deleteBody() {
634  dropAllReferences();
635  setLinkage(ExternalLinkage);
636  }
637 
638  /// removeFromParent - This method unlinks 'this' from the containing module,
639  /// but does not delete it.
640  ///
641  void removeFromParent();
642 
643  /// eraseFromParent - This method unlinks 'this' from the containing module
644  /// and deletes it.
645  ///
646  void eraseFromParent();
647 
648  /// Steal arguments from another function.
649  ///
650  /// Drop this function's arguments and splice in the ones from \c Src.
651  /// Requires that this has no function body.
652  void stealArgumentListFrom(Function &Src);
653 
654  /// Get the underlying elements of the Function... the basic block list is
655  /// empty for external functions.
656  ///
657  const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
658  BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
659 
661  return &Function::BasicBlocks;
662  }
663 
664  const BasicBlock &getEntryBlock() const { return front(); }
665  BasicBlock &getEntryBlock() { return front(); }
666 
667  //===--------------------------------------------------------------------===//
668  // Symbol Table Accessing functions...
669 
670  /// getSymbolTable() - Return the symbol table if any, otherwise nullptr.
671  ///
672  inline ValueSymbolTable *getValueSymbolTable() { return SymTab.get(); }
673  inline const ValueSymbolTable *getValueSymbolTable() const {
674  return SymTab.get();
675  }
676 
677  //===--------------------------------------------------------------------===//
678  // BasicBlock iterator forwarding functions
679  //
680  iterator begin() { return BasicBlocks.begin(); }
681  const_iterator begin() const { return BasicBlocks.begin(); }
682  iterator end () { return BasicBlocks.end(); }
683  const_iterator end () const { return BasicBlocks.end(); }
684 
685  size_t size() const { return BasicBlocks.size(); }
686  bool empty() const { return BasicBlocks.empty(); }
687  const BasicBlock &front() const { return BasicBlocks.front(); }
688  BasicBlock &front() { return BasicBlocks.front(); }
689  const BasicBlock &back() const { return BasicBlocks.back(); }
690  BasicBlock &back() { return BasicBlocks.back(); }
691 
692 /// @name Function Argument Iteration
693 /// @{
694 
696  CheckLazyArguments();
697  return Arguments;
698  }
700  CheckLazyArguments();
701  return Arguments;
702  }
703 
705  CheckLazyArguments();
706  return Arguments + NumArgs;
707  }
709  CheckLazyArguments();
710  return Arguments + NumArgs;
711  }
712 
713  Argument* getArg(unsigned i) const {
714  assert (i < NumArgs && "getArg() out of range!");
715  CheckLazyArguments();
716  return Arguments + i;
717  }
718 
720  return make_range(arg_begin(), arg_end());
721  }
723  return make_range(arg_begin(), arg_end());
724  }
725 
726 /// @}
727 
728  size_t arg_size() const { return NumArgs; }
729  bool arg_empty() const { return arg_size() == 0; }
730 
731  /// Check whether this function has a personality function.
732  bool hasPersonalityFn() const {
733  return getSubclassDataFromValue() & (1<<3);
734  }
735 
736  /// Get the personality function associated with this function.
737  Constant *getPersonalityFn() const;
738  void setPersonalityFn(Constant *Fn);
739 
740  /// Check whether this function has prefix data.
741  bool hasPrefixData() const {
742  return getSubclassDataFromValue() & (1<<1);
743  }
744 
745  /// Get the prefix data associated with this function.
746  Constant *getPrefixData() const;
747  void setPrefixData(Constant *PrefixData);
748 
749  /// Check whether this function has prologue data.
750  bool hasPrologueData() const {
751  return getSubclassDataFromValue() & (1<<2);
752  }
753 
754  /// Get the prologue data associated with this function.
755  Constant *getPrologueData() const;
756  void setPrologueData(Constant *PrologueData);
757 
758  /// Print the function to an output stream with an optional
759  /// AssemblyAnnotationWriter.
760  void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr,
761  bool ShouldPreserveUseListOrder = false,
762  bool IsForDebug = false) const;
763 
764  /// viewCFG - This function is meant for use from the debugger. You can just
765  /// say 'call F->viewCFG()' and a ghostview window should pop up from the
766  /// program, displaying the CFG of the current function with the code for each
767  /// basic block inside. This depends on there being a 'dot' and 'gv' program
768  /// in your path.
769  ///
770  void viewCFG() const;
771 
772  /// viewCFGOnly - This function is meant for use from the debugger. It works
773  /// just like viewCFG, but it does not include the contents of basic blocks
774  /// into the nodes, just the label. If you are only interested in the CFG
775  /// this can make the graph smaller.
776  ///
777  void viewCFGOnly() const;
778 
779  /// Methods for support type inquiry through isa, cast, and dyn_cast:
780  static bool classof(const Value *V) {
781  return V->getValueID() == Value::FunctionVal;
782  }
783 
784  /// dropAllReferences() - This method causes all the subinstructions to "let
785  /// go" of all references that they are maintaining. This allows one to
786  /// 'delete' a whole module at a time, even though there may be circular
787  /// references... first all references are dropped, and all use counts go to
788  /// zero. Then everything is deleted for real. Note that no operations are
789  /// valid on an object that has "dropped all references", except operator
790  /// delete.
791  ///
792  /// Since no other object in the module can have references into the body of a
793  /// function, dropping all references deletes the entire body of the function,
794  /// including any contained basic blocks.
795  ///
796  void dropAllReferences();
797 
798  /// hasAddressTaken - returns true if there are any uses of this function
799  /// other than direct calls or invokes to it, or blockaddress expressions.
800  /// Optionally passes back an offending user for diagnostic purposes.
801  ///
802  bool hasAddressTaken(const User** = nullptr) const;
803 
804  /// isDefTriviallyDead - Return true if it is trivially safe to remove
805  /// this function definition from the module (because it isn't externally
806  /// visible, does not have its address taken, and has no callers). To make
807  /// this more accurate, call removeDeadConstantUsers first.
808  bool isDefTriviallyDead() const;
809 
810  /// callsFunctionThatReturnsTwice - Return true if the function has a call to
811  /// setjmp or other function that gcc recognizes as "returning twice".
812  bool callsFunctionThatReturnsTwice() const;
813 
814  /// Set the attached subprogram.
815  ///
816  /// Calls \a setMetadata() with \a LLVMContext::MD_dbg.
817  void setSubprogram(DISubprogram *SP);
818 
819  /// Get the attached subprogram.
820  ///
821  /// Calls \a getMetadata() with \a LLVMContext::MD_dbg and casts the result
822  /// to \a DISubprogram.
823  DISubprogram *getSubprogram() const;
824 
825  /// Returns true if we should emit debug info for profiling.
826  bool isDebugInfoForProfiling() const;
827 
828  /// Check if null pointer dereferencing is considered undefined behavior for
829  /// the function.
830  /// Return value: false => null pointer dereference is undefined.
831  /// Return value: true => null pointer dereference is not undefined.
832  bool nullPointerIsDefined() const;
833 
834 private:
835  void allocHungoffUselist();
836  template<int Idx> void setHungoffOperand(Constant *C);
837 
838  /// Shadow Value::setValueSubclassData with a private forwarding method so
839  /// that subclasses cannot accidentally use it.
840  void setValueSubclassData(unsigned short D) {
842  }
843  void setValueSubclassDataBit(unsigned Bit, bool On);
844 };
845 
846 /// Check whether null pointer dereferencing is considered undefined behavior
847 /// for a given function or an address space.
848 /// Null pointer access in non-zero address space is not considered undefined.
849 /// Return value: false => null pointer dereference is undefined.
850 /// Return value: true => null pointer dereference is not undefined.
851 bool NullPointerIsDefined(const Function *F, unsigned AS = 0);
852 
853 template <>
855 
857 
858 } // end namespace llvm
859 
860 #endif // LLVM_IR_FUNCTION_H
size_t size() const
Definition: Function.h:685
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:481
uint64_t CallInst * C
bool isIntrinsic() const
isIntrinsic - Returns true if the function&#39;s name starts with "llvm.".
Definition: Function.h:198
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:552
This class provides a symbol table of name/value pairs.
bool empty() const
Definition: Function.h:686
unsigned getFnStackAlignment() const
Return the stack alignment for the function.
Definition: Function.h:343
const_iterator begin() const
Definition: Function.h:681
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:560
uint64_t getParamDereferenceableBytes(unsigned ArgNo) const
Extract the number of dereferenceable bytes for a parameter.
Definition: Function.h:454
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool hasOptNone() const
Do not optimize this function (-O0).
Definition: Function.h:616
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
bool hasOptSize() const
Optimize this function for size (-Os) or minimum size (-Oz).
Definition: Function.h:622
iterator end()
Definition: Function.h:682
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:435
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:689
void setDoesNotRecurse()
Definition: Function.h:580
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:750
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:704
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:492
void setDoesNotThrow()
Definition: Function.h:536
bool hasStructRetAttr() const
Determine if the function returns a structure through first or second pointer argument.
Definition: Function.h:600
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:741
Type * getPointerElementType() const
Definition: Type.h:380
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:448
bool hasUWTable() const
True if the ABI mandates (or the user requested) that this function be in a unwind table...
Definition: Function.h:586
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:415
bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
check if an attributes is in the list of attributes.
Definition: Function.h:400
bool onlyAccessesInaccessibleMemory() const
Determine if the function may only access memory that is inaccessible from the IR.
Definition: Function.h:505
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:660
bool arg_empty() const
Definition: Function.h:729
bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const
check if an attributes is in the list of attributes.
Definition: Function.h:395
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:732
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
iterator begin()
Definition: Function.h:680
void setSpeculatable()
Definition: Function.h:563
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Extract the number of dereferenceable_or_null bytes for a parameter.
Definition: Function.h:468
void setIsMaterializable(bool V)
Definition: Function.h:181
void setOnlyAccessesArgMemory()
Definition: Function.h:501
bool doesNotAccessMemory() const
Determine if the function does not access memory.
Definition: Function.h:473
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:461
const BasicBlock & getEntryBlock() const
Definition: Function.h:664
bool cannotDuplicate() const
Determine if the call cannot be duplicated.
Definition: Function.h:541
unsigned getStackAlignment(unsigned Index) const
Get the stack alignment.
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:484
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:633
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:607
BasicBlock & getEntryBlock()
Definition: Function.h:665
bool doesNotFreeMemory() const
Determine if the call might deallocate memory.
Definition: Function.h:568
BasicBlock & front()
Definition: Function.h:688
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:690
bool doesNotReturn() const
Determine if the function cannot return.
Definition: Function.h:522
iterator_range< const_arg_iterator > args() const
Definition: Function.h:722
size_t arg_size() const
Definition: Function.h:728
Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
gets the specified attribute from the list of attributes.
Definition: Function.h:405
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
arg_iterator arg_begin()
Definition: Function.h:695
Argument * getArg(unsigned i) const
Definition: Function.h:713
void setHasUWTable()
Definition: Function.h:589
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:571
#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:544
void addFnAttr(Attribute Attr)
Add function attributes to this function.
Definition: Function.h:240
BasicBlockListType & getBasicBlockList()
Definition: Function.h:658
bool doesNotRecurse() const
Determine if the function is known not to recurse, directly or indirectly.
Definition: Function.h:577
bool doesNotThrow() const
Determine if the function cannot unwind.
Definition: Function.h:533
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:525
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:517
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static ProfileCount getInvalid()
Definition: Function.h:281
void setNotConvergent()
Definition: Function.h:555
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:508
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:672
bool needsUnwindTableEntry() const
True if this function needs an unwind table.
Definition: Function.h:594
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:780
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:708
could "use" a pointer
Function::ProfileCount ProfileCount
Definition: Function.cpp:56
unsigned getParamAlignment(unsigned ArgNo) const
Return the alignment for the specified function parameter.
Type * getParamByValType(unsigned ArgNo) const
Extract the byval type for a parameter.
Definition: Function.h:440
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.h:351
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:476
#define N
bool onlyAccessesArgMemory() const
Determine if the call can access memmory only using pointers based on its arguments.
Definition: Function.h:498
bool hasMinSize() const
Optimize this function for minimum size (-Oz).
Definition: Function.h:619
bool doesNotReadMemory() const
Determine if the function does not access or only writes memory.
Definition: Function.h:489
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:514
const_arg_iterator arg_begin() const
Definition: Function.h:699
const BasicBlockListType & getBasicBlockList() const
Get the underlying elements of the Function...
Definition: Function.h:657
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:673
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:687
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:410
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:530
const_iterator end() const
Definition: Function.h:683
bool isConvergent() const
Determine if the call is convergent.
Definition: Function.h:549
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:719
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:70
void setReturnDoesNotAlias()
Definition: Function.h:611