contrib/llvm-project/llvm/include/llvm/IR/Argument.h

   1 //===-- llvm/Argument.h - Definition of the Argument class ------*- 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 declares the Argument class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_IR_ARGUMENT_H
  14 #define LLVM_IR_ARGUMENT_H
  15
  16 #include "llvm/ADT/Twine.h"
  17 #include "llvm/IR/Attributes.h"
  18 #include "llvm/IR/Value.h"
  19
  20 namespace llvm {
  21
  22 /// This class represents an incoming formal argument to a Function. A formal
  23 /// argument, since it is ``formal'', does not contain an actual value but
  24 /// instead represents the type, argument number, and attributes of an argument
  25 /// for a specific function. When used in the body of said function, the
  26 /// argument of course represents the value of the actual argument that the
  27 /// function was called with.
  28 class Argument final : public Value {
  29   Function *Parent;
  30   unsigned ArgNo;
  31
  32   friend class Function;
  33   void setParent(Function *parent);
  34
  35 public:
  36   /// Argument constructor.
  37   explicit Argument(Type *Ty, const Twine &Name = "", Function *F = nullptr,
  38                     unsigned ArgNo = 0);
  39
  40   inline const Function *getParent() const { return Parent; }
  41   inline       Function *getParent()       { return Parent; }
  42
  43   /// Return the index of this formal argument in its containing function.
  44   ///
  45   /// For example in "void foo(int a, float b)" a is 0 and b is 1.
  46   unsigned getArgNo() const {
  47     assert(Parent && "can't get number of unparented arg");
  48     return ArgNo;
  49   }
  50
  51   /// Return true if this argument has the nonnull attribute. Also returns true
  52   /// if at least one byte is known to be dereferenceable and the pointer is in
  53   /// addrspace(0).
  54   /// If AllowUndefOrPoison is true, respect the semantics of nonnull attribute
  55   /// and return true even if the argument can be undef or poison.
  56   bool hasNonNullAttr(bool AllowUndefOrPoison = true) const;
  57
  58   /// If this argument has the dereferenceable attribute, return the number of
  59   /// bytes known to be dereferenceable. Otherwise, zero is returned.
  60   uint64_t getDereferenceableBytes() const;
  61
  62   /// If this argument has the dereferenceable_or_null attribute, return the
  63   /// number of bytes known to be dereferenceable. Otherwise, zero is returned.
  64   uint64_t getDereferenceableOrNullBytes() const;
  65
  66   /// If this argument has nofpclass attribute, return the mask representing
  67   /// disallowed floating-point values. Otherwise, fcNone is returned.
  68   FPClassTest getNoFPClass() const;
  69
  70   /// Return true if this argument has the byval attribute.
  71   bool hasByValAttr() const;
  72
  73   /// Return true if this argument has the byref attribute.
  74   bool hasByRefAttr() const;
  75
  76   /// Return true if this argument has the swiftself attribute.
  77   bool hasSwiftSelfAttr() const;
  78
  79   /// Return true if this argument has the swifterror attribute.
  80   bool hasSwiftErrorAttr() const;
  81
  82   /// Return true if this argument has the byval, inalloca, or preallocated
  83   /// attribute. These attributes represent arguments being passed by value,
  84   /// with an associated copy between the caller and callee
  85   bool hasPassPointeeByValueCopyAttr() const;
  86
  87   /// If this argument satisfies has hasPassPointeeByValueAttr, return the
  88   /// in-memory ABI size copied to the stack for the call. Otherwise, return 0.
  89   uint64_t getPassPointeeByValueCopySize(const DataLayout &DL) const;
  90
  91   /// Return true if this argument has the byval, sret, inalloca, preallocated,
  92   /// or byref attribute. These attributes represent arguments being passed by
  93   /// value (which may or may not involve a stack copy)
  94   bool hasPointeeInMemoryValueAttr() const;
  95
  96   /// If hasPointeeInMemoryValueAttr returns true, the in-memory ABI type is
  97   /// returned. Otherwise, nullptr.
  98   Type *getPointeeInMemoryValueType() const;
  99
 100   /// If this is a byval or inalloca argument, return its alignment.
 101   /// FIXME: Remove this function once transition to Align is over.
 102   /// Use getParamAlign() instead.
 103   LLVM_DEPRECATED("Use getParamAlign() instead", "getParamAlign")
 104   uint64_t getParamAlignment() const;
 105
 106   /// If this is a byval or inalloca argument, return its alignment.
 107   MaybeAlign getParamAlign() const;
 108
 109   MaybeAlign getParamStackAlign() const;
 110
 111   /// If this is a byval argument, return its type.
 112   Type *getParamByValType() const;
 113
 114   /// If this is an sret argument, return its type.
 115   Type *getParamStructRetType() const;
 116
 117   /// If this is a byref argument, return its type.
 118   Type *getParamByRefType() const;
 119
 120   /// If this is an inalloca argument, return its type.
 121   Type *getParamInAllocaType() const;
 122
 123   /// Return true if this argument has the nest attribute.
 124   bool hasNestAttr() const;
 125
 126   /// Return true if this argument has the noalias attribute.
 127   bool hasNoAliasAttr() const;
 128
 129   /// Return true if this argument has the nocapture attribute.
 130   bool hasNoCaptureAttr() const;
 131
 132   /// Return true if this argument has the nofree attribute.
 133   bool hasNoFreeAttr() const;
 134
 135   /// Return true if this argument has the sret attribute.
 136   bool hasStructRetAttr() const;
 137
 138   /// Return true if this argument has the inreg attribute.
 139   bool hasInRegAttr() const;
 140
 141   /// Return true if this argument has the returned attribute.
 142   bool hasReturnedAttr() const;
 143
 144   /// Return true if this argument has the readonly or readnone attribute.
 145   bool onlyReadsMemory() const;
 146
 147   /// Return true if this argument has the inalloca attribute.
 148   bool hasInAllocaAttr() const;
 149
 150   /// Return true if this argument has the preallocated attribute.
 151   bool hasPreallocatedAttr() const;
 152
 153   /// Return true if this argument has the zext attribute.
 154   bool hasZExtAttr() const;
 155
 156   /// Return true if this argument has the sext attribute.
 157   bool hasSExtAttr() const;
 158
 159   /// Add attributes to an argument.
 160   void addAttrs(AttrBuilder &B);
 161
 162   void addAttr(Attribute::AttrKind Kind);
 163
 164   void addAttr(Attribute Attr);
 165
 166   /// Remove attributes from an argument.
 167   void removeAttr(Attribute::AttrKind Kind);
 168
 169   void removeAttrs(const AttributeMask &AM);
 170
 171   /// Check if an argument has a given attribute.
 172   bool hasAttribute(Attribute::AttrKind Kind) const;
 173
 174   Attribute getAttribute(Attribute::AttrKind Kind) const;
 175
 176   /// Method for support type inquiry through isa, cast, and dyn_cast.
 177   static bool classof(const Value *V) {
 178     return V->getValueID() == ArgumentVal;
 179   }
 180 };
 181
 182 } // End llvm namespace
 183
 184 #endif