1 //===--- CodeGenTypes.h - Type translation for LLVM CodeGen -----*- 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 // This is the code that handles AST -> LLVM type lowering. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef CLANG_CODEGEN_CODEGENTYPES_H 15 #define CLANG_CODEGEN_CODEGENTYPES_H 16 17 #include "CGCall.h" 18 #include "clang/AST/GlobalDecl.h" 19 #include "llvm/Module.h" 20 #include "llvm/ADT/DenseMap.h" 21 #include <vector> 22 23 namespace llvm { 24 class FunctionType; 25 class Module; 26 class TargetData; 27 class Type; 28 class LLVMContext; 29 class StructType; 30 } 31 32 namespace clang { 33 class ABIInfo; 34 class ASTContext; 35 template <typename> class CanQual; 36 class CXXConstructorDecl; 37 class CXXDestructorDecl; 38 class CXXMethodDecl; 39 class CodeGenOptions; 40 class FieldDecl; 41 class FunctionProtoType; 42 class ObjCInterfaceDecl; 43 class ObjCIvarDecl; 44 class PointerType; 45 class QualType; 46 class RecordDecl; 47 class TagDecl; 48 class TargetInfo; 49 class Type; 50 typedef CanQual<Type> CanQualType; 51 52 namespace CodeGen { 53 class CGCXXABI; 54 class CGRecordLayout; 55 56 /// CodeGenTypes - This class organizes the cross-module state that is used 57 /// while lowering AST types to LLVM types. 58 class CodeGenTypes { 59 ASTContext &Context; 60 const TargetInfo &Target; 61 llvm::Module &TheModule; 62 const llvm::TargetData &TheTargetData; 63 const ABIInfo &TheABIInfo; 64 CGCXXABI &TheCXXABI; 65 const CodeGenOptions &CodeGenOpts; 66 67 /// The opaque type map for Objective-C interfaces. All direct 68 /// manipulation is done by the runtime interfaces, which are 69 /// responsible for coercing to the appropriate type; these opaque 70 /// types are never refined. 71 llvm::DenseMap<const ObjCInterfaceType*, llvm::Type *> InterfaceTypes; 72 73 /// CGRecordLayouts - This maps llvm struct type with corresponding 74 /// record layout info. 75 llvm::DenseMap<const Type*, CGRecordLayout *> CGRecordLayouts; 76 77 /// RecordDeclTypes - This contains the LLVM IR type for any converted 78 /// RecordDecl. 79 llvm::DenseMap<const Type*, llvm::StructType *> RecordDeclTypes; 80 81 /// FunctionInfos - Hold memoized CGFunctionInfo results. 82 llvm::FoldingSet<CGFunctionInfo> FunctionInfos; 83 84 /// RecordsBeingLaidOut - This set keeps track of records that we're currently 85 /// converting to an IR type. For example, when converting: 86 /// struct A { struct B { int x; } } when processing 'x', the 'A' and 'B' 87 /// types will be in this set. 88 llvm::SmallPtrSet<const Type*, 4> RecordsBeingLaidOut; 89 90 llvm::SmallPtrSet<const CGFunctionInfo*, 4> FunctionsBeingProcessed; 91 92 /// SkippedLayout - True if we didn't layout a function due to a being inside 93 /// a recursive struct conversion, set this to true. 94 bool SkippedLayout; 95 96 SmallVector<const RecordDecl *, 8> DeferredRecords; 97 98 private: 99 /// TypeCache - This map keeps cache of llvm::Types 100 /// and maps llvm::Types to corresponding clang::Type. 101 llvm::DenseMap<const Type *, llvm::Type *> TypeCache; 102 103 public: 104 CodeGenTypes(ASTContext &Ctx, llvm::Module &M, const llvm::TargetData &TD, 105 const ABIInfo &Info, CGCXXABI &CXXABI, 106 const CodeGenOptions &Opts); 107 ~CodeGenTypes(); 108 109 const llvm::TargetData &getTargetData() const { return TheTargetData; } 110 const TargetInfo &getTarget() const { return Target; } 111 ASTContext &getContext() const { return Context; } 112 const ABIInfo &getABIInfo() const { return TheABIInfo; } 113 const CodeGenOptions &getCodeGenOpts() const { return CodeGenOpts; } 114 CGCXXABI &getCXXABI() const { return TheCXXABI; } 115 llvm::LLVMContext &getLLVMContext() { return TheModule.getContext(); } 116 117 /// ConvertType - Convert type T into a llvm::Type. 118 llvm::Type *ConvertType(QualType T); 119 120 /// ConvertTypeForMem - Convert type T into a llvm::Type. This differs from 121 /// ConvertType in that it is used to convert to the memory representation for 122 /// a type. For example, the scalar representation for _Bool is i1, but the 123 /// memory representation is usually i8 or i32, depending on the target. 124 llvm::Type *ConvertTypeForMem(QualType T); 125 126 /// GetFunctionType - Get the LLVM function type for \arg Info. 127 llvm::FunctionType *GetFunctionType(const CGFunctionInfo &Info, 128 bool IsVariadic); 129 130 llvm::FunctionType *GetFunctionType(GlobalDecl GD); 131 132 /// isFuncTypeConvertible - Utility to check whether a function type can 133 /// be converted to an LLVM type (i.e. doesn't depend on an incomplete tag 134 /// type). 135 bool isFuncTypeConvertible(const FunctionType *FT); 136 bool isFuncTypeArgumentConvertible(QualType Ty); 137 138 /// GetFunctionTypeForVTable - Get the LLVM function type for use in a vtable, 139 /// given a CXXMethodDecl. If the method to has an incomplete return type, 140 /// and/or incomplete argument types, this will return the opaque type. 141 llvm::Type *GetFunctionTypeForVTable(GlobalDecl GD); 142 143 const CGRecordLayout &getCGRecordLayout(const RecordDecl*); 144 145 /// UpdateCompletedType - When we find the full definition for a TagDecl, 146 /// replace the 'opaque' type we previously made for it if applicable. 147 void UpdateCompletedType(const TagDecl *TD); 148 149 /// getNullaryFunctionInfo - Get the function info for a void() 150 /// function with standard CC. 151 const CGFunctionInfo &getNullaryFunctionInfo(); 152 153 /// getFunctionInfo - Get the function info for the specified function decl. 154 const CGFunctionInfo &getFunctionInfo(GlobalDecl GD); 155 156 const CGFunctionInfo &getFunctionInfo(const FunctionDecl *FD); 157 const CGFunctionInfo &getFunctionInfo(const CXXMethodDecl *MD); 158 const CGFunctionInfo &getFunctionInfo(const ObjCMethodDecl *MD); 159 const CGFunctionInfo &getFunctionInfo(const CXXConstructorDecl *D, 160 CXXCtorType Type); 161 const CGFunctionInfo &getFunctionInfo(const CXXDestructorDecl *D, 162 CXXDtorType Type); 163 164 const CGFunctionInfo &getFunctionInfo(const CallArgList &Args, 165 const FunctionType *Ty) { 166 return getFunctionInfo(Ty->getResultType(), Args, 167 Ty->getExtInfo()); 168 } 169 170 const CGFunctionInfo &getFunctionInfo(CanQual<FunctionProtoType> Ty); 171 const CGFunctionInfo &getFunctionInfo(CanQual<FunctionNoProtoType> Ty); 172 173 /// getFunctionInfo - Get the function info for a member function of 174 /// the given type. This is used for calls through member function 175 /// pointers. 176 const CGFunctionInfo &getFunctionInfo(const CXXRecordDecl *RD, 177 const FunctionProtoType *FTP); 178 179 /// getFunctionInfo - Get the function info for a function described by a 180 /// return type and argument types. If the calling convention is not 181 /// specified, the "C" calling convention will be used. 182 const CGFunctionInfo &getFunctionInfo(QualType ResTy, 183 const CallArgList &Args, 184 const FunctionType::ExtInfo &Info); 185 const CGFunctionInfo &getFunctionInfo(QualType ResTy, 186 const FunctionArgList &Args, 187 const FunctionType::ExtInfo &Info); 188 189 /// Retrieves the ABI information for the given function signature. 190 /// 191 /// \param ArgTys - must all actually be canonical as params 192 const CGFunctionInfo &getFunctionInfo(CanQualType RetTy, 193 const SmallVectorImpl<CanQualType> &ArgTys, 194 const FunctionType::ExtInfo &Info); 195 196 /// \brief Compute a new LLVM record layout object for the given record. 197 CGRecordLayout *ComputeRecordLayout(const RecordDecl *D, 198 llvm::StructType *Ty); 199 200 /// addRecordTypeName - Compute a name from the given record decl with an 201 /// optional suffix and name the given LLVM type using it. 202 void addRecordTypeName(const RecordDecl *RD, llvm::StructType *Ty, 203 StringRef suffix); 204 205 206 public: // These are internal details of CGT that shouldn't be used externally. 207 /// ConvertRecordDeclType - Lay out a tagged decl type like struct or union. 208 llvm::StructType *ConvertRecordDeclType(const RecordDecl *TD); 209 210 /// GetExpandedTypes - Expand the type \arg Ty into the LLVM 211 /// argument types it would be passed as on the provided vector \arg 212 /// ArgTys. See ABIArgInfo::Expand. 213 void GetExpandedTypes(QualType type, 214 SmallVectorImpl<llvm::Type*> &expanded); 215 216 /// IsZeroInitializable - Return whether a type can be 217 /// zero-initialized (in the C++ sense) with an LLVM zeroinitializer. 218 bool isZeroInitializable(QualType T); 219 220 /// IsZeroInitializable - Return whether a record type can be 221 /// zero-initialized (in the C++ sense) with an LLVM zeroinitializer. 222 bool isZeroInitializable(const CXXRecordDecl *RD); 223 224 bool isRecordLayoutComplete(const Type *Ty) const; 225 bool noRecordsBeingLaidOut() const { 226 return RecordsBeingLaidOut.empty(); 227 } 228 bool isRecordBeingLaidOut(const Type *Ty) const { 229 return RecordsBeingLaidOut.count(Ty); 230 } 231 232 }; 233 234 } // end namespace CodeGen 235 } // end namespace clang 236 237 #endif 238
