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