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