 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
0.0% |
0 / 0 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
0.0% |
0 / 0 |
| |
|
Line Coverage: |
100.0% |
15 / 15 |
| |
 |
|
 |
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 "llvm/Module.h"
18 : #include "llvm/ADT/DenseMap.h"
19 : #include "llvm/ADT/SmallSet.h"
20 : #include <vector>
21 :
22 : #include "CGCall.h"
23 : #include "GlobalDecl.h"
24 :
25 : namespace llvm {
26 : class FunctionType;
27 : class Module;
28 : class OpaqueType;
29 : class PATypeHolder;
30 : class TargetData;
31 : class Type;
32 : class LLVMContext;
33 : }
34 :
35 : namespace clang {
36 : class ABIInfo;
37 : class ASTContext;
38 : class CXXConstructorDecl;
39 : class CXXDestructorDecl;
40 : class CXXMethodDecl;
41 : class FieldDecl;
42 : class FunctionProtoType;
43 : class ObjCInterfaceDecl;
44 : class ObjCIvarDecl;
45 : class PointerType;
46 : class QualType;
47 : class RecordDecl;
48 : class TagDecl;
49 : class TargetInfo;
50 : class Type;
51 :
52 : namespace CodeGen {
53 : class CodeGenTypes;
54 :
55 : /// CGRecordLayout - This class handles struct and union layout info while
56 : /// lowering AST types to LLVM types.
57 : class CGRecordLayout {
58 : CGRecordLayout(); // DO NOT IMPLEMENT
59 :
60 : /// LLVMType - The LLVMType corresponding to this record layout.
61 : const llvm::Type *LLVMType;
62 :
63 : /// ContainsPointerToDataMember - Whether one of the fields in this record
64 : /// layout is a pointer to data member, or a struct that contains pointer to
65 : /// data member.
66 : bool ContainsPointerToDataMember;
67 :
68 : public:
69 1341: CGRecordLayout(const llvm::Type *T, bool ContainsPointerToDataMember)
70 1341: : LLVMType(T), ContainsPointerToDataMember(ContainsPointerToDataMember) { }
71 :
72 : /// getLLVMType - Return llvm type associated with this record.
73 1341: const llvm::Type *getLLVMType() const {
74 1341: return LLVMType;
75 : }
76 :
77 : /// containsPointerToDataMember - Whether this struct contains pointers to
78 : /// data members.
79 210: bool containsPointerToDataMember() const {
80 210: return ContainsPointerToDataMember;
81 : }
82 : };
83 :
84 : /// CodeGenTypes - This class organizes the cross-module state that is used
85 : /// while lowering AST types to LLVM types.
86 : class CodeGenTypes {
87 : ASTContext &Context;
88 : const TargetInfo &Target;
89 : llvm::Module& TheModule;
90 : const llvm::TargetData& TheTargetData;
91 : const ABIInfo& TheABIInfo;
92 :
93 : llvm::SmallVector<std::pair<QualType,
94 : llvm::OpaqueType *>, 8> PointersToResolve;
95 :
96 : llvm::DenseMap<const Type*, llvm::PATypeHolder> TagDeclTypes;
97 :
98 : llvm::DenseMap<const Type*, llvm::PATypeHolder> FunctionTypes;
99 :
100 : /// The opaque type map for Objective-C interfaces. All direct
101 : /// manipulation is done by the runtime interfaces, which are
102 : /// responsible for coercing to the appropriate type; these opaque
103 : /// types are never refined.
104 : llvm::DenseMap<const ObjCInterfaceType*, const llvm::Type *> InterfaceTypes;
105 :
106 : /// CGRecordLayouts - This maps llvm struct type with corresponding
107 : /// record layout info.
108 : /// FIXME : If CGRecordLayout is less than 16 bytes then use
109 : /// inline it in the map.
110 : llvm::DenseMap<const Type*, CGRecordLayout *> CGRecordLayouts;
111 :
112 : /// FieldInfo - This maps struct field with corresponding llvm struct type
113 : /// field no. This info is populated by record organizer.
114 : llvm::DenseMap<const FieldDecl *, unsigned> FieldInfo;
115 :
116 : /// FunctionInfos - Hold memoized CGFunctionInfo results.
117 : llvm::FoldingSet<CGFunctionInfo> FunctionInfos;
118 :
119 : public:
120 91: struct BitFieldInfo {
121 : BitFieldInfo(unsigned FieldNo,
122 : unsigned Start,
123 93: unsigned Size)
124 93: : FieldNo(FieldNo), Start(Start), Size(Size) {}
125 :
126 : unsigned FieldNo;
127 : unsigned Start;
128 : unsigned Size;
129 : };
130 :
131 : private:
132 : llvm::DenseMap<const FieldDecl *, BitFieldInfo> BitFields;
133 :
134 : /// TypeCache - This map keeps cache of llvm::Types (through PATypeHolder)
135 : /// and maps llvm::Types to corresponding clang::Type. llvm::PATypeHolder is
136 : /// used instead of llvm::Type because it allows us to bypass potential
137 : /// dangling type pointers due to type refinement on llvm side.
138 : llvm::DenseMap<Type *, llvm::PATypeHolder> TypeCache;
139 :
140 : /// ConvertNewType - Convert type T into a llvm::Type. Do not use this
141 : /// method directly because it does not do any type caching. This method
142 : /// is available only for ConvertType(). CovertType() is preferred
143 : /// interface to convert type T into a llvm::Type.
144 : const llvm::Type *ConvertNewType(QualType T);
145 : public:
146 : CodeGenTypes(ASTContext &Ctx, llvm::Module &M, const llvm::TargetData &TD,
147 : const ABIInfo &Info);
148 : ~CodeGenTypes();
149 :
150 8226: const llvm::TargetData &getTargetData() const { return TheTargetData; }
151 : const TargetInfo &getTarget() const { return Target; }
152 9975: ASTContext &getContext() const { return Context; }
153 2891: const ABIInfo &getABIInfo() const { return TheABIInfo; }
154 11697: llvm::LLVMContext &getLLVMContext() { return TheModule.getContext(); }
155 :
156 : /// ConvertType - Convert type T into a llvm::Type.
157 : const llvm::Type *ConvertType(QualType T);
158 : const llvm::Type *ConvertTypeRecursive(QualType T);
159 :
160 : /// ConvertTypeForMem - Convert type T into a llvm::Type. This differs from
161 : /// ConvertType in that it is used to convert to the memory representation for
162 : /// a type. For example, the scalar representation for _Bool is i1, but the
163 : /// memory representation is usually i8 or i32, depending on the target.
164 : const llvm::Type *ConvertTypeForMem(QualType T);
165 : const llvm::Type *ConvertTypeForMemRecursive(QualType T);
166 :
167 : /// GetFunctionType - Get the LLVM function type for \arg Info.
168 : const llvm::FunctionType *GetFunctionType(const CGFunctionInfo &Info,
169 : bool IsVariadic);
170 :
171 :
172 : /// GetFunctionTypeForVtable - Get the LLVM function type for use in a vtable,
173 : /// given a CXXMethodDecl. If the method to has an incomplete return type,
174 : /// and/or incomplete argument types, this will return the opaque type.
175 : const llvm::Type *GetFunctionTypeForVtable(const CXXMethodDecl *MD);
176 :
177 : const CGRecordLayout &getCGRecordLayout(const TagDecl*) const;
178 :
179 : /// getLLVMFieldNo - Return llvm::StructType element number
180 : /// that corresponds to the field FD.
181 : unsigned getLLVMFieldNo(const FieldDecl *FD);
182 :
183 : /// UpdateCompletedType - When we find the full definition for a TagDecl,
184 : /// replace the 'opaque' type we previously made for it if applicable.
185 : void UpdateCompletedType(const TagDecl *TD);
186 :
187 : private:
188 : const CGFunctionInfo &getFunctionInfo(const FunctionNoProtoType *FTNP);
189 : const CGFunctionInfo &getFunctionInfo(const FunctionProtoType *FTP);
190 :
191 : public:
192 : /// getFunctionInfo - Get the function info for the specified function decl.
193 : const CGFunctionInfo &getFunctionInfo(GlobalDecl GD);
194 :
195 : const CGFunctionInfo &getFunctionInfo(const FunctionDecl *FD);
196 : const CGFunctionInfo &getFunctionInfo(const CXXMethodDecl *MD);
197 : const CGFunctionInfo &getFunctionInfo(const ObjCMethodDecl *MD);
198 : const CGFunctionInfo &getFunctionInfo(const CXXConstructorDecl *D,
199 : CXXCtorType Type);
200 : const CGFunctionInfo &getFunctionInfo(const CXXDestructorDecl *D,
201 : CXXDtorType Type);
202 :
203 : const CGFunctionInfo &getFunctionInfo(const CallArgList &Args,
204 1304: const FunctionType *Ty) {
205 : return getFunctionInfo(Ty->getResultType(), Args,
206 1304: Ty->getCallConv(), Ty->getNoReturnAttr());
207 : }
208 :
209 : // getFunctionInfo - Get the function info for a member function.
210 : const CGFunctionInfo &getFunctionInfo(const CXXRecordDecl *RD,
211 : const FunctionProtoType *FTP);
212 :
213 : /// getFunctionInfo - Get the function info for a function described by a
214 : /// return type and argument types. If the calling convention is not
215 : /// specified, the "C" calling convention will be used.
216 : const CGFunctionInfo &getFunctionInfo(QualType ResTy,
217 : const CallArgList &Args,
218 : CallingConv CC,
219 : bool NoReturn);
220 : const CGFunctionInfo &getFunctionInfo(QualType ResTy,
221 : const FunctionArgList &Args,
222 : CallingConv CC,
223 : bool NoReturn);
224 : const CGFunctionInfo &getFunctionInfo(QualType RetTy,
225 : const llvm::SmallVector<QualType, 16> &ArgTys,
226 : CallingConv CC,
227 : bool NoReturn);
228 :
229 : public: // These are internal details of CGT that shouldn't be used externally.
230 : /// addFieldInfo - Assign field number to field FD.
231 : void addFieldInfo(const FieldDecl *FD, unsigned FieldNo);
232 :
233 : /// addBitFieldInfo - Assign a start bit and a size to field FD.
234 : void addBitFieldInfo(const FieldDecl *FD, unsigned FieldNo,
235 : unsigned Start, unsigned Size);
236 :
237 : /// getBitFieldInfo - Return the BitFieldInfo that corresponds to the field
238 : /// FD.
239 : BitFieldInfo getBitFieldInfo(const FieldDecl *FD);
240 :
241 : /// ConvertTagDeclType - Lay out a tagged decl type like struct or union or
242 : /// enum.
243 : const llvm::Type *ConvertTagDeclType(const TagDecl *TD);
244 :
245 : /// GetExpandedTypes - Expand the type \arg Ty into the LLVM
246 : /// argument types it would be passed as on the provided vector \arg
247 : /// ArgTys. See ABIArgInfo::Expand.
248 : void GetExpandedTypes(QualType Ty, std::vector<const llvm::Type*> &ArgTys);
249 : };
250 :
251 : } // end namespace CodeGen
252 : } // end namespace clang
253 :
254 : #endif
Generated: 2010-02-10 01:31 by zcov