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 ABIArgInfo(Kind K,llvm::Type * TD,unsigned UI,bool B0,bool B1,bool IR,bool PIR,llvm::Type * P)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: ABIArgInfo()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 } getIgnore()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 } getExpand()116 static ABIArgInfo getExpand() { 117 return ABIArgInfo(Expand, 0, 0, false, false, false, false, 0); 118 } getExpandWithPadding(bool PaddingInReg,llvm::Type * Padding)119 static ABIArgInfo getExpandWithPadding(bool PaddingInReg, 120 llvm::Type *Padding) { 121 return ABIArgInfo(Expand, 0, 0, false, false, false, PaddingInReg, 122 Padding); 123 } 124 getKind()125 Kind getKind() const { return TheKind; } isDirect()126 bool isDirect() const { return TheKind == Direct; } isExtend()127 bool isExtend() const { return TheKind == Extend; } isIgnore()128 bool isIgnore() const { return TheKind == Ignore; } isIndirect()129 bool isIndirect() const { return TheKind == Indirect; } isExpand()130 bool isExpand() const { return TheKind == Expand; } 131 canHaveCoerceToType()132 bool canHaveCoerceToType() const { 133 return TheKind == Direct || TheKind == Extend; 134 } 135 136 // Direct/Extend accessors getDirectOffset()137 unsigned getDirectOffset() const { 138 assert((isDirect() || isExtend()) && "Not a direct or extend kind"); 139 return UIntData; 140 } 141 getPaddingType()142 llvm::Type *getPaddingType() const { 143 return PaddingType; 144 } 145 getPaddingInReg()146 bool getPaddingInReg() const { 147 return PaddingInReg; 148 } 149 getCoerceToType()150 llvm::Type *getCoerceToType() const { 151 assert(canHaveCoerceToType() && "Invalid kind!"); 152 return TypeData; 153 } 154 setCoerceToType(llvm::Type * T)155 void setCoerceToType(llvm::Type *T) { 156 assert(canHaveCoerceToType() && "Invalid kind!"); 157 TypeData = T; 158 } 159 getInReg()160 bool getInReg() const { 161 assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!"); 162 return InReg; 163 } 164 165 // Indirect accessors getIndirectAlign()166 unsigned getIndirectAlign() const { 167 assert(TheKind == Indirect && "Invalid kind!"); 168 return UIntData; 169 } 170 getIndirectByVal()171 bool getIndirectByVal() const { 172 assert(TheKind == Indirect && "Invalid kind!"); 173 return BoolData0; 174 } 175 getIndirectRealign()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: ABIInfo(CodeGen::CodeGenTypes & cgt)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. getRuntimeCC()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 223