contrib/llvm/tools/clang/lib/CodeGen/ABIInfo.h

   1 //===----- ABIInfo.h - ABI information access & encapsulation ---*- C++ -*-===//
   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 #ifndef CLANG_CODEGEN_ABIINFO_H
  11 #define CLANG_CODEGEN_ABIINFO_H
  12
  13 #include "clang/AST/Type.h"
  14 #include "llvm/IR/Type.h"
  15 #include "llvm/IR/CallingConv.h"
  16
  17 namespace llvm {
  18   class Value;
  19   class LLVMContext;
  20   class DataLayout;
  21 }
  22
  23 namespace clang {
  24   class ASTContext;
  25   class TargetInfo;
  26
  27   namespace CodeGen {
  28     class CGFunctionInfo;
  29     class CodeGenFunction;
  30     class CodeGenTypes;
  31   }
  32
  33   // FIXME: All of this stuff should be part of the target interface
  34   // somehow. It is currently here because it is not clear how to factor
  35   // the targets to support this, since the Targets currently live in a
  36   // layer below types n'stuff.
  37
  38   /// ABIArgInfo - Helper class to encapsulate information about how a
  39   /// specific C type should be passed to or returned from a function.
  40   class ABIArgInfo {
  41   public:
  42     enum Kind {
  43       /// Direct - Pass the argument directly using the normal converted LLVM
  44       /// type, or by coercing to another specified type stored in
  45       /// 'CoerceToType').  If an offset is specified (in UIntData), then the
  46       /// argument passed is offset by some number of bytes in the memory
  47       /// representation. A dummy argument is emitted before the real argument
  48       /// if the specified type stored in "PaddingType" is not zero.
  49       Direct,
  50
  51       /// Extend - Valid only for integer argument types. Same as 'direct'
  52       /// but also emit a zero/sign extension attribute.
  53       Extend,
  54
  55       /// Indirect - Pass the argument indirectly via a hidden pointer
  56       /// with the specified alignment (0 indicates default alignment).
  57       Indirect,
  58
  59       /// Ignore - Ignore the argument (treat as void). Useful for void and
  60       /// empty structs.
  61       Ignore,
  62
  63       /// Expand - Only valid for aggregate argument types. The structure should
  64       /// be expanded into consecutive arguments for its constituent fields.
  65       /// Currently expand is only allowed on structures whose fields
  66       /// are all scalar types or are themselves expandable types.
  67       Expand,
  68
  69       KindFirst=Direct, KindLast=Expand
  70     };
  71
  72   private:
  73     Kind TheKind;
  74     llvm::Type *TypeData;
  75     llvm::Type *PaddingType;
  76     unsigned UIntData;
  77     bool BoolData0;
  78     bool BoolData1;
  79     bool InReg;
  80     bool PaddingInReg;
  81
  82     ABIArgInfo(Kind K, llvm::Type *TD, unsigned UI, bool B0, bool B1, bool IR,
  83                bool PIR, llvm::Type* P)
  84       : TheKind(K), TypeData(TD), PaddingType(P), UIntData(UI), BoolData0(B0),
  85         BoolData1(B1), InReg(IR), PaddingInReg(PIR) {}
  86
  87   public:
  88     ABIArgInfo() : TheKind(Direct), TypeData(0), UIntData(0) {}
  89
  90     static ABIArgInfo getDirect(llvm::Type *T = 0, unsigned Offset = 0,
  91                                 llvm::Type *Padding = 0) {
  92       return ABIArgInfo(Direct, T, Offset, false, false, false, false, Padding);
  93     }
  94     static ABIArgInfo getDirectInReg(llvm::Type *T = 0) {
  95       return ABIArgInfo(Direct, T, 0, false, false, true, false, 0);
  96     }
  97     static ABIArgInfo getExtend(llvm::Type *T = 0) {
  98       return ABIArgInfo(Extend, T, 0, false, false, false, false, 0);
  99     }
 100     static ABIArgInfo getExtendInReg(llvm::Type *T = 0) {
 101       return ABIArgInfo(Extend, T, 0, false, false, true, false, 0);
 102     }
 103     static ABIArgInfo getIgnore() {
 104       return ABIArgInfo(Ignore, 0, 0, false, false, false, false, 0);
 105     }
 106     static ABIArgInfo getIndirect(unsigned Alignment, bool ByVal = true
 107                                   , bool Realign = false
 108                                   , llvm::Type *Padding = 0) {
 109       return ABIArgInfo(Indirect, 0, Alignment, ByVal, Realign, false, false,
 110                         Padding);
 111     }
 112     static ABIArgInfo getIndirectInReg(unsigned Alignment, bool ByVal = true
 113                                   , bool Realign = false) {
 114       return ABIArgInfo(Indirect, 0, Alignment, ByVal, Realign, true, false, 0);
 115     }
 116     static ABIArgInfo getExpand() {
 117       return ABIArgInfo(Expand, 0, 0, false, false, false, false, 0);
 118     }
 119     static ABIArgInfo getExpandWithPadding(bool PaddingInReg,
 120                                            llvm::Type *Padding) {
 121      return ABIArgInfo(Expand, 0, 0, false, false, false, PaddingInReg,
 122                        Padding);
 123     }
 124
 125     Kind getKind() const { return TheKind; }
 126     bool isDirect() const { return TheKind == Direct; }
 127     bool isExtend() const { return TheKind == Extend; }
 128     bool isIgnore() const { return TheKind == Ignore; }
 129     bool isIndirect() const { return TheKind == Indirect; }
 130     bool isExpand() const { return TheKind == Expand; }
 131
 132     bool canHaveCoerceToType() const {
 133       return TheKind == Direct || TheKind == Extend;
 134     }
 135
 136     // Direct/Extend accessors
 137     unsigned getDirectOffset() const {
 138       assert((isDirect() || isExtend()) && "Not a direct or extend kind");
 139       return UIntData;
 140     }
 141
 142     llvm::Type *getPaddingType() const {
 143       return PaddingType;
 144     }
 145
 146     bool getPaddingInReg() const {
 147       return PaddingInReg;
 148     }
 149
 150     llvm::Type *getCoerceToType() const {
 151       assert(canHaveCoerceToType() && "Invalid kind!");
 152       return TypeData;
 153     }
 154
 155     void setCoerceToType(llvm::Type *T) {
 156       assert(canHaveCoerceToType() && "Invalid kind!");
 157       TypeData = T;
 158     }
 159
 160     bool getInReg() const {
 161       assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
 162       return InReg;
 163     }
 164
 165     // Indirect accessors
 166     unsigned getIndirectAlign() const {
 167       assert(TheKind == Indirect && "Invalid kind!");
 168       return UIntData;
 169     }
 170
 171     bool getIndirectByVal() const {
 172       assert(TheKind == Indirect && "Invalid kind!");
 173       return BoolData0;
 174     }
 175
 176     bool getIndirectRealign() const {
 177       assert(TheKind == Indirect && "Invalid kind!");
 178       return BoolData1;
 179     }
 180
 181     void dump() const;
 182   };
 183
 184   /// ABIInfo - Target specific hooks for defining how a type should be
 185   /// passed or returned from functions.
 186   class ABIInfo {
 187   public:
 188     CodeGen::CodeGenTypes &CGT;
 189   protected:
 190     llvm::CallingConv::ID RuntimeCC;
 191   public:
 192     ABIInfo(CodeGen::CodeGenTypes &cgt)
 193       : CGT(cgt), RuntimeCC(llvm::CallingConv::C) {}
 194
 195     virtual ~ABIInfo();
 196
 197     ASTContext &getContext() const;
 198     llvm::LLVMContext &getVMContext() const;
 199     const llvm::DataLayout &getDataLayout() const;
 200     const TargetInfo &getTarget() const;
 201
 202     /// Return the calling convention to use for system runtime
 203     /// functions.
 204     llvm::CallingConv::ID getRuntimeCC() const {
 205       return RuntimeCC;
 206     }
 207
 208     virtual void computeInfo(CodeGen::CGFunctionInfo &FI) const = 0;
 209
 210     /// EmitVAArg - Emit the target dependent code to load a value of
 211     /// \arg Ty from the va_list pointed to by \arg VAListAddr.
 212
 213     // FIXME: This is a gaping layering violation if we wanted to drop
 214     // the ABI information any lower than CodeGen. Of course, for
 215     // VAArg handling it has to be at this level; there is no way to
 216     // abstract this out.
 217     virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
 218                                    CodeGen::CodeGenFunction &CGF) const = 0;
 219   };
 220 }  // end namespace clang
 221
 222 #endif