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 LLVM_CLANG_LIB_CODEGEN_CODEGENTYPES_H
15#define LLVM_CLANG_LIB_CODEGEN_CODEGENTYPES_H
16
17#include "CGCall.h"
18#include "clang/AST/GlobalDecl.h"
19#include "clang/CodeGen/CGFunctionInfo.h"
20#include "llvm/ADT/DenseMap.h"
21#include "llvm/IR/Module.h"
22#include <vector>
23
24namespace llvm {
25class FunctionType;
26class Module;
27class DataLayout;
28class Type;
29class LLVMContext;
30class StructType;
31}
32
33namespace clang {
34class ASTContext;
35template <typename> class CanQual;
36class CXXConstructorDecl;
37class CXXDestructorDecl;
38class CXXMethodDecl;
39class CodeGenOptions;
40class FieldDecl;
41class FunctionProtoType;
42class ObjCInterfaceDecl;
43class ObjCIvarDecl;
44class PointerType;
45class QualType;
46class RecordDecl;
47class TagDecl;
48class TargetInfo;
49class Type;
50typedef CanQual<Type> CanQualType;
51
52namespace CodeGen {
53class ABIInfo;
54class CGCXXABI;
55class CGRecordLayout;
56class CodeGenModule;
57class RequiredArgs;
58
59enum class StructorType {
60  Complete, // constructor or destructor
61  Base,     // constructor or destructor
62  Deleting  // destructor only
63};
64
65inline CXXCtorType toCXXCtorType(StructorType T) {
66  switch (T) {
67  case StructorType::Complete:
68    return Ctor_Complete;
69  case StructorType::Base:
70    return Ctor_Base;
71  case StructorType::Deleting:
72    llvm_unreachable("cannot have a deleting ctor");
73  }
74  llvm_unreachable("not a StructorType");
75}
76
77inline StructorType getFromCtorType(CXXCtorType T) {
78  switch (T) {
79  case Ctor_Complete:
80    return StructorType::Complete;
81  case Ctor_Base:
82    return StructorType::Base;
83  case Ctor_Comdat:
84    llvm_unreachable("not expecting a COMDAT");
85  case Ctor_CopyingClosure:
86  case Ctor_DefaultClosure:
87    llvm_unreachable("not expecting a closure");
88  }
89  llvm_unreachable("not a CXXCtorType");
90}
91
92inline CXXDtorType toCXXDtorType(StructorType T) {
93  switch (T) {
94  case StructorType::Complete:
95    return Dtor_Complete;
96  case StructorType::Base:
97    return Dtor_Base;
98  case StructorType::Deleting:
99    return Dtor_Deleting;
100  }
101  llvm_unreachable("not a StructorType");
102}
103
104inline StructorType getFromDtorType(CXXDtorType T) {
105  switch (T) {
106  case Dtor_Deleting:
107    return StructorType::Deleting;
108  case Dtor_Complete:
109    return StructorType::Complete;
110  case Dtor_Base:
111    return StructorType::Base;
112  case Dtor_Comdat:
113    llvm_unreachable("not expecting a COMDAT");
114  }
115  llvm_unreachable("not a CXXDtorType");
116}
117
118/// This class organizes the cross-module state that is used while lowering
119/// AST types to LLVM types.
120class CodeGenTypes {
121  CodeGenModule &CGM;
122  // Some of this stuff should probably be left on the CGM.
123  ASTContext &Context;
124  llvm::Module &TheModule;
125  const TargetInfo &Target;
126  CGCXXABI &TheCXXABI;
127
128  // This should not be moved earlier, since its initialization depends on some
129  // of the previous reference members being already initialized
130  const ABIInfo &TheABIInfo;
131
132  /// The opaque type map for Objective-C interfaces. All direct
133  /// manipulation is done by the runtime interfaces, which are
134  /// responsible for coercing to the appropriate type; these opaque
135  /// types are never refined.
136  llvm::DenseMap<const ObjCInterfaceType*, llvm::Type *> InterfaceTypes;
137
138  /// Maps clang struct type with corresponding record layout info.
139  llvm::DenseMap<const Type*, CGRecordLayout *> CGRecordLayouts;
140
141  /// Contains the LLVM IR type for any converted RecordDecl.
142  llvm::DenseMap<const Type*, llvm::StructType *> RecordDeclTypes;
143
144  /// Hold memoized CGFunctionInfo results.
145  llvm::FoldingSet<CGFunctionInfo> FunctionInfos;
146
147  /// This set keeps track of records that we're currently converting
148  /// to an IR type.  For example, when converting:
149  /// struct A { struct B { int x; } } when processing 'x', the 'A' and 'B'
150  /// types will be in this set.
151  llvm::SmallPtrSet<const Type*, 4> RecordsBeingLaidOut;
152
153  llvm::SmallPtrSet<const CGFunctionInfo*, 4> FunctionsBeingProcessed;
154
155  /// True if we didn't layout a function due to a being inside
156  /// a recursive struct conversion, set this to true.
157  bool SkippedLayout;
158
159  SmallVector<const RecordDecl *, 8> DeferredRecords;
160
161  /// This map keeps cache of llvm::Types and maps clang::Type to
162  /// corresponding llvm::Type.
163  llvm::DenseMap<const Type *, llvm::Type *> TypeCache;
164
165  llvm::SmallSet<const Type *, 8> RecordsWithOpaqueMemberPointers;
166
167  unsigned ClangCallConvToLLVMCallConv(CallingConv CC);
168
169public:
170  CodeGenTypes(CodeGenModule &cgm);
171  ~CodeGenTypes();
172
173  const llvm::DataLayout &getDataLayout() const {
174    return TheModule.getDataLayout();
175  }
176  ASTContext &getContext() const { return Context; }
177  const ABIInfo &getABIInfo() const { return TheABIInfo; }
178  const TargetInfo &getTarget() const { return Target; }
179  CGCXXABI &getCXXABI() const { return TheCXXABI; }
180  llvm::LLVMContext &getLLVMContext() { return TheModule.getContext(); }
181
182  /// ConvertType - Convert type T into a llvm::Type.
183  llvm::Type *ConvertType(QualType T);
184
185  /// \brief Converts the GlobalDecl into an llvm::Type. This should be used
186  /// when we know the target of the function we want to convert.  This is
187  /// because some functions (explicitly, those with pass_object_size
188  /// parameters) may not have the same signature as their type portrays, and
189  /// can only be called directly.
190  llvm::Type *ConvertFunctionType(QualType FT,
191                                  const FunctionDecl *FD = nullptr);
192
193  /// ConvertTypeForMem - Convert type T into a llvm::Type.  This differs from
194  /// ConvertType in that it is used to convert to the memory representation for
195  /// a type.  For example, the scalar representation for _Bool is i1, but the
196  /// memory representation is usually i8 or i32, depending on the target.
197  llvm::Type *ConvertTypeForMem(QualType T);
198
199  /// GetFunctionType - Get the LLVM function type for \arg Info.
200  llvm::FunctionType *GetFunctionType(const CGFunctionInfo &Info);
201
202  llvm::FunctionType *GetFunctionType(GlobalDecl GD);
203
204  /// isFuncTypeConvertible - Utility to check whether a function type can
205  /// be converted to an LLVM type (i.e. doesn't depend on an incomplete tag
206  /// type).
207  bool isFuncTypeConvertible(const FunctionType *FT);
208  bool isFuncParamTypeConvertible(QualType Ty);
209
210  /// Determine if a C++ inheriting constructor should have parameters matching
211  /// those of its inherited constructor.
212  bool inheritingCtorHasParams(const InheritedConstructor &Inherited,
213                               CXXCtorType Type);
214
215  /// GetFunctionTypeForVTable - Get the LLVM function type for use in a vtable,
216  /// given a CXXMethodDecl. If the method to has an incomplete return type,
217  /// and/or incomplete argument types, this will return the opaque type.
218  llvm::Type *GetFunctionTypeForVTable(GlobalDecl GD);
219
220  const CGRecordLayout &getCGRecordLayout(const RecordDecl*);
221
222  /// UpdateCompletedType - When we find the full definition for a TagDecl,
223  /// replace the 'opaque' type we previously made for it if applicable.
224  void UpdateCompletedType(const TagDecl *TD);
225
226  /// \brief Remove stale types from the type cache when an inheritance model
227  /// gets assigned to a class.
228  void RefreshTypeCacheForClass(const CXXRecordDecl *RD);
229
230  // The arrangement methods are split into three families:
231  //   - those meant to drive the signature and prologue/epilogue
232  //     of a function declaration or definition,
233  //   - those meant for the computation of the LLVM type for an abstract
234  //     appearance of a function, and
235  //   - those meant for performing the IR-generation of a call.
236  // They differ mainly in how they deal with optional (i.e. variadic)
237  // arguments, as well as unprototyped functions.
238  //
239  // Key points:
240  // - The CGFunctionInfo for emitting a specific call site must include
241  //   entries for the optional arguments.
242  // - The function type used at the call site must reflect the formal
243  //   signature of the declaration being called, or else the call will
244  //   go awry.
245  // - For the most part, unprototyped functions are called by casting to
246  //   a formal signature inferred from the specific argument types used
247  //   at the call-site.  However, some targets (e.g. x86-64) screw with
248  //   this for compatibility reasons.
249
250  const CGFunctionInfo &arrangeGlobalDeclaration(GlobalDecl GD);
251
252  /// Given a function info for a declaration, return the function info
253  /// for a call with the given arguments.
254  ///
255  /// Often this will be able to simply return the declaration info.
256  const CGFunctionInfo &arrangeCall(const CGFunctionInfo &declFI,
257                                    const CallArgList &args);
258
259  /// Free functions are functions that are compatible with an ordinary
260  /// C function pointer type.
261  const CGFunctionInfo &arrangeFunctionDeclaration(const FunctionDecl *FD);
262  const CGFunctionInfo &arrangeFreeFunctionCall(const CallArgList &Args,
263                                                const FunctionType *Ty,
264                                                bool ChainCall);
265  const CGFunctionInfo &arrangeFreeFunctionType(CanQual<FunctionProtoType> Ty,
266                                                const FunctionDecl *FD);
267  const CGFunctionInfo &arrangeFreeFunctionType(CanQual<FunctionNoProtoType> Ty);
268
269  /// A nullary function is a freestanding function of type 'void ()'.
270  /// This method works for both calls and declarations.
271  const CGFunctionInfo &arrangeNullaryFunction();
272
273  /// A builtin function is a freestanding function using the default
274  /// C conventions.
275  const CGFunctionInfo &
276  arrangeBuiltinFunctionDeclaration(QualType resultType,
277                                    const FunctionArgList &args);
278  const CGFunctionInfo &
279  arrangeBuiltinFunctionDeclaration(CanQualType resultType,
280                                    ArrayRef<CanQualType> argTypes);
281  const CGFunctionInfo &arrangeBuiltinFunctionCall(QualType resultType,
282                                                   const CallArgList &args);
283
284  /// Objective-C methods are C functions with some implicit parameters.
285  const CGFunctionInfo &arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD);
286  const CGFunctionInfo &arrangeObjCMessageSendSignature(const ObjCMethodDecl *MD,
287                                                        QualType receiverType);
288  const CGFunctionInfo &arrangeUnprototypedObjCMessageSend(
289                                                     QualType returnType,
290                                                     const CallArgList &args);
291
292  /// Block invocation functions are C functions with an implicit parameter.
293  const CGFunctionInfo &arrangeBlockFunctionDeclaration(
294                                                 const FunctionProtoType *type,
295                                                 const FunctionArgList &args);
296  const CGFunctionInfo &arrangeBlockFunctionCall(const CallArgList &args,
297                                                 const FunctionType *type);
298
299  /// C++ methods have some special rules and also have implicit parameters.
300  const CGFunctionInfo &arrangeCXXMethodDeclaration(const CXXMethodDecl *MD);
301  const CGFunctionInfo &arrangeCXXStructorDeclaration(const CXXMethodDecl *MD,
302                                                      StructorType Type);
303  const CGFunctionInfo &arrangeCXXConstructorCall(const CallArgList &Args,
304                                                  const CXXConstructorDecl *D,
305                                                  CXXCtorType CtorKind,
306                                                  unsigned ExtraArgs);
307
308  const CGFunctionInfo &arrangeCXXMethodCall(const CallArgList &args,
309                                             const FunctionProtoType *type,
310                                             RequiredArgs required);
311  const CGFunctionInfo &arrangeMSMemberPointerThunk(const CXXMethodDecl *MD);
312  const CGFunctionInfo &arrangeMSCtorClosure(const CXXConstructorDecl *CD,
313                                                 CXXCtorType CT);
314  const CGFunctionInfo &arrangeCXXMethodType(const CXXRecordDecl *RD,
315                                             const FunctionProtoType *FTP,
316                                             const CXXMethodDecl *MD);
317
318  /// "Arrange" the LLVM information for a call or type with the given
319  /// signature.  This is largely an internal method; other clients
320  /// should use one of the above routines, which ultimately defer to
321  /// this.
322  ///
323  /// \param argTypes - must all actually be canonical as params
324  const CGFunctionInfo &arrangeLLVMFunctionInfo(CanQualType returnType,
325                                                bool instanceMethod,
326                                                bool chainCall,
327                                                ArrayRef<CanQualType> argTypes,
328                                                FunctionType::ExtInfo info,
329                    ArrayRef<FunctionProtoType::ExtParameterInfo> paramInfos,
330                                                RequiredArgs args);
331
332  /// \brief Compute a new LLVM record layout object for the given record.
333  CGRecordLayout *ComputeRecordLayout(const RecordDecl *D,
334                                      llvm::StructType *Ty);
335
336  /// addRecordTypeName - Compute a name from the given record decl with an
337  /// optional suffix and name the given LLVM type using it.
338  void addRecordTypeName(const RecordDecl *RD, llvm::StructType *Ty,
339                         StringRef suffix);
340
341
342public:  // These are internal details of CGT that shouldn't be used externally.
343  /// ConvertRecordDeclType - Lay out a tagged decl type like struct or union.
344  llvm::StructType *ConvertRecordDeclType(const RecordDecl *TD);
345
346  /// getExpandedTypes - Expand the type \arg Ty into the LLVM
347  /// argument types it would be passed as. See ABIArgInfo::Expand.
348  void getExpandedTypes(QualType Ty,
349                        SmallVectorImpl<llvm::Type *>::iterator &TI);
350
351  /// IsZeroInitializable - Return whether a type can be
352  /// zero-initialized (in the C++ sense) with an LLVM zeroinitializer.
353  bool isZeroInitializable(QualType T);
354
355  /// IsZeroInitializable - Return whether a record type can be
356  /// zero-initialized (in the C++ sense) with an LLVM zeroinitializer.
357  bool isZeroInitializable(const RecordDecl *RD);
358
359  bool isRecordLayoutComplete(const Type *Ty) const;
360  bool noRecordsBeingLaidOut() const {
361    return RecordsBeingLaidOut.empty();
362  }
363  bool isRecordBeingLaidOut(const Type *Ty) const {
364    return RecordsBeingLaidOut.count(Ty);
365  }
366
367};
368
369}  // end namespace CodeGen
370}  // end namespace clang
371
372#endif
373