Home | History | Annotate | Download | only in CodeGen 
      1 //==-- CGFunctionInfo.h - Representation of function argument/return types -==//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // Defines CGFunctionInfo and associated types used in representing the
     11 // LLVM source types and ABI-coerced types for function arguments and
     12 // return values.
     13 //
     14 //===----------------------------------------------------------------------===//
     15 
     16 #ifndef LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
     17 #define LLVM_CLANG_CODEGEN_CGFUNCTIONINFO_H
     18 
     19 #include "clang/AST/CanonicalType.h"
     20 #include "clang/AST/Type.h"
     21 #include "llvm/ADT/FoldingSet.h"
     22 #include <cassert>
     23 
     24 namespace llvm {
     25   class Type;
     26   class StructType;
     27 }
     28 
     29 namespace clang {
     30 class Decl;
     31 
     32 namespace CodeGen {
     33 
     34 /// ABIArgInfo - Helper class to encapsulate information about how a
     35 /// specific C type should be passed to or returned from a function.
     36 class ABIArgInfo {
     37 public:
     38   enum Kind : uint8_t {
     39     /// Direct - Pass the argument directly using the normal converted LLVM
     40     /// type, or by coercing to another specified type stored in
     41     /// 'CoerceToType').  If an offset is specified (in UIntData), then the
     42     /// argument passed is offset by some number of bytes in the memory
     43     /// representation. A dummy argument is emitted before the real argument
     44     /// if the specified type stored in "PaddingType" is not zero.
     45     Direct,
     46 
     47     /// Extend - Valid only for integer argument types. Same as 'direct'
     48     /// but also emit a zero/sign extension attribute.
     49     Extend,
     50 
     51     /// Indirect - Pass the argument indirectly via a hidden pointer
     52     /// with the specified alignment (0 indicates default alignment).
     53     Indirect,
     54 
     55     /// Ignore - Ignore the argument (treat as void). Useful for void and
     56     /// empty structs.
     57     Ignore,
     58 
     59     /// Expand - Only valid for aggregate argument types. The structure should
     60     /// be expanded into consecutive arguments for its constituent fields.
     61     /// Currently expand is only allowed on structures whose fields
     62     /// are all scalar types or are themselves expandable types.
     63     Expand,
     64 
     65     /// InAlloca - Pass the argument directly using the LLVM inalloca attribute.
     66     /// This is similar to indirect with byval, except it only applies to
     67     /// arguments stored in memory and forbids any implicit copies.  When
     68     /// applied to a return type, it means the value is returned indirectly via
     69     /// an implicit sret parameter stored in the argument struct.
     70     InAlloca,
     71     KindFirst = Direct,
     72     KindLast = InAlloca
     73   };
     74 
     75 private:
     76   llvm::Type *TypeData; // isDirect() || isExtend()
     77   llvm::Type *PaddingType;
     78   union {
     79     unsigned DirectOffset;     // isDirect() || isExtend()
     80     unsigned IndirectAlign;    // isIndirect()
     81     unsigned AllocaFieldIndex; // isInAlloca()
     82   };
     83   Kind TheKind;
     84   bool PaddingInReg : 1;
     85   bool InAllocaSRet : 1;    // isInAlloca()
     86   bool IndirectByVal : 1;   // isIndirect()
     87   bool IndirectRealign : 1; // isIndirect()
     88   bool SRetAfterThis : 1;   // isIndirect()
     89   bool InReg : 1;           // isDirect() || isExtend() || isIndirect()
     90   bool CanBeFlattened: 1;   // isDirect()
     91 
     92   ABIArgInfo(Kind K)
     93       : PaddingType(nullptr), TheKind(K), PaddingInReg(false), InReg(false) {}
     94 
     95 public:
     96   ABIArgInfo()
     97       : TypeData(nullptr), PaddingType(nullptr), DirectOffset(0),
     98         TheKind(Direct), PaddingInReg(false), InReg(false) {}
     99 
    100   static ABIArgInfo getDirect(llvm::Type *T = nullptr, unsigned Offset = 0,
    101                               llvm::Type *Padding = nullptr,
    102                               bool CanBeFlattened = true) {
    103     auto AI = ABIArgInfo(Direct);
    104     AI.setCoerceToType(T);
    105     AI.setDirectOffset(Offset);
    106     AI.setPaddingType(Padding);
    107     AI.setCanBeFlattened(CanBeFlattened);
    108     return AI;
    109   }
    110   static ABIArgInfo getDirectInReg(llvm::Type *T = nullptr) {
    111     auto AI = getDirect(T);
    112     AI.setInReg(true);
    113     return AI;
    114   }
    115   static ABIArgInfo getExtend(llvm::Type *T = nullptr) {
    116     auto AI = ABIArgInfo(Extend);
    117     AI.setCoerceToType(T);
    118     AI.setDirectOffset(0);
    119     return AI;
    120   }
    121   static ABIArgInfo getExtendInReg(llvm::Type *T = nullptr) {
    122     auto AI = getExtend(T);
    123     AI.setInReg(true);
    124     return AI;
    125   }
    126   static ABIArgInfo getIgnore() {
    127     return ABIArgInfo(Ignore);
    128   }
    129   static ABIArgInfo getIndirect(unsigned Alignment, bool ByVal = true,
    130                                 bool Realign = false,
    131                                 llvm::Type *Padding = nullptr) {
    132     auto AI = ABIArgInfo(Indirect);
    133     AI.setIndirectAlign(Alignment);
    134     AI.setIndirectByVal(ByVal);
    135     AI.setIndirectRealign(Realign);
    136     AI.setSRetAfterThis(false);
    137     AI.setPaddingType(Padding);
    138     return AI;
    139   }
    140   static ABIArgInfo getIndirectInReg(unsigned Alignment, bool ByVal = true,
    141                                      bool Realign = false) {
    142     auto AI = getIndirect(Alignment, ByVal, Realign);
    143     AI.setInReg(true);
    144     return AI;
    145   }
    146   static ABIArgInfo getInAlloca(unsigned FieldIndex) {
    147     auto AI = ABIArgInfo(InAlloca);
    148     AI.setInAllocaFieldIndex(FieldIndex);
    149     return AI;
    150   }
    151   static ABIArgInfo getExpand() {
    152     return ABIArgInfo(Expand);
    153   }
    154   static ABIArgInfo getExpandWithPadding(bool PaddingInReg,
    155                                          llvm::Type *Padding) {
    156     auto AI = getExpand();
    157     AI.setPaddingInReg(PaddingInReg);
    158     AI.setPaddingType(Padding);
    159     return AI;
    160   }
    161 
    162   Kind getKind() const { return TheKind; }
    163   bool isDirect() const { return TheKind == Direct; }
    164   bool isInAlloca() const { return TheKind == InAlloca; }
    165   bool isExtend() const { return TheKind == Extend; }
    166   bool isIgnore() const { return TheKind == Ignore; }
    167   bool isIndirect() const { return TheKind == Indirect; }
    168   bool isExpand() const { return TheKind == Expand; }
    169 
    170   bool canHaveCoerceToType() const { return isDirect() || isExtend(); }
    171 
    172   // Direct/Extend accessors
    173   unsigned getDirectOffset() const {
    174     assert((isDirect() || isExtend()) && "Not a direct or extend kind");
    175     return DirectOffset;
    176   }
    177   void setDirectOffset(unsigned Offset) {
    178     assert((isDirect() || isExtend()) && "Not a direct or extend kind");
    179     DirectOffset = Offset;
    180   }
    181 
    182   llvm::Type *getPaddingType() const { return PaddingType; }
    183 
    184   void setPaddingType(llvm::Type *T) { PaddingType = T; }
    185 
    186   bool getPaddingInReg() const {
    187     return PaddingInReg;
    188   }
    189   void setPaddingInReg(bool PIR) {
    190     PaddingInReg = PIR;
    191   }
    192 
    193   llvm::Type *getCoerceToType() const {
    194     assert(canHaveCoerceToType() && "Invalid kind!");
    195     return TypeData;
    196   }
    197 
    198   void setCoerceToType(llvm::Type *T) {
    199     assert(canHaveCoerceToType() && "Invalid kind!");
    200     TypeData = T;
    201   }
    202 
    203   bool getInReg() const {
    204     assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
    205     return InReg;
    206   }
    207 
    208   void setInReg(bool IR) {
    209     assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
    210     InReg = IR;
    211   }
    212 
    213   // Indirect accessors
    214   unsigned getIndirectAlign() const {
    215     assert(isIndirect() && "Invalid kind!");
    216     return IndirectAlign;
    217   }
    218   void setIndirectAlign(unsigned IA) {
    219     assert(isIndirect() && "Invalid kind!");
    220     IndirectAlign = IA;
    221   }
    222 
    223   bool getIndirectByVal() const {
    224     assert(isIndirect() && "Invalid kind!");
    225     return IndirectByVal;
    226   }
    227   void setIndirectByVal(unsigned IBV) {
    228     assert(isIndirect() && "Invalid kind!");
    229     IndirectByVal = IBV;
    230   }
    231 
    232   bool getIndirectRealign() const {
    233     assert(isIndirect() && "Invalid kind!");
    234     return IndirectRealign;
    235   }
    236   void setIndirectRealign(bool IR) {
    237     assert(isIndirect() && "Invalid kind!");
    238     IndirectRealign = IR;
    239   }
    240 
    241   bool isSRetAfterThis() const {
    242     assert(isIndirect() && "Invalid kind!");
    243     return SRetAfterThis;
    244   }
    245   void setSRetAfterThis(bool AfterThis) {
    246     assert(isIndirect() && "Invalid kind!");
    247     SRetAfterThis = AfterThis;
    248   }
    249 
    250   unsigned getInAllocaFieldIndex() const {
    251     assert(isInAlloca() && "Invalid kind!");
    252     return AllocaFieldIndex;
    253   }
    254   void setInAllocaFieldIndex(unsigned FieldIndex) {
    255     assert(isInAlloca() && "Invalid kind!");
    256     AllocaFieldIndex = FieldIndex;
    257   }
    258 
    259   /// \brief Return true if this field of an inalloca struct should be returned
    260   /// to implement a struct return calling convention.
    261   bool getInAllocaSRet() const {
    262     assert(isInAlloca() && "Invalid kind!");
    263     return InAllocaSRet;
    264   }
    265 
    266   void setInAllocaSRet(bool SRet) {
    267     assert(isInAlloca() && "Invalid kind!");
    268     InAllocaSRet = SRet;
    269   }
    270 
    271   bool getCanBeFlattened() const {
    272     assert(isDirect() && "Invalid kind!");
    273     return CanBeFlattened;
    274   }
    275 
    276   void setCanBeFlattened(bool Flatten) {
    277     assert(isDirect() && "Invalid kind!");
    278     CanBeFlattened = Flatten;
    279   }
    280 
    281   void dump() const;
    282 };
    283 
    284 /// A class for recording the number of arguments that a function
    285 /// signature requires.
    286 class RequiredArgs {
    287   /// The number of required arguments, or ~0 if the signature does
    288   /// not permit optional arguments.
    289   unsigned NumRequired;
    290 public:
    291   enum All_t { All };
    292 
    293   RequiredArgs(All_t _) : NumRequired(~0U) {}
    294   explicit RequiredArgs(unsigned n) : NumRequired(n) {
    295     assert(n != ~0U);
    296   }
    297 
    298   /// Compute the arguments required by the given formal prototype,
    299   /// given that there may be some additional, non-formal arguments
    300   /// in play.
    301   static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype,
    302                                        unsigned additional) {
    303     if (!prototype->isVariadic()) return All;
    304     return RequiredArgs(prototype->getNumParams() + additional);
    305   }
    306 
    307   static RequiredArgs forPrototype(const FunctionProtoType *prototype) {
    308     return forPrototypePlus(prototype, 0);
    309   }
    310 
    311   static RequiredArgs forPrototype(CanQual<FunctionProtoType> prototype) {
    312     return forPrototype(prototype.getTypePtr());
    313   }
    314 
    315   static RequiredArgs forPrototypePlus(CanQual<FunctionProtoType> prototype,
    316                                        unsigned additional) {
    317     return forPrototypePlus(prototype.getTypePtr(), additional);
    318   }
    319 
    320   bool allowsOptionalArgs() const { return NumRequired != ~0U; }
    321   unsigned getNumRequiredArgs() const {
    322     assert(allowsOptionalArgs());
    323     return NumRequired;
    324   }
    325 
    326   unsigned getOpaqueData() const { return NumRequired; }
    327   static RequiredArgs getFromOpaqueData(unsigned value) {
    328     if (value == ~0U) return All;
    329     return RequiredArgs(value);
    330   }
    331 };
    332 
    333 /// CGFunctionInfo - Class to encapsulate the information about a
    334 /// function definition.
    335 class CGFunctionInfo : public llvm::FoldingSetNode {
    336   struct ArgInfo {
    337     CanQualType type;
    338     ABIArgInfo info;
    339   };
    340 
    341   /// The LLVM::CallingConv to use for this function (as specified by the
    342   /// user).
    343   unsigned CallingConvention : 8;
    344 
    345   /// The LLVM::CallingConv to actually use for this function, which may
    346   /// depend on the ABI.
    347   unsigned EffectiveCallingConvention : 8;
    348 
    349   /// The clang::CallingConv that this was originally created with.
    350   unsigned ASTCallingConvention : 8;
    351 
    352   /// Whether this is an instance method.
    353   unsigned InstanceMethod : 1;
    354 
    355   /// Whether this is a chain call.
    356   unsigned ChainCall : 1;
    357 
    358   /// Whether this function is noreturn.
    359   unsigned NoReturn : 1;
    360 
    361   /// Whether this function is returns-retained.
    362   unsigned ReturnsRetained : 1;
    363 
    364   /// How many arguments to pass inreg.
    365   unsigned HasRegParm : 1;
    366   unsigned RegParm : 3;
    367 
    368   RequiredArgs Required;
    369 
    370   /// The struct representing all arguments passed in memory.  Only used when
    371   /// passing non-trivial types with inalloca.  Not part of the profile.
    372   llvm::StructType *ArgStruct;
    373 
    374   unsigned NumArgs;
    375   ArgInfo *getArgsBuffer() {
    376     return reinterpret_cast<ArgInfo*>(this+1);
    377   }
    378   const ArgInfo *getArgsBuffer() const {
    379     return reinterpret_cast<const ArgInfo*>(this + 1);
    380   }
    381 
    382   CGFunctionInfo() : Required(RequiredArgs::All) {}
    383 
    384 public:
    385   static CGFunctionInfo *create(unsigned llvmCC,
    386                                 bool instanceMethod,
    387                                 bool chainCall,
    388                                 const FunctionType::ExtInfo &extInfo,
    389                                 CanQualType resultType,
    390                                 ArrayRef<CanQualType> argTypes,
    391                                 RequiredArgs required);
    392 
    393   typedef const ArgInfo *const_arg_iterator;
    394   typedef ArgInfo *arg_iterator;
    395 
    396   typedef llvm::iterator_range<arg_iterator> arg_range;
    397   typedef llvm::iterator_range<const_arg_iterator> arg_const_range;
    398 
    399   arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
    400   arg_const_range arguments() const {
    401     return arg_const_range(arg_begin(), arg_end());
    402   }
    403 
    404   const_arg_iterator arg_begin() const { return getArgsBuffer() + 1; }
    405   const_arg_iterator arg_end() const { return getArgsBuffer() + 1 + NumArgs; }
    406   arg_iterator arg_begin() { return getArgsBuffer() + 1; }
    407   arg_iterator arg_end() { return getArgsBuffer() + 1 + NumArgs; }
    408 
    409   unsigned  arg_size() const { return NumArgs; }
    410 
    411   bool isVariadic() const { return Required.allowsOptionalArgs(); }
    412   RequiredArgs getRequiredArgs() const { return Required; }
    413   unsigned getNumRequiredArgs() const {
    414     return isVariadic() ? getRequiredArgs().getNumRequiredArgs() : arg_size();
    415   }
    416 
    417   bool isInstanceMethod() const { return InstanceMethod; }
    418 
    419   bool isChainCall() const { return ChainCall; }
    420 
    421   bool isNoReturn() const { return NoReturn; }
    422 
    423   /// In ARC, whether this function retains its return value.  This
    424   /// is not always reliable for call sites.
    425   bool isReturnsRetained() const { return ReturnsRetained; }
    426 
    427   /// getASTCallingConvention() - Return the AST-specified calling
    428   /// convention.
    429   CallingConv getASTCallingConvention() const {
    430     return CallingConv(ASTCallingConvention);
    431   }
    432 
    433   /// getCallingConvention - Return the user specified calling
    434   /// convention, which has been translated into an LLVM CC.
    435   unsigned getCallingConvention() const { return CallingConvention; }
    436 
    437   /// getEffectiveCallingConvention - Return the actual calling convention to
    438   /// use, which may depend on the ABI.
    439   unsigned getEffectiveCallingConvention() const {
    440     return EffectiveCallingConvention;
    441   }
    442   void setEffectiveCallingConvention(unsigned Value) {
    443     EffectiveCallingConvention = Value;
    444   }
    445 
    446   bool getHasRegParm() const { return HasRegParm; }
    447   unsigned getRegParm() const { return RegParm; }
    448 
    449   FunctionType::ExtInfo getExtInfo() const {
    450     return FunctionType::ExtInfo(isNoReturn(),
    451                                  getHasRegParm(), getRegParm(),
    452                                  getASTCallingConvention(),
    453                                  isReturnsRetained());
    454   }
    455 
    456   CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
    457 
    458   ABIArgInfo &getReturnInfo() { return getArgsBuffer()[0].info; }
    459   const ABIArgInfo &getReturnInfo() const { return getArgsBuffer()[0].info; }
    460 
    461   /// \brief Return true if this function uses inalloca arguments.
    462   bool usesInAlloca() const { return ArgStruct; }
    463 
    464   /// \brief Get the struct type used to represent all the arguments in memory.
    465   llvm::StructType *getArgStruct() const { return ArgStruct; }
    466   void setArgStruct(llvm::StructType *Ty) { ArgStruct = Ty; }
    467 
    468   void Profile(llvm::FoldingSetNodeID &ID) {
    469     ID.AddInteger(getASTCallingConvention());
    470     ID.AddBoolean(InstanceMethod);
    471     ID.AddBoolean(ChainCall);
    472     ID.AddBoolean(NoReturn);
    473     ID.AddBoolean(ReturnsRetained);
    474     ID.AddBoolean(HasRegParm);
    475     ID.AddInteger(RegParm);
    476     ID.AddInteger(Required.getOpaqueData());
    477     getReturnType().Profile(ID);
    478     for (const auto &I : arguments())
    479       I.type.Profile(ID);
    480   }
    481   static void Profile(llvm::FoldingSetNodeID &ID,
    482                       bool InstanceMethod,
    483                       bool ChainCall,
    484                       const FunctionType::ExtInfo &info,
    485                       RequiredArgs required,
    486                       CanQualType resultType,
    487                       ArrayRef<CanQualType> argTypes) {
    488     ID.AddInteger(info.getCC());
    489     ID.AddBoolean(InstanceMethod);
    490     ID.AddBoolean(ChainCall);
    491     ID.AddBoolean(info.getNoReturn());
    492     ID.AddBoolean(info.getProducesResult());
    493     ID.AddBoolean(info.getHasRegParm());
    494     ID.AddInteger(info.getRegParm());
    495     ID.AddInteger(required.getOpaqueData());
    496     resultType.Profile(ID);
    497     for (ArrayRef<CanQualType>::iterator
    498            i = argTypes.begin(), e = argTypes.end(); i != e; ++i) {
    499       i->Profile(ID);
    500     }
    501   }
    502 };
    503 
    504 }  // end namespace CodeGen
    505 }  // end namespace clang
    506 
    507 #endif
    508