CodeGenTypes.h source code [clang_source_code/lib/CodeGen/CodeGenTypes.h]

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