contrib/llvm/tools/clang/include/clang/CodeGen/CGFunctionInfo.h

   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_FUNCTION_INFO_H
  17 #define LLVM_CLANG_CODEGEN_FUNCTION_INFO_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 'direct', except it only applies to arguments stored
  67     /// in memory and forbids any implicit copies.  When applied to a return
  68     /// type, it means the value is returned indirectly via an implicit sret
  69     /// 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
  91   ABIArgInfo(Kind K)
  92       : PaddingType(nullptr), TheKind(K), PaddingInReg(false), InReg(false) {}
  93
  94 public:
  95   ABIArgInfo()
  96       : TypeData(nullptr), PaddingType(nullptr), DirectOffset(0),
  97         TheKind(Direct), PaddingInReg(false), InReg(false) {}
  98
  99   static ABIArgInfo getDirect(llvm::Type *T = nullptr, unsigned Offset = 0,
 100                               llvm::Type *Padding = nullptr) {
 101     auto AI = ABIArgInfo(Direct);
 102     AI.setCoerceToType(T);
 103     AI.setDirectOffset(Offset);
 104     AI.setPaddingType(Padding);
 105     return AI;
 106   }
 107   static ABIArgInfo getDirectInReg(llvm::Type *T = nullptr) {
 108     auto AI = getDirect(T);
 109     AI.setInReg(true);
 110     return AI;
 111   }
 112   static ABIArgInfo getExtend(llvm::Type *T = nullptr) {
 113     auto AI = ABIArgInfo(Extend);
 114     AI.setCoerceToType(T);
 115     AI.setDirectOffset(0);
 116     return AI;
 117   }
 118   static ABIArgInfo getExtendInReg(llvm::Type *T = nullptr) {
 119     auto AI = getExtend(T);
 120     AI.setInReg(true);
 121     return AI;
 122   }
 123   static ABIArgInfo getIgnore() {
 124     return ABIArgInfo(Ignore);
 125   }
 126   static ABIArgInfo getIndirect(unsigned Alignment, bool ByVal = true,
 127                                 bool Realign = false,
 128                                 llvm::Type *Padding = nullptr) {
 129     auto AI = ABIArgInfo(Indirect);
 130     AI.setIndirectAlign(Alignment);
 131     AI.setIndirectByVal(ByVal);
 132     AI.setIndirectRealign(Realign);
 133     AI.setSRetAfterThis(false);
 134     AI.setPaddingType(Padding);
 135     return AI;
 136   }
 137   static ABIArgInfo getIndirectInReg(unsigned Alignment, bool ByVal = true,
 138                                      bool Realign = false) {
 139     auto AI = getIndirect(Alignment, ByVal, Realign);
 140     AI.setInReg(true);
 141     return AI;
 142   }
 143   static ABIArgInfo getInAlloca(unsigned FieldIndex) {
 144     auto AI = ABIArgInfo(InAlloca);
 145     AI.setInAllocaFieldIndex(FieldIndex);
 146     return AI;
 147   }
 148   static ABIArgInfo getExpand() {
 149     return ABIArgInfo(Expand);
 150   }
 151   static ABIArgInfo getExpandWithPadding(bool PaddingInReg,
 152                                          llvm::Type *Padding) {
 153     auto AI = getExpand();
 154     AI.setPaddingInReg(PaddingInReg);
 155     AI.setPaddingType(Padding);
 156     return AI;
 157   }
 158
 159   Kind getKind() const { return TheKind; }
 160   bool isDirect() const { return TheKind == Direct; }
 161   bool isInAlloca() const { return TheKind == InAlloca; }
 162   bool isExtend() const { return TheKind == Extend; }
 163   bool isIgnore() const { return TheKind == Ignore; }
 164   bool isIndirect() const { return TheKind == Indirect; }
 165   bool isExpand() const { return TheKind == Expand; }
 166
 167   bool canHaveCoerceToType() const { return isDirect() || isExtend(); }
 168
 169   // Direct/Extend accessors
 170   unsigned getDirectOffset() const {
 171     assert((isDirect() || isExtend()) && "Not a direct or extend kind");
 172     return DirectOffset;
 173   }
 174   void setDirectOffset(unsigned Offset) {
 175     assert((isDirect() || isExtend()) && "Not a direct or extend kind");
 176     DirectOffset = Offset;
 177   }
 178
 179   llvm::Type *getPaddingType() const { return PaddingType; }
 180
 181   void setPaddingType(llvm::Type *T) { PaddingType = T; }
 182
 183   bool getPaddingInReg() const {
 184     return PaddingInReg;
 185   }
 186   void setPaddingInReg(bool PIR) {
 187     PaddingInReg = PIR;
 188   }
 189
 190   llvm::Type *getCoerceToType() const {
 191     assert(canHaveCoerceToType() && "Invalid kind!");
 192     return TypeData;
 193   }
 194
 195   void setCoerceToType(llvm::Type *T) {
 196     assert(canHaveCoerceToType() && "Invalid kind!");
 197     TypeData = T;
 198   }
 199
 200   bool getInReg() const {
 201     assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
 202     return InReg;
 203   }
 204
 205   void setInReg(bool IR) {
 206     assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
 207     InReg = IR;
 208   }
 209
 210   // Indirect accessors
 211   unsigned getIndirectAlign() const {
 212     assert(isIndirect() && "Invalid kind!");
 213     return IndirectAlign;
 214   }
 215   void setIndirectAlign(unsigned IA) {
 216     assert(isIndirect() && "Invalid kind!");
 217     IndirectAlign = IA;
 218   }
 219
 220   bool getIndirectByVal() const {
 221     assert(isIndirect() && "Invalid kind!");
 222     return IndirectByVal;
 223   }
 224   void setIndirectByVal(unsigned IBV) {
 225     assert(isIndirect() && "Invalid kind!");
 226     IndirectByVal = IBV;
 227   }
 228
 229   bool getIndirectRealign() const {
 230     assert(isIndirect() && "Invalid kind!");
 231     return IndirectRealign;
 232   }
 233   void setIndirectRealign(bool IR) {
 234     assert(isIndirect() && "Invalid kind!");
 235     IndirectRealign = IR;
 236   }
 237
 238   bool isSRetAfterThis() const {
 239     assert(isIndirect() && "Invalid kind!");
 240     return SRetAfterThis;
 241   }
 242   void setSRetAfterThis(bool AfterThis) {
 243     assert(isIndirect() && "Invalid kind!");
 244     SRetAfterThis = AfterThis;
 245   }
 246
 247   unsigned getInAllocaFieldIndex() const {
 248     assert(isInAlloca() && "Invalid kind!");
 249     return AllocaFieldIndex;
 250   }
 251   void setInAllocaFieldIndex(unsigned FieldIndex) {
 252     assert(isInAlloca() && "Invalid kind!");
 253     AllocaFieldIndex = FieldIndex;
 254   }
 255
 256   /// \brief Return true if this field of an inalloca struct should be returned
 257   /// to implement a struct return calling convention.
 258   bool getInAllocaSRet() const {
 259     assert(isInAlloca() && "Invalid kind!");
 260     return InAllocaSRet;
 261   }
 262
 263   void setInAllocaSRet(bool SRet) {
 264     assert(isInAlloca() && "Invalid kind!");
 265     InAllocaSRet = SRet;
 266   }
 267
 268   void dump() const;
 269 };
 270
 271 /// A class for recording the number of arguments that a function
 272 /// signature requires.
 273 class RequiredArgs {
 274   /// The number of required arguments, or ~0 if the signature does
 275   /// not permit optional arguments.
 276   unsigned NumRequired;
 277 public:
 278   enum All_t { All };
 279
 280   RequiredArgs(All_t _) : NumRequired(~0U) {}
 281   explicit RequiredArgs(unsigned n) : NumRequired(n) {
 282     assert(n != ~0U);
 283   }
 284
 285   /// Compute the arguments required by the given formal prototype,
 286   /// given that there may be some additional, non-formal arguments
 287   /// in play.
 288   static RequiredArgs forPrototypePlus(const FunctionProtoType *prototype,
 289                                        unsigned additional) {
 290     if (!prototype->isVariadic()) return All;
 291     return RequiredArgs(prototype->getNumParams() + additional);
 292   }
 293
 294   static RequiredArgs forPrototype(const FunctionProtoType *prototype) {
 295     return forPrototypePlus(prototype, 0);
 296   }
 297
 298   static RequiredArgs forPrototype(CanQual<FunctionProtoType> prototype) {
 299     return forPrototype(prototype.getTypePtr());
 300   }
 301
 302   static RequiredArgs forPrototypePlus(CanQual<FunctionProtoType> prototype,
 303                                        unsigned additional) {
 304     return forPrototypePlus(prototype.getTypePtr(), additional);
 305   }
 306
 307   bool allowsOptionalArgs() const { return NumRequired != ~0U; }
 308   unsigned getNumRequiredArgs() const {
 309     assert(allowsOptionalArgs());
 310     return NumRequired;
 311   }
 312
 313   unsigned getOpaqueData() const { return NumRequired; }
 314   static RequiredArgs getFromOpaqueData(unsigned value) {
 315     if (value == ~0U) return All;
 316     return RequiredArgs(value);
 317   }
 318 };
 319
 320 /// CGFunctionInfo - Class to encapsulate the information about a
 321 /// function definition.
 322 class CGFunctionInfo : public llvm::FoldingSetNode {
 323   struct ArgInfo {
 324     CanQualType type;
 325     ABIArgInfo info;
 326   };
 327
 328   /// The LLVM::CallingConv to use for this function (as specified by the
 329   /// user).
 330   unsigned CallingConvention : 8;
 331
 332   /// The LLVM::CallingConv to actually use for this function, which may
 333   /// depend on the ABI.
 334   unsigned EffectiveCallingConvention : 8;
 335
 336   /// The clang::CallingConv that this was originally created with.
 337   unsigned ASTCallingConvention : 8;
 338
 339   /// Whether this is an instance method.
 340   unsigned InstanceMethod : 1;
 341
 342   /// Whether this function is noreturn.
 343   unsigned NoReturn : 1;
 344
 345   /// Whether this function is returns-retained.
 346   unsigned ReturnsRetained : 1;
 347
 348   /// How many arguments to pass inreg.
 349   unsigned HasRegParm : 1;
 350   unsigned RegParm : 4;
 351
 352   RequiredArgs Required;
 353
 354   /// The struct representing all arguments passed in memory.  Only used when
 355   /// passing non-trivial types with inalloca.  Not part of the profile.
 356   llvm::StructType *ArgStruct;
 357
 358   unsigned NumArgs;
 359   ArgInfo *getArgsBuffer() {
 360     return reinterpret_cast<ArgInfo*>(this+1);
 361   }
 362   const ArgInfo *getArgsBuffer() const {
 363     return reinterpret_cast<const ArgInfo*>(this + 1);
 364   }
 365
 366   CGFunctionInfo() : Required(RequiredArgs::All) {}
 367
 368 public:
 369   static CGFunctionInfo *create(unsigned llvmCC,
 370                                 bool InstanceMethod,
 371                                 const FunctionType::ExtInfo &extInfo,
 372                                 CanQualType resultType,
 373                                 ArrayRef<CanQualType> argTypes,
 374                                 RequiredArgs required);
 375
 376   typedef const ArgInfo *const_arg_iterator;
 377   typedef ArgInfo *arg_iterator;
 378
 379   typedef llvm::iterator_range<arg_iterator> arg_range;
 380   typedef llvm::iterator_range<const_arg_iterator> arg_const_range;
 381
 382   arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
 383   arg_const_range arguments() const {
 384     return arg_const_range(arg_begin(), arg_end());
 385   }
 386
 387   const_arg_iterator arg_begin() const { return getArgsBuffer() + 1; }
 388   const_arg_iterator arg_end() const { return getArgsBuffer() + 1 + NumArgs; }
 389   arg_iterator arg_begin() { return getArgsBuffer() + 1; }
 390   arg_iterator arg_end() { return getArgsBuffer() + 1 + NumArgs; }
 391
 392   unsigned  arg_size() const { return NumArgs; }
 393
 394   bool isVariadic() const { return Required.allowsOptionalArgs(); }
 395   RequiredArgs getRequiredArgs() const { return Required; }
 396
 397   bool isInstanceMethod() const { return InstanceMethod; }
 398
 399   bool isNoReturn() const { return NoReturn; }
 400
 401   /// In ARC, whether this function retains its return value.  This
 402   /// is not always reliable for call sites.
 403   bool isReturnsRetained() const { return ReturnsRetained; }
 404
 405   /// getASTCallingConvention() - Return the AST-specified calling
 406   /// convention.
 407   CallingConv getASTCallingConvention() const {
 408     return CallingConv(ASTCallingConvention);
 409   }
 410
 411   /// getCallingConvention - Return the user specified calling
 412   /// convention, which has been translated into an LLVM CC.
 413   unsigned getCallingConvention() const { return CallingConvention; }
 414
 415   /// getEffectiveCallingConvention - Return the actual calling convention to
 416   /// use, which may depend on the ABI.
 417   unsigned getEffectiveCallingConvention() const {
 418     return EffectiveCallingConvention;
 419   }
 420   void setEffectiveCallingConvention(unsigned Value) {
 421     EffectiveCallingConvention = Value;
 422   }
 423
 424   bool getHasRegParm() const { return HasRegParm; }
 425   unsigned getRegParm() const { return RegParm; }
 426
 427   FunctionType::ExtInfo getExtInfo() const {
 428     return FunctionType::ExtInfo(isNoReturn(),
 429                                  getHasRegParm(), getRegParm(),
 430                                  getASTCallingConvention(),
 431                                  isReturnsRetained());
 432   }
 433
 434   CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
 435
 436   ABIArgInfo &getReturnInfo() { return getArgsBuffer()[0].info; }
 437   const ABIArgInfo &getReturnInfo() const { return getArgsBuffer()[0].info; }
 438
 439   /// \brief Return true if this function uses inalloca arguments.
 440   bool usesInAlloca() const { return ArgStruct; }
 441
 442   /// \brief Get the struct type used to represent all the arguments in memory.
 443   llvm::StructType *getArgStruct() const { return ArgStruct; }
 444   void setArgStruct(llvm::StructType *Ty) { ArgStruct = Ty; }
 445
 446   void Profile(llvm::FoldingSetNodeID &ID) {
 447     ID.AddInteger(getASTCallingConvention());
 448     ID.AddBoolean(InstanceMethod);
 449     ID.AddBoolean(NoReturn);
 450     ID.AddBoolean(ReturnsRetained);
 451     ID.AddBoolean(HasRegParm);
 452     ID.AddInteger(RegParm);
 453     ID.AddInteger(Required.getOpaqueData());
 454     getReturnType().Profile(ID);
 455     for (const auto &I : arguments())
 456       I.type.Profile(ID);
 457   }
 458   static void Profile(llvm::FoldingSetNodeID &ID,
 459                       bool InstanceMethod,
 460                       const FunctionType::ExtInfo &info,
 461                       RequiredArgs required,
 462                       CanQualType resultType,
 463                       ArrayRef<CanQualType> argTypes) {
 464     ID.AddInteger(info.getCC());
 465     ID.AddBoolean(InstanceMethod);
 466     ID.AddBoolean(info.getNoReturn());
 467     ID.AddBoolean(info.getProducesResult());
 468     ID.AddBoolean(info.getHasRegParm());
 469     ID.AddInteger(info.getRegParm());
 470     ID.AddInteger(required.getOpaqueData());
 471     resultType.Profile(ID);
 472     for (ArrayRef<CanQualType>::iterator
 473            i = argTypes.begin(), e = argTypes.end(); i != e; ++i) {
 474       i->Profile(ID);
 475     }
 476   }
 477 };
 478
 479 }  // end namespace CodeGen
 480 }  // end namespace clang
 481
 482 #endif