LLVM  14.0.0git
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 typedef unsigned ID;
47 }
48 
49 class AssemblyAnnotationWriter;
50 class Constant;
51 struct DenormalMode;
52 class DISubprogram;
53 class LLVMContext;
54 class Module;
55 template <typename T> class Optional;
56 class raw_ostream;
57 class Type;
58 class User;
59 class BranchProbabilityInfo;
60 class BlockFrequencyInfo;
61 
63  public ilist_node<Function> {
64 public:
66 
67  // BasicBlock iterators...
70 
72  using const_arg_iterator = const Argument *;
73 
74 private:
75  // Important things that make up a function!
76  BasicBlockListType BasicBlocks; ///< The basic blocks
77  mutable Argument *Arguments = nullptr; ///< The formal arguments
78  size_t NumArgs;
79  std::unique_ptr<ValueSymbolTable>
80  SymTab; ///< Symbol table of args/instructions
81  AttributeList AttributeSets; ///< Parameter attributes
82 
83  /*
84  * Value::SubclassData
85  *
86  * bit 0 : HasLazyArguments
87  * bit 1 : HasPrefixData
88  * bit 2 : HasPrologueData
89  * bit 3 : HasPersonalityFn
90  * bits 4-13 : CallingConvention
91  * bits 14 : HasGC
92  * bits 15 : [reserved]
93  */
94 
95  /// Bits from GlobalObject::GlobalObjectSubclassData.
96  enum {
97  /// Whether this function is materializable.
98  IsMaterializableBit = 0,
99  };
100 
102 
103  /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
104  /// built on demand, so that the list isn't allocated until the first client
105  /// needs it. The hasLazyArguments predicate returns true if the arg list
106  /// hasn't been set up yet.
107 public:
108  bool hasLazyArguments() const {
109  return getSubclassDataFromValue() & (1<<0);
110  }
111 
112 private:
113  void CheckLazyArguments() const {
114  if (hasLazyArguments())
115  BuildLazyArguments();
116  }
117 
118  void BuildLazyArguments() const;
119 
120  void clearArguments();
121 
122  /// Function ctor - If the (optional) Module argument is specified, the
123  /// function is automatically inserted into the end of the function list for
124  /// the module.
125  ///
126  Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
127  const Twine &N = "", Module *M = nullptr);
128 
129 public:
130  Function(const Function&) = delete;
131  void operator=(const Function&) = delete;
132  ~Function();
133 
134  // This is here to help easily convert from FunctionT * (Function * or
135  // MachineFunction *) in BlockFrequencyInfoImpl to Function * by calling
136  // FunctionT->getFunction().
137  const Function &getFunction() const { return *this; }
138 
140  unsigned AddrSpace, const Twine &N = "",
141  Module *M = nullptr) {
142  return new Function(Ty, Linkage, AddrSpace, N, M);
143  }
144 
145  // TODO: remove this once all users have been updated to pass an AddrSpace
147  const Twine &N = "", Module *M = nullptr) {
148  return new Function(Ty, Linkage, static_cast<unsigned>(-1), N, M);
149  }
150 
151  /// Creates a new function and attaches it to a module.
152  ///
153  /// Places the function in the program address space as specified
154  /// by the module's data layout.
155  static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
156  const Twine &N, Module &M);
157 
158  /// Creates a function with some attributes recorded in llvm.module.flags
159  /// applied.
160  ///
161  /// Use this when synthesizing new functions that need attributes that would
162  /// have been set by command line options.
163  static Function *createWithDefaultAttr(FunctionType *Ty, LinkageTypes Linkage,
164  unsigned AddrSpace,
165  const Twine &N = "",
166  Module *M = nullptr);
167 
168  // Provide fast operand accessors.
170 
171  /// Returns the number of non-debug IR instructions in this function.
172  /// This is equivalent to the sum of the sizes of each basic block contained
173  /// within this function.
174  unsigned getInstructionCount() const;
175 
176  /// Returns the FunctionType for me.
178  return cast<FunctionType>(getValueType());
179  }
180 
181  /// Returns the type of the ret val.
182  Type *getReturnType() const { return getFunctionType()->getReturnType(); }
183 
184  /// getContext - Return a reference to the LLVMContext associated with this
185  /// function.
186  LLVMContext &getContext() const;
187 
188  /// isVarArg - Return true if this function takes a variable number of
189  /// arguments.
190  bool isVarArg() const { return getFunctionType()->isVarArg(); }
191 
192  bool isMaterializable() const {
193  return getGlobalObjectSubClassData() & (1 << IsMaterializableBit);
194  }
195  void setIsMaterializable(bool V) {
196  unsigned Mask = 1 << IsMaterializableBit;
197  setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) |
198  (V ? Mask : 0u));
199  }
200 
201  /// getIntrinsicID - This method returns the ID number of the specified
202  /// function, or Intrinsic::not_intrinsic if the function is not an
203  /// intrinsic, or if the pointer is null. This value is always defined to be
204  /// zero to allow easy checking for whether a function is intrinsic or not.
205  /// The particular intrinsic functions which correspond to this value are
206  /// defined in llvm/Intrinsics.h.
208 
209  /// isIntrinsic - Returns true if the function's name starts with "llvm.".
210  /// It's possible for this function to return true while getIntrinsicID()
211  /// returns Intrinsic::not_intrinsic!
212  bool isIntrinsic() const { return HasLLVMReservedName; }
213 
214  /// isTargetIntrinsic - Returns true if IID is an intrinsic specific to a
215  /// certain target. If it is a generic intrinsic false is returned.
216  static bool isTargetIntrinsic(Intrinsic::ID IID);
217 
218  /// isTargetIntrinsic - Returns true if this function is an intrinsic and the
219  /// intrinsic is specific to a certain target. If this is not an intrinsic
220  /// or a generic intrinsic, false is returned.
221  bool isTargetIntrinsic() const;
222 
223  /// Returns true if the function is one of the "Constrained Floating-Point
224  /// Intrinsics". Returns false if not, and returns false when
225  /// getIntrinsicID() returns Intrinsic::not_intrinsic.
226  bool isConstrainedFPIntrinsic() const;
227 
228  static Intrinsic::ID lookupIntrinsicID(StringRef Name);
229 
230  /// Recalculate the ID for this function if it is an Intrinsic defined
231  /// in llvm/Intrinsics.h. Sets the intrinsic ID to Intrinsic::not_intrinsic
232  /// if the name of this function does not match an intrinsic in that header.
233  /// Note, this method does not need to be called directly, as it is called
234  /// from Value::setName() whenever the name of this function changes.
235  void recalculateIntrinsicID();
236 
237  /// getCallingConv()/setCallingConv(CC) - These method get and set the
238  /// calling convention of this function. The enum values for the known
239  /// calling conventions are defined in CallingConv.h.
241  return static_cast<CallingConv::ID>((getSubclassDataFromValue() >> 4) &
243  }
245  auto ID = static_cast<unsigned>(CC);
246  assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
247  setValueSubclassData((getSubclassDataFromValue() & 0xc00f) | (ID << 4));
248  }
249 
250  enum ProfileCountType { PCT_Real, PCT_Synthetic };
251 
252  /// Class to represent profile counts.
253  ///
254  /// This class represents both real and synthetic profile counts.
255  class ProfileCount {
256  private:
257  uint64_t Count = 0;
258  ProfileCountType PCT = PCT_Real;
259 
260  public:
262  : Count(Count), PCT(PCT) {}
263  uint64_t getCount() const { return Count; }
264  ProfileCountType getType() const { return PCT; }
265  bool isSynthetic() const { return PCT == PCT_Synthetic; }
266  };
267 
268  /// Set the entry count for this function.
269  ///
270  /// Entry count is the number of times this function was executed based on
271  /// pgo data. \p Imports points to a set of GUIDs that needs to
272  /// be imported by the function for sample PGO, to enable the same inlines as
273  /// the profiled optimized binary.
274  void setEntryCount(ProfileCount Count,
275  const DenseSet<GlobalValue::GUID> *Imports = nullptr);
276 
277  /// A convenience wrapper for setting entry count
278  void setEntryCount(uint64_t Count, ProfileCountType Type = PCT_Real,
279  const DenseSet<GlobalValue::GUID> *Imports = nullptr);
280 
281  /// Get the entry count for this function.
282  ///
283  /// Entry count is the number of times the function was executed.
284  /// When AllowSynthetic is false, only pgo_data will be returned.
285  Optional<ProfileCount> getEntryCount(bool AllowSynthetic = false) const;
286 
287  /// Return true if the function is annotated with profile data.
288  ///
289  /// Presence of entry counts from a profile run implies the function has
290  /// profile annotations. If IncludeSynthetic is false, only return true
291  /// when the profile data is real.
292  bool hasProfileData(bool IncludeSynthetic = false) const {
293  return getEntryCount(IncludeSynthetic).hasValue();
294  }
295 
296  /// Returns the set of GUIDs that needs to be imported to the function for
297  /// sample PGO, to enable the same inlines as the profiled optimized binary.
298  DenseSet<GlobalValue::GUID> getImportGUIDs() const;
299 
300  /// Set the section prefix for this function.
301  void setSectionPrefix(StringRef Prefix);
302 
303  /// Get the section prefix for this function.
304  Optional<StringRef> getSectionPrefix() const;
305 
306  /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
307  /// to use during code generation.
308  bool hasGC() const {
309  return getSubclassDataFromValue() & (1<<14);
310  }
311  const std::string &getGC() const;
312  void setGC(std::string Str);
313  void clearGC();
314 
315  /// Return the attribute list for this Function.
316  AttributeList getAttributes() const { return AttributeSets; }
317 
318  /// Set the attribute list for this Function.
319  void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; }
320 
321  // TODO: remove non-AtIndex versions of these methods.
322  /// adds the attribute to the list of attributes.
323  void addAttributeAtIndex(unsigned i, Attribute Attr);
324 
325  /// Add function attributes to this function.
326  void addFnAttr(Attribute::AttrKind Kind);
327 
328  /// Add function attributes to this function.
329  void addFnAttr(StringRef Kind, StringRef Val = StringRef());
330 
331  /// Add function attributes to this function.
332  void addFnAttr(Attribute Attr);
333 
334  /// Add function attributes to this function.
335  void addFnAttrs(const AttrBuilder &Attrs);
336 
337  /// Add return value attributes to this function.
338  void addRetAttr(Attribute::AttrKind Kind);
339 
340  /// Add return value attributes to this function.
341  void addRetAttr(Attribute Attr);
342 
343  /// Add return value attributes to this function.
344  void addRetAttrs(const AttrBuilder &Attrs);
345 
346  /// adds the attribute to the list of attributes for the given arg.
347  void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
348 
349  /// adds the attribute to the list of attributes for the given arg.
350  void addParamAttr(unsigned ArgNo, Attribute Attr);
351 
352  /// adds the attributes to the list of attributes for the given arg.
353  void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);
354 
355  /// removes the attribute from the list of attributes.
356  void removeAttributeAtIndex(unsigned i, Attribute::AttrKind Kind);
357 
358  /// removes the attribute from the list of attributes.
359  void removeAttributeAtIndex(unsigned i, StringRef Kind);
360 
361  /// Remove function attributes from this function.
362  void removeFnAttr(Attribute::AttrKind Kind);
363 
364  /// Remove function attribute from this function.
365  void removeFnAttr(StringRef Kind);
366 
367  void removeFnAttrs(const AttributeMask &Attrs);
368 
369  /// removes the attribute from the return value list of attributes.
370  void removeRetAttr(Attribute::AttrKind Kind);
371 
372  /// removes the attribute from the return value list of attributes.
373  void removeRetAttr(StringRef Kind);
374 
375  /// removes the attributes from the return value list of attributes.
376  void removeRetAttrs(const AttributeMask &Attrs);
377 
378  /// removes the attribute from the list of attributes.
379  void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
380 
381  /// removes the attribute from the list of attributes.
382  void removeParamAttr(unsigned ArgNo, StringRef Kind);
383 
384  /// removes the attribute from the list of attributes.
385  void removeParamAttrs(unsigned ArgNo, const AttributeMask &Attrs);
386 
387  /// Return true if the function has the attribute.
388  bool hasFnAttribute(Attribute::AttrKind Kind) const;
389 
390  /// Return true if the function has the attribute.
391  bool hasFnAttribute(StringRef Kind) const;
392 
393  /// check if an attribute is in the list of attributes for the return value.
394  bool hasRetAttribute(Attribute::AttrKind Kind) const;
395 
396  /// check if an attributes is in the list of attributes.
397  bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const;
398 
399  /// gets the attribute from the list of attributes.
400  Attribute getAttributeAtIndex(unsigned i, Attribute::AttrKind Kind) const;
401 
402  /// gets the attribute from the list of attributes.
403  Attribute getAttributeAtIndex(unsigned i, StringRef Kind) const;
404 
405  /// Return the attribute for the given attribute kind.
406  Attribute getFnAttribute(Attribute::AttrKind Kind) const;
407 
408  /// Return the attribute for the given attribute kind.
409  Attribute getFnAttribute(StringRef Kind) const;
410 
411  /// gets the specified attribute from the list of attributes.
412  Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const;
413 
414  /// removes noundef and other attributes that imply undefined behavior if a
415  /// `undef` or `poison` value is passed from the list of attributes.
416  void removeParamUndefImplyingAttrs(unsigned ArgNo);
417 
418  /// Return the stack alignment for the function.
420  return AttributeSets.getFnStackAlignment();
421  }
422 
423  /// Returns true if the function has ssp, sspstrong, or sspreq fn attrs.
424  bool hasStackProtectorFnAttr() const;
425 
426  /// adds the dereferenceable attribute to the list of attributes for
427  /// the given arg.
428  void addDereferenceableParamAttr(unsigned ArgNo, 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  /// FIXME: Remove this function once transition to Align is over.
436  /// Use getParamAlign() instead.
437  uint64_t getParamAlignment(unsigned ArgNo) const {
438  if (const auto MA = getParamAlign(ArgNo))
439  return MA->value();
440  return 0;
441  }
442 
443  MaybeAlign getParamAlign(unsigned ArgNo) const {
444  return AttributeSets.getParamAlignment(ArgNo);
445  }
446 
447  MaybeAlign getParamStackAlign(unsigned ArgNo) const {
448  return AttributeSets.getParamStackAlignment(ArgNo);
449  }
450 
451  /// Extract the byval type for a parameter.
452  Type *getParamByValType(unsigned ArgNo) const {
453  return AttributeSets.getParamByValType(ArgNo);
454  }
455 
456  /// Extract the sret type for a parameter.
457  Type *getParamStructRetType(unsigned ArgNo) const {
458  return AttributeSets.getParamStructRetType(ArgNo);
459  }
460 
461  /// Extract the inalloca type for a parameter.
462  Type *getParamInAllocaType(unsigned ArgNo) const {
463  return AttributeSets.getParamInAllocaType(ArgNo);
464  }
465 
466  /// Extract the byref type for a parameter.
467  Type *getParamByRefType(unsigned ArgNo) const {
468  return AttributeSets.getParamByRefType(ArgNo);
469  }
470 
471  /// Extract the preallocated type for a parameter.
472  Type *getParamPreallocatedType(unsigned ArgNo) const {
473  return AttributeSets.getParamPreallocatedType(ArgNo);
474  }
475 
476  /// Extract the number of dereferenceable bytes for a parameter.
477  /// @param ArgNo Index of an argument, with 0 being the first function arg.
478  uint64_t getParamDereferenceableBytes(unsigned ArgNo) const {
479  return AttributeSets.getParamDereferenceableBytes(ArgNo);
480  }
481 
482  /// Extract the number of dereferenceable_or_null bytes for a
483  /// parameter.
484  /// @param ArgNo AttributeList ArgNo, referring to an argument.
486  return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo);
487  }
488 
489  /// A function will have the "coroutine.presplit" attribute if it's
490  /// a coroutine and has not gone through full CoroSplit pass.
491  bool isPresplitCoroutine() const {
492  return hasFnAttribute("coroutine.presplit");
493  }
494 
495  /// Determine if the function does not access memory.
496  bool doesNotAccessMemory() const {
497  return hasFnAttribute(Attribute::ReadNone);
498  }
500  addFnAttr(Attribute::ReadNone);
501  }
502 
503  /// Determine if the function does not access or only reads memory.
504  bool onlyReadsMemory() const {
505  return doesNotAccessMemory() || hasFnAttribute(Attribute::ReadOnly);
506  }
508  addFnAttr(Attribute::ReadOnly);
509  }
510 
511  /// Determine if the function does not access or only writes memory.
512  bool onlyWritesMemory() const {
513  return doesNotAccessMemory() || hasFnAttribute(Attribute::WriteOnly);
514  }
516  addFnAttr(Attribute::WriteOnly);
517  }
518 
519  /// Determine if the call can access memmory only using pointers based
520  /// on its arguments.
521  bool onlyAccessesArgMemory() const {
522  return hasFnAttribute(Attribute::ArgMemOnly);
523  }
524  void setOnlyAccessesArgMemory() { addFnAttr(Attribute::ArgMemOnly); }
525 
526  /// Determine if the function may only access memory that is
527  /// inaccessible from the IR.
529  return hasFnAttribute(Attribute::InaccessibleMemOnly);
530  }
532  addFnAttr(Attribute::InaccessibleMemOnly);
533  }
534 
535  /// Determine if the function may only access memory that is
536  /// either inaccessible from the IR or pointed to by its arguments.
538  return hasFnAttribute(Attribute::InaccessibleMemOrArgMemOnly);
539  }
541  addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
542  }
543 
544  /// Determine if the function cannot return.
545  bool doesNotReturn() const {
546  return hasFnAttribute(Attribute::NoReturn);
547  }
549  addFnAttr(Attribute::NoReturn);
550  }
551 
552  /// Determine if the function should not perform indirect branch tracking.
553  bool doesNoCfCheck() const { return hasFnAttribute(Attribute::NoCfCheck); }
554 
555  /// Determine if the function cannot unwind.
556  bool doesNotThrow() const {
557  return hasFnAttribute(Attribute::NoUnwind);
558  }
560  addFnAttr(Attribute::NoUnwind);
561  }
562 
563  /// Determine if the call cannot be duplicated.
564  bool cannotDuplicate() const {
565  return hasFnAttribute(Attribute::NoDuplicate);
566  }
568  addFnAttr(Attribute::NoDuplicate);
569  }
570 
571  /// Determine if the call is convergent.
572  bool isConvergent() const {
573  return hasFnAttribute(Attribute::Convergent);
574  }
575  void setConvergent() {
576  addFnAttr(Attribute::Convergent);
577  }
579  removeFnAttr(Attribute::Convergent);
580  }
581 
582  /// Determine if the call has sideeffects.
583  bool isSpeculatable() const {
584  return hasFnAttribute(Attribute::Speculatable);
585  }
587  addFnAttr(Attribute::Speculatable);
588  }
589 
590  /// Determine if the call might deallocate memory.
591  bool doesNotFreeMemory() const {
592  return onlyReadsMemory() || hasFnAttribute(Attribute::NoFree);
593  }
595  addFnAttr(Attribute::NoFree);
596  }
597 
598  /// Determine if the call can synchroize with other threads
599  bool hasNoSync() const {
600  return hasFnAttribute(Attribute::NoSync);
601  }
602  void setNoSync() {
603  addFnAttr(Attribute::NoSync);
604  }
605 
606  /// Determine if the function is known not to recurse, directly or
607  /// indirectly.
608  bool doesNotRecurse() const {
609  return hasFnAttribute(Attribute::NoRecurse);
610  }
612  addFnAttr(Attribute::NoRecurse);
613  }
614 
615  /// Determine if the function is required to make forward progress.
616  bool mustProgress() const {
617  return hasFnAttribute(Attribute::MustProgress) ||
618  hasFnAttribute(Attribute::WillReturn);
619  }
620  void setMustProgress() { addFnAttr(Attribute::MustProgress); }
621 
622  /// Determine if the function will return.
623  bool willReturn() const { return hasFnAttribute(Attribute::WillReturn); }
624  void setWillReturn() { addFnAttr(Attribute::WillReturn); }
625 
626  /// True if the ABI mandates (or the user requested) that this
627  /// function be in a unwind table.
628  bool hasUWTable() const {
629  return hasFnAttribute(Attribute::UWTable);
630  }
631  void setHasUWTable() {
632  addFnAttr(Attribute::UWTable);
633  }
634 
635  /// True if this function needs an unwind table.
636  bool needsUnwindTableEntry() const {
637  return hasUWTable() || !doesNotThrow() || hasPersonalityFn();
638  }
639 
640  /// Determine if the function returns a structure through first
641  /// or second pointer argument.
642  bool hasStructRetAttr() const {
643  return AttributeSets.hasParamAttr(0, Attribute::StructRet) ||
644  AttributeSets.hasParamAttr(1, Attribute::StructRet);
645  }
646 
647  /// Determine if the parameter or return value is marked with NoAlias
648  /// attribute.
649  bool returnDoesNotAlias() const {
650  return AttributeSets.hasRetAttr(Attribute::NoAlias);
651  }
652  void setReturnDoesNotAlias() { addRetAttr(Attribute::NoAlias); }
653 
654  /// Do not optimize this function (-O0).
655  bool hasOptNone() const { return hasFnAttribute(Attribute::OptimizeNone); }
656 
657  /// Optimize this function for minimum size (-Oz).
658  bool hasMinSize() const { return hasFnAttribute(Attribute::MinSize); }
659 
660  /// Optimize this function for size (-Os) or minimum size (-Oz).
661  bool hasOptSize() const {
662  return hasFnAttribute(Attribute::OptimizeForSize) || hasMinSize();
663  }
664 
665  /// Returns the denormal handling type for the default rounding mode of the
666  /// function.
667  DenormalMode getDenormalMode(const fltSemantics &FPType) const;
668 
669  /// copyAttributesFrom - copy all additional attributes (those not needed to
670  /// create a Function) from the Function Src to this one.
671  void copyAttributesFrom(const Function *Src);
672 
673  /// deleteBody - This method deletes the body of the function, and converts
674  /// the linkage to external.
675  ///
676  void deleteBody() {
677  dropAllReferences();
678  setLinkage(ExternalLinkage);
679  }
680 
681  /// removeFromParent - This method unlinks 'this' from the containing module,
682  /// but does not delete it.
683  ///
684  void removeFromParent();
685 
686  /// eraseFromParent - This method unlinks 'this' from the containing module
687  /// and deletes it.
688  ///
689  void eraseFromParent();
690 
691  /// Steal arguments from another function.
692  ///
693  /// Drop this function's arguments and splice in the ones from \c Src.
694  /// Requires that this has no function body.
695  void stealArgumentListFrom(Function &Src);
696 
697  /// Get the underlying elements of the Function... the basic block list is
698  /// empty for external functions.
699  ///
700  const BasicBlockListType &getBasicBlockList() const { return BasicBlocks; }
701  BasicBlockListType &getBasicBlockList() { return BasicBlocks; }
702 
704  return &Function::BasicBlocks;
705  }
706 
707  const BasicBlock &getEntryBlock() const { return front(); }
708  BasicBlock &getEntryBlock() { return front(); }
709 
710  //===--------------------------------------------------------------------===//
711  // Symbol Table Accessing functions...
712 
713  /// getSymbolTable() - Return the symbol table if any, otherwise nullptr.
714  ///
715  inline ValueSymbolTable *getValueSymbolTable() { return SymTab.get(); }
716  inline const ValueSymbolTable *getValueSymbolTable() const {
717  return SymTab.get();
718  }
719 
720  //===--------------------------------------------------------------------===//
721  // BasicBlock iterator forwarding functions
722  //
723  iterator begin() { return BasicBlocks.begin(); }
724  const_iterator begin() const { return BasicBlocks.begin(); }
725  iterator end () { return BasicBlocks.end(); }
726  const_iterator end () const { return BasicBlocks.end(); }
727 
728  size_t size() const { return BasicBlocks.size(); }
729  bool empty() const { return BasicBlocks.empty(); }
730  const BasicBlock &front() const { return BasicBlocks.front(); }
731  BasicBlock &front() { return BasicBlocks.front(); }
732  const BasicBlock &back() const { return BasicBlocks.back(); }
733  BasicBlock &back() { return BasicBlocks.back(); }
734 
735 /// @name Function Argument Iteration
736 /// @{
737 
739  CheckLazyArguments();
740  return Arguments;
741  }
743  CheckLazyArguments();
744  return Arguments;
745  }
746 
748  CheckLazyArguments();
749  return Arguments + NumArgs;
750  }
752  CheckLazyArguments();
753  return Arguments + NumArgs;
754  }
755 
756  Argument* getArg(unsigned i) const {
757  assert (i < NumArgs && "getArg() out of range!");
758  CheckLazyArguments();
759  return Arguments + i;
760  }
761 
763  return make_range(arg_begin(), arg_end());
764  }
766  return make_range(arg_begin(), arg_end());
767  }
768 
769 /// @}
770 
771  size_t arg_size() const { return NumArgs; }
772  bool arg_empty() const { return arg_size() == 0; }
773 
774  /// Check whether this function has a personality function.
775  bool hasPersonalityFn() const {
776  return getSubclassDataFromValue() & (1<<3);
777  }
778 
779  /// Get the personality function associated with this function.
780  Constant *getPersonalityFn() const;
781  void setPersonalityFn(Constant *Fn);
782 
783  /// Check whether this function has prefix data.
784  bool hasPrefixData() const {
785  return getSubclassDataFromValue() & (1<<1);
786  }
787 
788  /// Get the prefix data associated with this function.
789  Constant *getPrefixData() const;
790  void setPrefixData(Constant *PrefixData);
791 
792  /// Check whether this function has prologue data.
793  bool hasPrologueData() const {
794  return getSubclassDataFromValue() & (1<<2);
795  }
796 
797  /// Get the prologue data associated with this function.
798  Constant *getPrologueData() const;
799  void setPrologueData(Constant *PrologueData);
800 
801  /// Print the function to an output stream with an optional
802  /// AssemblyAnnotationWriter.
803  void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr,
804  bool ShouldPreserveUseListOrder = false,
805  bool IsForDebug = false) const;
806 
807  /// viewCFG - This function is meant for use from the debugger. You can just
808  /// say 'call F->viewCFG()' and a ghostview window should pop up from the
809  /// program, displaying the CFG of the current function with the code for each
810  /// basic block inside. This depends on there being a 'dot' and 'gv' program
811  /// in your path.
812  ///
813  void viewCFG() const;
814 
815  /// Extended form to print edge weights.
816  void viewCFG(bool ViewCFGOnly, const BlockFrequencyInfo *BFI,
817  const BranchProbabilityInfo *BPI) const;
818 
819  /// viewCFGOnly - This function is meant for use from the debugger. It works
820  /// just like viewCFG, but it does not include the contents of basic blocks
821  /// into the nodes, just the label. If you are only interested in the CFG
822  /// this can make the graph smaller.
823  ///
824  void viewCFGOnly() const;
825 
826  /// Extended form to print edge weights.
827  void viewCFGOnly(const BlockFrequencyInfo *BFI,
828  const BranchProbabilityInfo *BPI) const;
829 
830  /// Methods for support type inquiry through isa, cast, and dyn_cast:
831  static bool classof(const Value *V) {
832  return V->getValueID() == Value::FunctionVal;
833  }
834 
835  /// dropAllReferences() - This method causes all the subinstructions to "let
836  /// go" of all references that they are maintaining. This allows one to
837  /// 'delete' a whole module at a time, even though there may be circular
838  /// references... first all references are dropped, and all use counts go to
839  /// zero. Then everything is deleted for real. Note that no operations are
840  /// valid on an object that has "dropped all references", except operator
841  /// delete.
842  ///
843  /// Since no other object in the module can have references into the body of a
844  /// function, dropping all references deletes the entire body of the function,
845  /// including any contained basic blocks.
846  ///
847  void dropAllReferences();
848 
849  /// hasAddressTaken - returns true if there are any uses of this function
850  /// other than direct calls or invokes to it, or blockaddress expressions.
851  /// Optionally passes back an offending user for diagnostic purposes,
852  /// ignores callback uses, assume like pointer annotation calls, references in
853  /// llvm.used and llvm.compiler.used variables, and operand bundle
854  /// "clang.arc.attachedcall".
855  bool hasAddressTaken(const User ** = nullptr,
856  bool IgnoreCallbackUses = false,
857  bool IgnoreAssumeLikeCalls = true,
858  bool IngoreLLVMUsed = false,
859  bool IgnoreARCAttachedCall = false) const;
860 
861  /// isDefTriviallyDead - Return true if it is trivially safe to remove
862  /// this function definition from the module (because it isn't externally
863  /// visible, does not have its address taken, and has no callers). To make
864  /// this more accurate, call removeDeadConstantUsers first.
865  bool isDefTriviallyDead() const;
866 
867  /// callsFunctionThatReturnsTwice - Return true if the function has a call to
868  /// setjmp or other function that gcc recognizes as "returning twice".
869  bool callsFunctionThatReturnsTwice() const;
870 
871  /// Set the attached subprogram.
872  ///
873  /// Calls \a setMetadata() with \a LLVMContext::MD_dbg.
874  void setSubprogram(DISubprogram *SP);
875 
876  /// Get the attached subprogram.
877  ///
878  /// Calls \a getMetadata() with \a LLVMContext::MD_dbg and casts the result
879  /// to \a DISubprogram.
880  DISubprogram *getSubprogram() const;
881 
882  /// Returns true if we should emit debug info for profiling.
883  bool isDebugInfoForProfiling() const;
884 
885  /// Check if null pointer dereferencing is considered undefined behavior for
886  /// the function.
887  /// Return value: false => null pointer dereference is undefined.
888  /// Return value: true => null pointer dereference is not undefined.
889  bool nullPointerIsDefined() const;
890 
891 private:
892  void allocHungoffUselist();
893  template<int Idx> void setHungoffOperand(Constant *C);
894 
895  /// Shadow Value::setValueSubclassData with a private forwarding method so
896  /// that subclasses cannot accidentally use it.
897  void setValueSubclassData(unsigned short D) {
899  }
900  void setValueSubclassDataBit(unsigned Bit, bool On);
901 };
902 
903 /// Check whether null pointer dereferencing is considered undefined behavior
904 /// for a given function or an address space.
905 /// Null pointer access in non-zero address space is not considered undefined.
906 /// Return value: false => null pointer dereference is undefined.
907 /// Return value: true => null pointer dereference is not undefined.
908 bool NullPointerIsDefined(const Function *F, unsigned AS = 0);
909 
910 template <>
912 
914 
915 } // end namespace llvm
916 
917 #endif // LLVM_IR_FUNCTION_H
i
i
Definition: README.txt:29
llvm::AttributeList::getParamInAllocaType
Type * getParamInAllocaType(unsigned ArgNo) const
Return the inalloca type for the specified function parameter.
Definition: Attributes.cpp:1420
llvm::Function::getBasicBlockList
BasicBlockListType & getBasicBlockList()
Definition: Function.h:701
llvm::objcarc::ARCInstKind::User
@ User
could "use" a pointer
llvm::Argument
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
llvm::Function::Create
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:146
llvm::Function::setOnlyAccessesInaccessibleMemOrArgMem
void setOnlyAccessesInaccessibleMemOrArgMem()
Definition: Function.h:540
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::Function::isIntrinsic
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
Definition: Function.h:212
llvm::Function::setNoSync
void setNoSync()
Definition: Function.h:602
llvm::Function::arg_empty
bool arg_empty() const
Definition: Function.h:772
LLVM_READONLY
#define LLVM_READONLY
Definition: Compiler.h:216
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
llvm::Function::args
iterator_range< arg_iterator > args()
Definition: Function.h:762
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
print
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
Definition: ArchiveWriter.cpp:148
llvm::Function::end
iterator end()
Definition: Function.h:725
llvm::Function::onlyWritesMemory
bool onlyWritesMemory() const
Determine if the function does not access or only writes memory.
Definition: Function.h:512
FunctionType
Definition: ItaniumDemangle.h:779
llvm::Function::hasOptNone
bool hasOptNone() const
Do not optimize this function (-O0).
Definition: Function.h:655
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
llvm::Function::empty
bool empty() const
Definition: Function.h:729
llvm::Function::getBasicBlockList
const BasicBlockListType & getBasicBlockList() const
Get the underlying elements of the Function...
Definition: Function.h:700
llvm::Function::doesNoCfCheck
bool doesNoCfCheck() const
Determine if the function should not perform indirect branch tracking.
Definition: Function.h:553
llvm::Function
Definition: Function.h:62
llvm::Attribute
Definition: Attributes.h:52
StringRef.h
llvm::Function::getParamDereferenceableBytes
uint64_t getParamDereferenceableBytes(unsigned ArgNo) const
Extract the number of dereferenceable bytes for a parameter.
Definition: Function.h:478
llvm::AttributeList::getParamPreallocatedType
Type * getParamPreallocatedType(unsigned ArgNo) const
Return the preallocated type for the specified function parameter.
Definition: Attributes.cpp:1416
llvm::Function::getFnStackAlign
MaybeAlign getFnStackAlign() const
Return the stack alignment for the function.
Definition: Function.h:419
llvm::Function::getParamByValType
Type * getParamByValType(unsigned ArgNo) const
Extract the byval type for a parameter.
Definition: Function.h:452
llvm::Function::begin
const_iterator begin() const
Definition: Function.h:724
viewCFG
static void viewCFG(Function &F, const BlockFrequencyInfo *BFI, const BranchProbabilityInfo *BPI, uint64_t MaxFreq, bool CFGOnly=false)
Definition: CFGPrinter.cpp:84
llvm::Function::getEntryBlock
const BasicBlock & getEntryBlock() const
Definition: Function.h:707
llvm::AttributeList::getParamByValType
Type * getParamByValType(unsigned ArgNo) const
Return the byval type for the specified function parameter.
Definition: Attributes.cpp:1404
llvm::Function::setDoesNotThrow
void setDoesNotThrow()
Definition: Function.h:559
llvm::Function::setWillReturn
void setWillReturn()
Definition: Function.h:624
llvm::Function::arg_size
size_t arg_size() const
Definition: Function.h:771
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::AttributeList
Definition: Attributes.h:403
llvm::AttributeMask
Definition: Attributes.h:936
DEFINE_TRANSPARENT_OPERAND_ACCESSORS
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
Definition: OperandTraits.h:125
llvm::Function::front
BasicBlock & front()
Definition: Function.h:731
llvm::Optional
Definition: APInt.h:33
GlobalObject.h
llvm::Function::setCannotDuplicate
void setCannotDuplicate()
Definition: Function.h:567
llvm::MCID::Convergent
@ Convergent
Definition: MCInstrDesc.h:182
llvm::Function::ProfileCount::isSynthetic
bool isSynthetic() const
Definition: Function.h:265
llvm::GlobalValue::LinkageTypes
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:47
llvm::Value::setValueSubclassData
void setValueSubclassData(unsigned short D)
Definition: Value.h:853
llvm::BitmaskEnumDetail::Mask
std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::AttributeList::getParamDereferenceableBytes
uint64_t getParamDereferenceableBytes(unsigned Index) const
Get the number of dereferenceable bytes (or zero if unknown) of an arg.
Definition: Attributes.cpp:1440
llvm::Function::setOnlyAccessesArgMemory
void setOnlyAccessesArgMemory()
Definition: Function.h:524
llvm::AttributeList::getParamStackAlignment
MaybeAlign getParamStackAlignment(unsigned ArgNo) const
Return the stack alignment for the specified function parameter.
Definition: Attributes.cpp:1400
llvm::Function::setConvergent
void setConvergent()
Definition: Function.h:575
llvm::Function::hasUWTable
bool hasUWTable() const
True if the ABI mandates (or the user requested) that this function be in a unwind table.
Definition: Function.h:628
llvm::BlockFrequencyInfo
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Definition: BlockFrequencyInfo.h:37
llvm::Function::getSublistAccess
static BasicBlockListType Function::* getSublistAccess(BasicBlock *)
Definition: Function.h:703
GlobalValue.h
llvm::OperandTraits
Compile-time customization of User operands.
Definition: User.h:42
llvm::Function::end
const_iterator end() const
Definition: Function.h:726
llvm::ISD::Constant
@ Constant
Definition: ISDOpcodes.h:76
llvm::Function::getEntryBlock
BasicBlock & getEntryBlock()
Definition: Function.h:708
llvm::User
Definition: User.h:44
llvm::Function::onlyAccessesInaccessibleMemory
bool onlyAccessesInaccessibleMemory() const
Determine if the function may only access memory that is inaccessible from the IR.
Definition: Function.h:528
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::AttributeList::getParamDereferenceableOrNullBytes
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Get the number of dereferenceable_or_null bytes (or zero if unknown) of an arg.
Definition: Attributes.cpp:1449
Twine.h
llvm::GlobalObject
Definition: GlobalObject.h:27
llvm::BranchProbabilityInfo
Analysis providing branch probability information.
Definition: BranchProbabilityInfo.h:115
llvm::Function::setSpeculatable
void setSpeculatable()
Definition: Function.h:586
llvm::CallingConv::MaxID
@ MaxID
The highest possible calling convention ID. Must be some 2^k - 1.
Definition: CallingConv.h:256
llvm::Function::back
BasicBlock & back()
Definition: Function.h:733
DenseSet.h
llvm::Function::cannotDuplicate
bool cannotDuplicate() const
Determine if the call cannot be duplicated.
Definition: Function.h:564
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:109
llvm::Function::arg_end
arg_iterator arg_end()
Definition: Function.h:747
llvm::Value::getValueID
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:532
llvm::Function::ProfileCount::ProfileCount
ProfileCount(uint64_t Count, ProfileCountType PCT)
Definition: Function.h:261
llvm::Function::setDoesNotRecurse
void setDoesNotRecurse()
Definition: Function.h:611
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::Function::hasPersonalityFn
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:775
OperandTraits.h
llvm::Function::isSpeculatable
bool isSpeculatable() const
Determine if the call has sideeffects.
Definition: Function.h:583
llvm::Function::isMaterializable
bool isMaterializable() const
Definition: Function.h:192
llvm::Function::doesNotAccessMemory
bool doesNotAccessMemory() const
Determine if the function does not access memory.
Definition: Function.h:496
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::Function::getParamInAllocaType
Type * getParamInAllocaType(unsigned ArgNo) const
Extract the inalloca type for a parameter.
Definition: Function.h:462
llvm::Function::getValueSymbolTable
const ValueSymbolTable * getValueSymbolTable() const
Definition: Function.h:716
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::codeview::ClassOptions::Intrinsic
@ Intrinsic
llvm::Function::hasPrologueData
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:793
llvm::Function::getAttributes
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:316
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
BasicBlock.h
llvm::Function::setDoesNotFreeMemory
void setDoesNotFreeMemory()
Definition: Function.h:594
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::Function::getReturnType
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.h:182
llvm::Function::willReturn
bool willReturn() const
Determine if the function will return.
Definition: Function.h:623
llvm::SymbolTableListTraits
Definition: GlobalAlias.h:26
uint64_t
llvm::Function::hasPrefixData
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:784
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::Function::getCallingConv
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:240
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
LLVM_EXTERNAL_VISIBILITY
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:136
llvm::Function::hasGC
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.h:308
llvm::Function::setDoesNotAccessMemory
void setDoesNotAccessMemory()
Definition: Function.h:499
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
llvm::AttrBuilder
Definition: Attributes.h:997
llvm::Function::args
iterator_range< const_arg_iterator > args() const
Definition: Function.h:765
llvm::DenormalMode
Represent subnormal handling kind for floating point instruction inputs and outputs.
Definition: FloatingPointMode.h:67
llvm::Attribute::AttrKind
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
Definition: Attributes.h:71
llvm::Function::setMustProgress
void setMustProgress()
Definition: Function.h:620
llvm::Function::getParamPreallocatedType
Type * getParamPreallocatedType(unsigned ArgNo) const
Extract the preallocated type for a parameter.
Definition: Function.h:472
llvm::AttributeList::getParamAlignment
MaybeAlign getParamAlignment(unsigned ArgNo) const
Return the alignment for the specified function parameter.
Definition: Attributes.cpp:1396
llvm::Function::hasStructRetAttr
bool hasStructRetAttr() const
Determine if the function returns a structure through first or second pointer argument.
Definition: Function.h:642
getSubprogram
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&...Args)
Definition: DIBuilder.cpp:825
TemplateParamKind::Type
@ Type
llvm::Function::onlyAccessesInaccessibleMemOrArgMem
bool onlyAccessesInaccessibleMemOrArgMem() const
Determine if the function may only access memory that is either inaccessible from the IR or pointed t...
Definition: Function.h:537
llvm::Function::Create
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:139
llvm::Function::ProfileCountType
ProfileCountType
Definition: Function.h:250
llvm::SmallVectorImpl::const_iterator
typename SuperClass::const_iterator const_iterator
Definition: SmallVector.h:559
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
iterator_range.h
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::Function::doesNotRecurse
bool doesNotRecurse() const
Determine if the function is known not to recurse, directly or indirectly.
Definition: Function.h:608
llvm::Function::getFunction
const Function & getFunction() const
Definition: Function.h:137
llvm::Function::classof
static bool classof(const Value *V)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: Function.h:831
llvm::Function::getIntrinsicID
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:207
llvm::Function::isConvergent
bool isConvergent() const
Determine if the call is convergent.
Definition: Function.h:572
llvm::SymbolTableList< BasicBlock >
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::Function::setCallingConv
void setCallingConv(CallingConv::ID CC)
Definition: Function.h:244
Compiler.h
llvm::AttributeList::getParamByRefType
Type * getParamByRefType(unsigned ArgNo) const
Return the byref type for the specified function parameter.
Definition: Attributes.cpp:1412
llvm::Function::getParamAlign
MaybeAlign getParamAlign(unsigned ArgNo) const
Definition: Function.h:443
llvm::Function::ProfileCount::getType
ProfileCountType getType() const
Definition: Function.h:264
Module
Machine Check Debug Module
Definition: MachineCheckDebugify.cpp:122
llvm::AMDGPUISD::BFI
@ BFI
Definition: AMDGPUISelLowering.h:431
llvm::Function::setOnlyReadsMemory
void setOnlyReadsMemory()
Definition: Function.h:507
llvm::Function::setIsMaterializable
void setIsMaterializable(bool V)
Definition: Function.h:195
llvm::Function::begin
iterator begin()
Definition: Function.h:723
llvm::Function::doesNotFreeMemory
bool doesNotFreeMemory() const
Determine if the call might deallocate memory.
Definition: Function.h:591
llvm::ilist_node
Definition: ilist_node.h:148
llvm::Function::hasOptSize
bool hasOptSize() const
Optimize this function for size (-Os) or minimum size (-Oz).
Definition: Function.h:661
llvm::Function::ProfileCount::getCount
uint64_t getCount() const
Definition: Function.h:263
llvm::cl::Optional
@ Optional
Definition: CommandLine.h:119
Argument.h
llvm::Function::returnDoesNotAlias
bool returnDoesNotAlias() const
Determine if the parameter or return value is marked with NoAlias attribute.
Definition: Function.h:649
CallingConv.h
llvm::Function::doesNotThrow
bool doesNotThrow() const
Determine if the function cannot unwind.
Definition: Function.h:556
Attributes.h
llvm::Function::hasLazyArguments
bool hasLazyArguments() const
hasLazyArguments/CheckLazyArguments - The argument list of a function is built on demand,...
Definition: Function.h:108
llvm::Function::getParamAlignment
uint64_t getParamAlignment(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: Function.h:437
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::Function::getValueSymbolTable
ValueSymbolTable * getValueSymbolTable()
getSymbolTable() - Return the symbol table if any, otherwise nullptr.
Definition: Function.h:715
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::AssemblyAnnotationWriter
Definition: AssemblyAnnotationWriter.h:27
llvm::Function::getArg
Argument * getArg(unsigned i) const
Definition: Function.h:756
llvm::Function::back
const BasicBlock & back() const
Definition: Function.h:732
llvm::Function::getParamDereferenceableOrNullBytes
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Extract the number of dereferenceable_or_null bytes for a parameter.
Definition: Function.h:485
llvm::AttributeList::getParamStructRetType
Type * getParamStructRetType(unsigned ArgNo) const
Return the sret type for the specified function parameter.
Definition: Attributes.cpp:1408
Casting.h
llvm::fltSemantics
Definition: APFloat.cpp:54
llvm::Function::needsUnwindTableEntry
bool needsUnwindTableEntry() const
True if this function needs an unwind table.
Definition: Function.h:636
Arguments
AMDGPU Lower Kernel Arguments
Definition: AMDGPULowerKernelArguments.cpp:243
llvm::Function::getFunctionType
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:177
llvm::Function::hasProfileData
bool hasProfileData(bool IncludeSynthetic=false) const
Return true if the function is annotated with profile data.
Definition: Function.h:292
llvm::Function::onlyAccessesArgMemory
bool onlyAccessesArgMemory() const
Determine if the call can access memmory only using pointers based on its arguments.
Definition: Function.h:521
llvm::Function::setNotConvergent
void setNotConvergent()
Definition: Function.h:578
llvm::Function::mustProgress
bool mustProgress() const
Determine if the function is required to make forward progress.
Definition: Function.h:616
llvm::Function::getParamStackAlign
MaybeAlign getParamStackAlign(unsigned ArgNo) const
Definition: Function.h:447
llvm::Function::arg_begin
arg_iterator arg_begin()
Definition: Function.h:738
llvm::Function::deleteBody
void deleteBody()
deleteBody - This method deletes the body of the function, and converts the linkage to external.
Definition: Function.h:676
llvm::Function::getParamByRefType
Type * getParamByRefType(unsigned ArgNo) const
Extract the byref type for a parameter.
Definition: Function.h:467
llvm::Function::front
const BasicBlock & front() const
Definition: Function.h:730
DECLARE_TRANSPARENT_OPERAND_ACCESSORS
#define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS)
Macro for generating in-class operand accessor declarations.
Definition: OperandTraits.h:110
llvm::Function::isVarArg
bool isVarArg() const
isVarArg - Return true if this function takes a variable number of arguments.
Definition: Function.h:190
llvm::Function::arg_end
const_arg_iterator arg_end() const
Definition: Function.h:751
llvm::ValueSymbolTable
This class provides a symbol table of name/value pairs.
Definition: ValueSymbolTable.h:37
llvm::SmallVectorImpl::iterator
typename SuperClass::iterator iterator
Definition: SmallVector.h:558
llvm::Function::setHasUWTable
void setHasUWTable()
Definition: Function.h:631
N
#define N
llvm::AttributeList::hasRetAttr
bool hasRetAttr(Attribute::AttrKind Kind) const
Return true if the attribute exists for the return value.
Definition: Attributes.h:744
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::tgtok::Bit
@ Bit
Definition: TGLexer.h:50
llvm::Function::setDoesNotReturn
void setDoesNotReturn()
Definition: Function.h:548
llvm::Function::doesNotReturn
bool doesNotReturn() const
Determine if the function cannot return.
Definition: Function.h:545
llvm::Function::onlyReadsMemory
bool onlyReadsMemory() const
Determine if the function does not access or only reads memory.
Definition: Function.h:504
ilist_node.h
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1826
llvm::Function::hasMinSize
bool hasMinSize() const
Optimize this function for minimum size (-Oz).
Definition: Function.h:658
DerivedTypes.h
llvm::Function::setOnlyAccessesInaccessibleMemory
void setOnlyAccessesInaccessibleMemory()
Definition: Function.h:531
llvm::Function::hasNoSync
bool hasNoSync() const
Determine if the call can synchroize with other threads.
Definition: Function.h:599
llvm::Function::ProfileCount
Class to represent profile counts.
Definition: Function.h:255
llvm::Function::setOnlyWritesMemory
void setOnlyWritesMemory()
Definition: Function.h:515
llvm::HungoffOperandTraits
HungoffOperandTraits - determine the allocation regime of the Use array when it is not a prefix to th...
Definition: OperandTraits.h:95
llvm::NullPointerIsDefined
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:1985
llvm::Function::arg_begin
const_arg_iterator arg_begin() const
Definition: Function.h:742
llvm::AttributeList::hasParamAttr
bool hasParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Return true if the attribute exists for the given argument.
Definition: Attributes.h:729
SymbolTableListTraits.h
Value.h
llvm::Function::getParamStructRetType
Type * getParamStructRetType(unsigned ArgNo) const
Extract the sret type for a parameter.
Definition: Function.h:457
llvm::Function::setAttributes
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:319
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::Function::isPresplitCoroutine
bool isPresplitCoroutine() const
A function will have the "coroutine.presplit" attribute if it's a coroutine and has not gone through ...
Definition: Function.h:491
llvm::Function::const_iterator
BasicBlockListType::const_iterator const_iterator
Definition: Function.h:69
llvm::Function::setReturnDoesNotAlias
void setReturnDoesNotAlias()
Definition: Function.h:652
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:103
llvm::Function::size
size_t size() const
Definition: Function.h:728
llvm::AttributeList::getFnStackAlignment
MaybeAlign getFnStackAlignment() const
Get the stack alignment of the function.
Definition: Attributes.cpp:1428
llvm::Function::iterator
BasicBlockListType::iterator iterator
Definition: Function.h:68
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38