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/ADT/DenseMap.h"
20#include "llvm/IR/Module.h"
21#include <vector>
22
23namespace llvm {
24  class FunctionType;
25  class Module;
26  class DataLayout;
27  class Type;
28  class LLVMContext;
29  class StructType;
30}
31
32namespace 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
52namespace CodeGen {
53  class CGCXXABI;
54  class CGRecordLayout;
55  class CodeGenModule;
56  class RequiredArgs;
57
58/// CodeGenTypes - This class organizes the cross-module state that is used
59/// while lowering AST types to LLVM types.
60class CodeGenTypes {
61public:
62  // Some of this stuff should probably be left on the CGM.
63  CodeGenModule &CGM;
64  ASTContext &Context;
65  llvm::Module &TheModule;
66  const llvm::DataLayout &TheDataLayout;
67  const TargetInfo &Target;
68  CGCXXABI &TheCXXABI;
69  const CodeGenOptions &CodeGenOpts;
70
71  // This should not be moved earlier, since its initialization depends on some
72  // of the previous reference members being already initialized
73  const ABIInfo &TheABIInfo;
74
75private:
76  /// The opaque type map for Objective-C interfaces. All direct
77  /// manipulation is done by the runtime interfaces, which are
78  /// responsible for coercing to the appropriate type; these opaque
79  /// types are never refined.
80  llvm::DenseMap<const ObjCInterfaceType*, llvm::Type *> InterfaceTypes;
81
82  /// CGRecordLayouts - This maps llvm struct type with corresponding
83  /// record layout info.
84  llvm::DenseMap<const Type*, CGRecordLayout *> CGRecordLayouts;
85
86  /// RecordDeclTypes - This contains the LLVM IR type for any converted
87  /// RecordDecl.
88  llvm::DenseMap<const Type*, llvm::StructType *> RecordDeclTypes;
89
90  /// FunctionInfos - Hold memoized CGFunctionInfo results.
91  llvm::FoldingSet<CGFunctionInfo> FunctionInfos;
92
93  /// RecordsBeingLaidOut - This set keeps track of records that we're currently
94  /// converting to an IR type.  For example, when converting:
95  /// struct A { struct B { int x; } } when processing 'x', the 'A' and 'B'
96  /// types will be in this set.
97  llvm::SmallPtrSet<const Type*, 4> RecordsBeingLaidOut;
98
99  llvm::SmallPtrSet<const CGFunctionInfo*, 4> FunctionsBeingProcessed;
100
101  /// SkippedLayout - True if we didn't layout a function due to a being inside
102  /// a recursive struct conversion, set this to true.
103  bool SkippedLayout;
104
105  SmallVector<const RecordDecl *, 8> DeferredRecords;
106
107private:
108  /// TypeCache - This map keeps cache of llvm::Types
109  /// and maps llvm::Types to corresponding clang::Type.
110  llvm::DenseMap<const Type *, llvm::Type *> TypeCache;
111
112public:
113  CodeGenTypes(CodeGenModule &cgm);
114  ~CodeGenTypes();
115
116  const llvm::DataLayout &getDataLayout() const { return TheDataLayout; }
117  ASTContext &getContext() const { return Context; }
118  const ABIInfo &getABIInfo() const { return TheABIInfo; }
119  const CodeGenOptions &getCodeGenOpts() const { return CodeGenOpts; }
120  const TargetInfo &getTarget() const { return Target; }
121  CGCXXABI &getCXXABI() const { return TheCXXABI; }
122  llvm::LLVMContext &getLLVMContext() { return TheModule.getContext(); }
123
124  /// ConvertType - Convert type T into a llvm::Type.
125  llvm::Type *ConvertType(QualType T);
126
127  /// ConvertTypeForMem - Convert type T into a llvm::Type.  This differs from
128  /// ConvertType in that it is used to convert to the memory representation for
129  /// a type.  For example, the scalar representation for _Bool is i1, but the
130  /// memory representation is usually i8 or i32, depending on the target.
131  llvm::Type *ConvertTypeForMem(QualType T);
132
133  /// GetFunctionType - Get the LLVM function type for \arg Info.
134  llvm::FunctionType *GetFunctionType(const CGFunctionInfo &Info);
135
136  llvm::FunctionType *GetFunctionType(GlobalDecl GD);
137
138  /// isFuncTypeConvertible - Utility to check whether a function type can
139  /// be converted to an LLVM type (i.e. doesn't depend on an incomplete tag
140  /// type).
141  bool isFuncTypeConvertible(const FunctionType *FT);
142  bool isFuncTypeArgumentConvertible(QualType Ty);
143
144  /// GetFunctionTypeForVTable - Get the LLVM function type for use in a vtable,
145  /// given a CXXMethodDecl. If the method to has an incomplete return type,
146  /// and/or incomplete argument types, this will return the opaque type.
147  llvm::Type *GetFunctionTypeForVTable(GlobalDecl GD);
148
149  const CGRecordLayout &getCGRecordLayout(const RecordDecl*);
150
151  /// UpdateCompletedType - When we find the full definition for a TagDecl,
152  /// replace the 'opaque' type we previously made for it if applicable.
153  void UpdateCompletedType(const TagDecl *TD);
154
155  /// getNullaryFunctionInfo - Get the function info for a void()
156  /// function with standard CC.
157  const CGFunctionInfo &arrangeNullaryFunction();
158
159  // The arrangement methods are split into three families:
160  //   - those meant to drive the signature and prologue/epilogue
161  //     of a function declaration or definition,
162  //   - those meant for the computation of the LLVM type for an abstract
163  //     appearance of a function, and
164  //   - those meant for performing the IR-generation of a call.
165  // They differ mainly in how they deal with optional (i.e. variadic)
166  // arguments, as well as unprototyped functions.
167  //
168  // Key points:
169  // - The CGFunctionInfo for emitting a specific call site must include
170  //   entries for the optional arguments.
171  // - The function type used at the call site must reflect the formal
172  //   signature of the declaration being called, or else the call will
173  //   go awry.
174  // - For the most part, unprototyped functions are called by casting to
175  //   a formal signature inferred from the specific argument types used
176  //   at the call-site.  However, some targets (e.g. x86-64) screw with
177  //   this for compatibility reasons.
178
179  const CGFunctionInfo &arrangeGlobalDeclaration(GlobalDecl GD);
180  const CGFunctionInfo &arrangeFunctionDeclaration(const FunctionDecl *FD);
181  const CGFunctionInfo &arrangeFunctionDeclaration(QualType ResTy,
182                                                   const FunctionArgList &Args,
183                                             const FunctionType::ExtInfo &Info,
184                                                   bool isVariadic);
185
186  const CGFunctionInfo &arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD);
187  const CGFunctionInfo &arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD,
188                                                        QualType receiverType);
189
190  const CGFunctionInfo &arrangeCXXMethodDeclaration(const CXXMethodDecl *MD);
191  const CGFunctionInfo &arrangeCXXConstructorDeclaration(
192                                                    const CXXConstructorDecl *D,
193                                                    CXXCtorType Type);
194  const CGFunctionInfo &arrangeCXXDestructor(const CXXDestructorDecl *D,
195                                             CXXDtorType Type);
196
197  const CGFunctionInfo &arrangeFreeFunctionCall(const CallArgList &Args,
198                                                const FunctionType *Ty);
199  const CGFunctionInfo &arrangeFreeFunctionCall(QualType ResTy,
200                                                const CallArgList &args,
201                                                FunctionType::ExtInfo info,
202                                                RequiredArgs required);
203  const CGFunctionInfo &arrangeBlockFunctionCall(const CallArgList &args,
204                                                 const FunctionType *type);
205
206  const CGFunctionInfo &arrangeCXXMethodCall(const CallArgList &args,
207                                             const FunctionProtoType *type,
208                                             RequiredArgs required);
209
210  const CGFunctionInfo &arrangeFreeFunctionType(CanQual<FunctionProtoType> Ty);
211  const CGFunctionInfo &arrangeFreeFunctionType(CanQual<FunctionNoProtoType> Ty);
212  const CGFunctionInfo &arrangeCXXMethodType(const CXXRecordDecl *RD,
213                                             const FunctionProtoType *FTP);
214
215  /// "Arrange" the LLVM information for a call or type with the given
216  /// signature.  This is largely an internal method; other clients
217  /// should use one of the above routines, which ultimately defer to
218  /// this.
219  ///
220  /// \param argTypes - must all actually be canonical as params
221  const CGFunctionInfo &arrangeLLVMFunctionInfo(CanQualType returnType,
222                                                ArrayRef<CanQualType> argTypes,
223                                                FunctionType::ExtInfo info,
224                                                RequiredArgs args);
225
226  /// \brief Compute a new LLVM record layout object for the given record.
227  CGRecordLayout *ComputeRecordLayout(const RecordDecl *D,
228                                      llvm::StructType *Ty);
229
230  /// addRecordTypeName - Compute a name from the given record decl with an
231  /// optional suffix and name the given LLVM type using it.
232  void addRecordTypeName(const RecordDecl *RD, llvm::StructType *Ty,
233                         StringRef suffix);
234
235
236public:  // These are internal details of CGT that shouldn't be used externally.
237  /// ConvertRecordDeclType - Lay out a tagged decl type like struct or union.
238  llvm::StructType *ConvertRecordDeclType(const RecordDecl *TD);
239
240  /// GetExpandedTypes - Expand the type \arg Ty into the LLVM
241  /// argument types it would be passed as on the provided vector \arg
242  /// ArgTys. See ABIArgInfo::Expand.
243  void GetExpandedTypes(QualType type,
244                        SmallVectorImpl<llvm::Type*> &expanded);
245
246  /// IsZeroInitializable - Return whether a type can be
247  /// zero-initialized (in the C++ sense) with an LLVM zeroinitializer.
248  bool isZeroInitializable(QualType T);
249
250  /// IsZeroInitializable - Return whether a record type can be
251  /// zero-initialized (in the C++ sense) with an LLVM zeroinitializer.
252  bool isZeroInitializable(const CXXRecordDecl *RD);
253
254  bool isRecordLayoutComplete(const Type *Ty) const;
255  bool noRecordsBeingLaidOut() const {
256    return RecordsBeingLaidOut.empty();
257  }
258  bool isRecordBeingLaidOut(const Type *Ty) const {
259    return RecordsBeingLaidOut.count(Ty);
260  }
261
262};
263
264}  // end namespace CodeGen
265}  // end namespace clang
266
267#endif
268