Bug Summary

File:clang/lib/CodeGen/CGObjCMac.cpp
Warning:line 2644, column 26
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGObjCMac.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/CodeGen -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D CLANG_ROUND_TRIP_CC1_ARGS=ON -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-08-28-193554-24367-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp

/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp

1//===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===//
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 provides Objective-C code generation targeting the Apple runtime.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CGBlocks.h"
14#include "CGCleanup.h"
15#include "CGObjCRuntime.h"
16#include "CGRecordLayout.h"
17#include "CodeGenFunction.h"
18#include "CodeGenModule.h"
19#include "clang/AST/ASTContext.h"
20#include "clang/AST/Attr.h"
21#include "clang/AST/Decl.h"
22#include "clang/AST/DeclObjC.h"
23#include "clang/AST/Mangle.h"
24#include "clang/AST/RecordLayout.h"
25#include "clang/AST/StmtObjC.h"
26#include "clang/Basic/CodeGenOptions.h"
27#include "clang/Basic/LangOptions.h"
28#include "clang/CodeGen/CGFunctionInfo.h"
29#include "clang/CodeGen/ConstantInitBuilder.h"
30#include "llvm/ADT/CachedHashString.h"
31#include "llvm/ADT/DenseSet.h"
32#include "llvm/ADT/SetVector.h"
33#include "llvm/ADT/SmallPtrSet.h"
34#include "llvm/ADT/SmallString.h"
35#include "llvm/ADT/UniqueVector.h"
36#include "llvm/IR/DataLayout.h"
37#include "llvm/IR/InlineAsm.h"
38#include "llvm/IR/IntrinsicInst.h"
39#include "llvm/IR/LLVMContext.h"
40#include "llvm/IR/Module.h"
41#include "llvm/Support/ScopedPrinter.h"
42#include "llvm/Support/raw_ostream.h"
43#include <cstdio>
44
45using namespace clang;
46using namespace CodeGen;
47
48namespace {
49
50// FIXME: We should find a nicer way to make the labels for metadata, string
51// concatenation is lame.
52
53class ObjCCommonTypesHelper {
54protected:
55 llvm::LLVMContext &VMContext;
56
57private:
58 // The types of these functions don't really matter because we
59 // should always bitcast before calling them.
60
61 /// id objc_msgSend (id, SEL, ...)
62 ///
63 /// The default messenger, used for sends whose ABI is unchanged from
64 /// the all-integer/pointer case.
65 llvm::FunctionCallee getMessageSendFn() const {
66 // Add the non-lazy-bind attribute, since objc_msgSend is likely to
67 // be called a lot.
68 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
69 return CGM.CreateRuntimeFunction(
70 llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend",
71 llvm::AttributeList::get(CGM.getLLVMContext(),
72 llvm::AttributeList::FunctionIndex,
73 llvm::Attribute::NonLazyBind));
74 }
75
76 /// void objc_msgSend_stret (id, SEL, ...)
77 ///
78 /// The messenger used when the return value is an aggregate returned
79 /// by indirect reference in the first argument, and therefore the
80 /// self and selector parameters are shifted over by one.
81 llvm::FunctionCallee getMessageSendStretFn() const {
82 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
83 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
84 params, true),
85 "objc_msgSend_stret");
86 }
87
88 /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
89 ///
90 /// The messenger used when the return value is returned on the x87
91 /// floating-point stack; without a special entrypoint, the nil case
92 /// would be unbalanced.
93 llvm::FunctionCallee getMessageSendFpretFn() const {
94 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
95 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
96 params, true),
97 "objc_msgSend_fpret");
98 }
99
100 /// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
101 ///
102 /// The messenger used when the return value is returned in two values on the
103 /// x87 floating point stack; without a special entrypoint, the nil case
104 /// would be unbalanced. Only used on 64-bit X86.
105 llvm::FunctionCallee getMessageSendFp2retFn() const {
106 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
107 llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext);
108 llvm::Type *resultType =
109 llvm::StructType::get(longDoubleType, longDoubleType);
110
111 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType,
112 params, true),
113 "objc_msgSend_fp2ret");
114 }
115
116 /// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
117 ///
118 /// The messenger used for super calls, which have different dispatch
119 /// semantics. The class passed is the superclass of the current
120 /// class.
121 llvm::FunctionCallee getMessageSendSuperFn() const {
122 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
123 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
124 params, true),
125 "objc_msgSendSuper");
126 }
127
128 /// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
129 ///
130 /// A slightly different messenger used for super calls. The class
131 /// passed is the current class.
132 llvm::FunctionCallee getMessageSendSuperFn2() const {
133 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
134 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
135 params, true),
136 "objc_msgSendSuper2");
137 }
138
139 /// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super,
140 /// SEL op, ...)
141 ///
142 /// The messenger used for super calls which return an aggregate indirectly.
143 llvm::FunctionCallee getMessageSendSuperStretFn() const {
144 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
145 return CGM.CreateRuntimeFunction(
146 llvm::FunctionType::get(CGM.VoidTy, params, true),
147 "objc_msgSendSuper_stret");
148 }
149
150 /// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
151 /// SEL op, ...)
152 ///
153 /// objc_msgSendSuper_stret with the super2 semantics.
154 llvm::FunctionCallee getMessageSendSuperStretFn2() const {
155 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
156 return CGM.CreateRuntimeFunction(
157 llvm::FunctionType::get(CGM.VoidTy, params, true),
158 "objc_msgSendSuper2_stret");
159 }
160
161 llvm::FunctionCallee getMessageSendSuperFpretFn() const {
162 // There is no objc_msgSendSuper_fpret? How can that work?
163 return getMessageSendSuperFn();
164 }
165
166 llvm::FunctionCallee getMessageSendSuperFpretFn2() const {
167 // There is no objc_msgSendSuper_fpret? How can that work?
168 return getMessageSendSuperFn2();
169 }
170
171protected:
172 CodeGen::CodeGenModule &CGM;
173
174public:
175 llvm::IntegerType *ShortTy, *IntTy, *LongTy;
176 llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy;
177 llvm::Type *IvarOffsetVarTy;
178
179 /// ObjectPtrTy - LLVM type for object handles (typeof(id))
180 llvm::PointerType *ObjectPtrTy;
181
182 /// PtrObjectPtrTy - LLVM type for id *
183 llvm::PointerType *PtrObjectPtrTy;
184
185 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
186 llvm::PointerType *SelectorPtrTy;
187
188private:
189 /// ProtocolPtrTy - LLVM type for external protocol handles
190 /// (typeof(Protocol))
191 llvm::Type *ExternalProtocolPtrTy;
192
193public:
194 llvm::Type *getExternalProtocolPtrTy() {
195 if (!ExternalProtocolPtrTy) {
196 // FIXME: It would be nice to unify this with the opaque type, so that the
197 // IR comes out a bit cleaner.
198 CodeGen::CodeGenTypes &Types = CGM.getTypes();
199 ASTContext &Ctx = CGM.getContext();
200 llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
201 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
202 }
203
204 return ExternalProtocolPtrTy;
205 }
206
207 // SuperCTy - clang type for struct objc_super.
208 QualType SuperCTy;
209 // SuperPtrCTy - clang type for struct objc_super *.
210 QualType SuperPtrCTy;
211
212 /// SuperTy - LLVM type for struct objc_super.
213 llvm::StructType *SuperTy;
214 /// SuperPtrTy - LLVM type for struct objc_super *.
215 llvm::PointerType *SuperPtrTy;
216
217 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
218 /// in GCC parlance).
219 llvm::StructType *PropertyTy;
220
221 /// PropertyListTy - LLVM type for struct objc_property_list
222 /// (_prop_list_t in GCC parlance).
223 llvm::StructType *PropertyListTy;
224 /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
225 llvm::PointerType *PropertyListPtrTy;
226
227 // MethodTy - LLVM type for struct objc_method.
228 llvm::StructType *MethodTy;
229
230 /// CacheTy - LLVM type for struct objc_cache.
231 llvm::Type *CacheTy;
232 /// CachePtrTy - LLVM type for struct objc_cache *.
233 llvm::PointerType *CachePtrTy;
234
235 llvm::FunctionCallee getGetPropertyFn() {
236 CodeGen::CodeGenTypes &Types = CGM.getTypes();
237 ASTContext &Ctx = CGM.getContext();
238 // id objc_getProperty (id, SEL, ptrdiff_t, bool)
239 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
240 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
241 CanQualType Params[] = {
242 IdType, SelType,
243 Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), Ctx.BoolTy};
244 llvm::FunctionType *FTy =
245 Types.GetFunctionType(
246 Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
247 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
248 }
249
250 llvm::FunctionCallee getSetPropertyFn() {
251 CodeGen::CodeGenTypes &Types = CGM.getTypes();
252 ASTContext &Ctx = CGM.getContext();
253 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
254 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
255 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
256 CanQualType Params[] = {
257 IdType,
258 SelType,
259 Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(),
260 IdType,
261 Ctx.BoolTy,
262 Ctx.BoolTy};
263 llvm::FunctionType *FTy =
264 Types.GetFunctionType(
265 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
266 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
267 }
268
269 llvm::FunctionCallee getOptimizedSetPropertyFn(bool atomic, bool copy) {
270 CodeGen::CodeGenTypes &Types = CGM.getTypes();
271 ASTContext &Ctx = CGM.getContext();
272 // void objc_setProperty_atomic(id self, SEL _cmd,
273 // id newValue, ptrdiff_t offset);
274 // void objc_setProperty_nonatomic(id self, SEL _cmd,
275 // id newValue, ptrdiff_t offset);
276 // void objc_setProperty_atomic_copy(id self, SEL _cmd,
277 // id newValue, ptrdiff_t offset);
278 // void objc_setProperty_nonatomic_copy(id self, SEL _cmd,
279 // id newValue, ptrdiff_t offset);
280
281 SmallVector<CanQualType,4> Params;
282 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
283 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
284 Params.push_back(IdType);
285 Params.push_back(SelType);
286 Params.push_back(IdType);
287 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
288 llvm::FunctionType *FTy =
289 Types.GetFunctionType(
290 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
291 const char *name;
292 if (atomic && copy)
293 name = "objc_setProperty_atomic_copy";
294 else if (atomic && !copy)
295 name = "objc_setProperty_atomic";
296 else if (!atomic && copy)
297 name = "objc_setProperty_nonatomic_copy";
298 else
299 name = "objc_setProperty_nonatomic";
300
301 return CGM.CreateRuntimeFunction(FTy, name);
302 }
303
304 llvm::FunctionCallee getCopyStructFn() {
305 CodeGen::CodeGenTypes &Types = CGM.getTypes();
306 ASTContext &Ctx = CGM.getContext();
307 // void objc_copyStruct (void *, const void *, size_t, bool, bool)
308 SmallVector<CanQualType,5> Params;
309 Params.push_back(Ctx.VoidPtrTy);
310 Params.push_back(Ctx.VoidPtrTy);
311 Params.push_back(Ctx.getSizeType());
312 Params.push_back(Ctx.BoolTy);
313 Params.push_back(Ctx.BoolTy);
314 llvm::FunctionType *FTy =
315 Types.GetFunctionType(
316 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
317 return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
318 }
319
320 /// This routine declares and returns address of:
321 /// void objc_copyCppObjectAtomic(
322 /// void *dest, const void *src,
323 /// void (*copyHelper) (void *dest, const void *source));
324 llvm::FunctionCallee getCppAtomicObjectFunction() {
325 CodeGen::CodeGenTypes &Types = CGM.getTypes();
326 ASTContext &Ctx = CGM.getContext();
327 /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
328 SmallVector<CanQualType,3> Params;
329 Params.push_back(Ctx.VoidPtrTy);
330 Params.push_back(Ctx.VoidPtrTy);
331 Params.push_back(Ctx.VoidPtrTy);
332 llvm::FunctionType *FTy =
333 Types.GetFunctionType(
334 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
335 return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
336 }
337
338 llvm::FunctionCallee getEnumerationMutationFn() {
339 CodeGen::CodeGenTypes &Types = CGM.getTypes();
340 ASTContext &Ctx = CGM.getContext();
341 // void objc_enumerationMutation (id)
342 SmallVector<CanQualType,1> Params;
343 Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
344 llvm::FunctionType *FTy =
345 Types.GetFunctionType(
346 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
347 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
348 }
349
350 llvm::FunctionCallee getLookUpClassFn() {
351 CodeGen::CodeGenTypes &Types = CGM.getTypes();
352 ASTContext &Ctx = CGM.getContext();
353 // Class objc_lookUpClass (const char *)
354 SmallVector<CanQualType,1> Params;
355 Params.push_back(
356 Ctx.getCanonicalType(Ctx.getPointerType(Ctx.CharTy.withConst())));
357 llvm::FunctionType *FTy =
358 Types.GetFunctionType(Types.arrangeBuiltinFunctionDeclaration(
359 Ctx.getCanonicalType(Ctx.getObjCClassType()),
360 Params));
361 return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass");
362 }
363
364 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
365 llvm::FunctionCallee getGcReadWeakFn() {
366 // id objc_read_weak (id *)
367 llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
368 llvm::FunctionType *FTy =
369 llvm::FunctionType::get(ObjectPtrTy, args, false);
370 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
371 }
372
373 /// GcAssignWeakFn -- LLVM objc_assign_weak function.
374 llvm::FunctionCallee getGcAssignWeakFn() {
375 // id objc_assign_weak (id, id *)
376 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
377 llvm::FunctionType *FTy =
378 llvm::FunctionType::get(ObjectPtrTy, args, false);
379 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
380 }
381
382 /// GcAssignGlobalFn -- LLVM objc_assign_global function.
383 llvm::FunctionCallee getGcAssignGlobalFn() {
384 // id objc_assign_global(id, id *)
385 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
386 llvm::FunctionType *FTy =
387 llvm::FunctionType::get(ObjectPtrTy, args, false);
388 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
389 }
390
391 /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
392 llvm::FunctionCallee getGcAssignThreadLocalFn() {
393 // id objc_assign_threadlocal(id src, id * dest)
394 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
395 llvm::FunctionType *FTy =
396 llvm::FunctionType::get(ObjectPtrTy, args, false);
397 return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
398 }
399
400 /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
401 llvm::FunctionCallee getGcAssignIvarFn() {
402 // id objc_assign_ivar(id, id *, ptrdiff_t)
403 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
404 CGM.PtrDiffTy };
405 llvm::FunctionType *FTy =
406 llvm::FunctionType::get(ObjectPtrTy, args, false);
407 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
408 }
409
410 /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
411 llvm::FunctionCallee GcMemmoveCollectableFn() {
412 // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
413 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
414 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
415 return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
416 }
417
418 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
419 llvm::FunctionCallee getGcAssignStrongCastFn() {
420 // id objc_assign_strongCast(id, id *)
421 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
422 llvm::FunctionType *FTy =
423 llvm::FunctionType::get(ObjectPtrTy, args, false);
424 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
425 }
426
427 /// ExceptionThrowFn - LLVM objc_exception_throw function.
428 llvm::FunctionCallee getExceptionThrowFn() {
429 // void objc_exception_throw(id)
430 llvm::Type *args[] = { ObjectPtrTy };
431 llvm::FunctionType *FTy =
432 llvm::FunctionType::get(CGM.VoidTy, args, false);
433 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
434 }
435
436 /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
437 llvm::FunctionCallee getExceptionRethrowFn() {
438 // void objc_exception_rethrow(void)
439 llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
440 return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
441 }
442
443 /// SyncEnterFn - LLVM object_sync_enter function.
444 llvm::FunctionCallee getSyncEnterFn() {
445 // int objc_sync_enter (id)
446 llvm::Type *args[] = { ObjectPtrTy };
447 llvm::FunctionType *FTy =
448 llvm::FunctionType::get(CGM.IntTy, args, false);
449 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
450 }
451
452 /// SyncExitFn - LLVM object_sync_exit function.
453 llvm::FunctionCallee getSyncExitFn() {
454 // int objc_sync_exit (id)
455 llvm::Type *args[] = { ObjectPtrTy };
456 llvm::FunctionType *FTy =
457 llvm::FunctionType::get(CGM.IntTy, args, false);
458 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
459 }
460
461 llvm::FunctionCallee getSendFn(bool IsSuper) const {
462 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
463 }
464
465 llvm::FunctionCallee getSendFn2(bool IsSuper) const {
466 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
467 }
468
469 llvm::FunctionCallee getSendStretFn(bool IsSuper) const {
470 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
471 }
472
473 llvm::FunctionCallee getSendStretFn2(bool IsSuper) const {
474 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
475 }
476
477 llvm::FunctionCallee getSendFpretFn(bool IsSuper) const {
478 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
479 }
480
481 llvm::FunctionCallee getSendFpretFn2(bool IsSuper) const {
482 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
483 }
484
485 llvm::FunctionCallee getSendFp2retFn(bool IsSuper) const {
486 return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
487 }
488
489 llvm::FunctionCallee getSendFp2RetFn2(bool IsSuper) const {
490 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn();
491 }
492
493 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
494};
495
496/// ObjCTypesHelper - Helper class that encapsulates lazy
497/// construction of varies types used during ObjC generation.
498class ObjCTypesHelper : public ObjCCommonTypesHelper {
499public:
500 /// SymtabTy - LLVM type for struct objc_symtab.
501 llvm::StructType *SymtabTy;
502 /// SymtabPtrTy - LLVM type for struct objc_symtab *.
503 llvm::PointerType *SymtabPtrTy;
504 /// ModuleTy - LLVM type for struct objc_module.
505 llvm::StructType *ModuleTy;
506
507 /// ProtocolTy - LLVM type for struct objc_protocol.
508 llvm::StructType *ProtocolTy;
509 /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
510 llvm::PointerType *ProtocolPtrTy;
511 /// ProtocolExtensionTy - LLVM type for struct
512 /// objc_protocol_extension.
513 llvm::StructType *ProtocolExtensionTy;
514 /// ProtocolExtensionTy - LLVM type for struct
515 /// objc_protocol_extension *.
516 llvm::PointerType *ProtocolExtensionPtrTy;
517 /// MethodDescriptionTy - LLVM type for struct
518 /// objc_method_description.
519 llvm::StructType *MethodDescriptionTy;
520 /// MethodDescriptionListTy - LLVM type for struct
521 /// objc_method_description_list.
522 llvm::StructType *MethodDescriptionListTy;
523 /// MethodDescriptionListPtrTy - LLVM type for struct
524 /// objc_method_description_list *.
525 llvm::PointerType *MethodDescriptionListPtrTy;
526 /// ProtocolListTy - LLVM type for struct objc_property_list.
527 llvm::StructType *ProtocolListTy;
528 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
529 llvm::PointerType *ProtocolListPtrTy;
530 /// CategoryTy - LLVM type for struct objc_category.
531 llvm::StructType *CategoryTy;
532 /// ClassTy - LLVM type for struct objc_class.
533 llvm::StructType *ClassTy;
534 /// ClassPtrTy - LLVM type for struct objc_class *.
535 llvm::PointerType *ClassPtrTy;
536 /// ClassExtensionTy - LLVM type for struct objc_class_ext.
537 llvm::StructType *ClassExtensionTy;
538 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
539 llvm::PointerType *ClassExtensionPtrTy;
540 // IvarTy - LLVM type for struct objc_ivar.
541 llvm::StructType *IvarTy;
542 /// IvarListTy - LLVM type for struct objc_ivar_list.
543 llvm::StructType *IvarListTy;
544 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
545 llvm::PointerType *IvarListPtrTy;
546 /// MethodListTy - LLVM type for struct objc_method_list.
547 llvm::StructType *MethodListTy;
548 /// MethodListPtrTy - LLVM type for struct objc_method_list *.
549 llvm::PointerType *MethodListPtrTy;
550
551 /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
552 llvm::StructType *ExceptionDataTy;
553
554 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
555 llvm::FunctionCallee getExceptionTryEnterFn() {
556 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
557 return CGM.CreateRuntimeFunction(
558 llvm::FunctionType::get(CGM.VoidTy, params, false),
559 "objc_exception_try_enter");
560 }
561
562 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
563 llvm::FunctionCallee getExceptionTryExitFn() {
564 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
565 return CGM.CreateRuntimeFunction(
566 llvm::FunctionType::get(CGM.VoidTy, params, false),
567 "objc_exception_try_exit");
568 }
569
570 /// ExceptionExtractFn - LLVM objc_exception_extract function.
571 llvm::FunctionCallee getExceptionExtractFn() {
572 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
573 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
574 params, false),
575 "objc_exception_extract");
576 }
577
578 /// ExceptionMatchFn - LLVM objc_exception_match function.
579 llvm::FunctionCallee getExceptionMatchFn() {
580 llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
581 return CGM.CreateRuntimeFunction(
582 llvm::FunctionType::get(CGM.Int32Ty, params, false),
583 "objc_exception_match");
584 }
585
586 /// SetJmpFn - LLVM _setjmp function.
587 llvm::FunctionCallee getSetJmpFn() {
588 // This is specifically the prototype for x86.
589 llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
590 return CGM.CreateRuntimeFunction(
591 llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp",
592 llvm::AttributeList::get(CGM.getLLVMContext(),
593 llvm::AttributeList::FunctionIndex,
594 llvm::Attribute::NonLazyBind));
595 }
596
597public:
598 ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
599};
600
601/// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
602/// modern abi
603class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
604public:
605 // MethodListnfABITy - LLVM for struct _method_list_t
606 llvm::StructType *MethodListnfABITy;
607
608 // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
609 llvm::PointerType *MethodListnfABIPtrTy;
610
611 // ProtocolnfABITy = LLVM for struct _protocol_t
612 llvm::StructType *ProtocolnfABITy;
613
614 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
615 llvm::PointerType *ProtocolnfABIPtrTy;
616
617 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
618 llvm::StructType *ProtocolListnfABITy;
619
620 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
621 llvm::PointerType *ProtocolListnfABIPtrTy;
622
623 // ClassnfABITy - LLVM for struct _class_t
624 llvm::StructType *ClassnfABITy;
625
626 // ClassnfABIPtrTy - LLVM for struct _class_t*
627 llvm::PointerType *ClassnfABIPtrTy;
628
629 // IvarnfABITy - LLVM for struct _ivar_t
630 llvm::StructType *IvarnfABITy;
631
632 // IvarListnfABITy - LLVM for struct _ivar_list_t
633 llvm::StructType *IvarListnfABITy;
634
635 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
636 llvm::PointerType *IvarListnfABIPtrTy;
637
638 // ClassRonfABITy - LLVM for struct _class_ro_t
639 llvm::StructType *ClassRonfABITy;
640
641 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
642 llvm::PointerType *ImpnfABITy;
643
644 // CategorynfABITy - LLVM for struct _category_t
645 llvm::StructType *CategorynfABITy;
646
647 // New types for nonfragile abi messaging.
648
649 // MessageRefTy - LLVM for:
650 // struct _message_ref_t {
651 // IMP messenger;
652 // SEL name;
653 // };
654 llvm::StructType *MessageRefTy;
655 // MessageRefCTy - clang type for struct _message_ref_t
656 QualType MessageRefCTy;
657
658 // MessageRefPtrTy - LLVM for struct _message_ref_t*
659 llvm::Type *MessageRefPtrTy;
660 // MessageRefCPtrTy - clang type for struct _message_ref_t*
661 QualType MessageRefCPtrTy;
662
663 // SuperMessageRefTy - LLVM for:
664 // struct _super_message_ref_t {
665 // SUPER_IMP messenger;
666 // SEL name;
667 // };
668 llvm::StructType *SuperMessageRefTy;
669
670 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
671 llvm::PointerType *SuperMessageRefPtrTy;
672
673 llvm::FunctionCallee getMessageSendFixupFn() {
674 // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
675 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
676 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
677 params, true),
678 "objc_msgSend_fixup");
679 }
680
681 llvm::FunctionCallee getMessageSendFpretFixupFn() {
682 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
683 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
684 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
685 params, true),
686 "objc_msgSend_fpret_fixup");
687 }
688
689 llvm::FunctionCallee getMessageSendStretFixupFn() {
690 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
691 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
692 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
693 params, true),
694 "objc_msgSend_stret_fixup");
695 }
696
697 llvm::FunctionCallee getMessageSendSuper2FixupFn() {
698 // id objc_msgSendSuper2_fixup (struct objc_super *,
699 // struct _super_message_ref_t*, ...)
700 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
701 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
702 params, true),
703 "objc_msgSendSuper2_fixup");
704 }
705
706 llvm::FunctionCallee getMessageSendSuper2StretFixupFn() {
707 // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
708 // struct _super_message_ref_t*, ...)
709 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
710 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
711 params, true),
712 "objc_msgSendSuper2_stret_fixup");
713 }
714
715 llvm::FunctionCallee getObjCEndCatchFn() {
716 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
717 "objc_end_catch");
718 }
719
720 llvm::FunctionCallee getObjCBeginCatchFn() {
721 llvm::Type *params[] = { Int8PtrTy };
722 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
723 params, false),
724 "objc_begin_catch");
725 }
726
727 /// Class objc_loadClassref (void *)
728 ///
729 /// Loads from a classref. For Objective-C stub classes, this invokes the
730 /// initialization callback stored inside the stub. For all other classes
731 /// this simply dereferences the pointer.
732 llvm::FunctionCallee getLoadClassrefFn() const {
733 // Add the non-lazy-bind attribute, since objc_loadClassref is likely to
734 // be called a lot.
735 //
736 // Also it is safe to make it readnone, since we never load or store the
737 // classref except by calling this function.
738 llvm::Type *params[] = { Int8PtrPtrTy };
739 llvm::FunctionCallee F = CGM.CreateRuntimeFunction(
740 llvm::FunctionType::get(ClassnfABIPtrTy, params, false),
741 "objc_loadClassref",
742 llvm::AttributeList::get(CGM.getLLVMContext(),
743 llvm::AttributeList::FunctionIndex,
744 {llvm::Attribute::NonLazyBind,
745 llvm::Attribute::ReadNone,
746 llvm::Attribute::NoUnwind}));
747 if (!CGM.getTriple().isOSBinFormatCOFF())
748 cast<llvm::Function>(F.getCallee())->setLinkage(
749 llvm::Function::ExternalWeakLinkage);
750
751 return F;
752 }
753
754 llvm::StructType *EHTypeTy;
755 llvm::Type *EHTypePtrTy;
756
757 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
758};
759
760enum class ObjCLabelType {
761 ClassName,
762 MethodVarName,
763 MethodVarType,
764 PropertyName,
765};
766
767class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
768public:
769 class SKIP_SCAN {
770 public:
771 unsigned skip;
772 unsigned scan;
773 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
774 : skip(_skip), scan(_scan) {}
775 };
776
777 /// opcode for captured block variables layout 'instructions'.
778 /// In the following descriptions, 'I' is the value of the immediate field.
779 /// (field following the opcode).
780 ///
781 enum BLOCK_LAYOUT_OPCODE {
782 /// An operator which affects how the following layout should be
783 /// interpreted.
784 /// I == 0: Halt interpretation and treat everything else as
785 /// a non-pointer. Note that this instruction is equal
786 /// to '\0'.
787 /// I != 0: Currently unused.
788 BLOCK_LAYOUT_OPERATOR = 0,
789
790 /// The next I+1 bytes do not contain a value of object pointer type.
791 /// Note that this can leave the stream unaligned, meaning that
792 /// subsequent word-size instructions do not begin at a multiple of
793 /// the pointer size.
794 BLOCK_LAYOUT_NON_OBJECT_BYTES = 1,
795
796 /// The next I+1 words do not contain a value of object pointer type.
797 /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
798 /// when the required skip quantity is a multiple of the pointer size.
799 BLOCK_LAYOUT_NON_OBJECT_WORDS = 2,
800
801 /// The next I+1 words are __strong pointers to Objective-C
802 /// objects or blocks.
803 BLOCK_LAYOUT_STRONG = 3,
804
805 /// The next I+1 words are pointers to __block variables.
806 BLOCK_LAYOUT_BYREF = 4,
807
808 /// The next I+1 words are __weak pointers to Objective-C
809 /// objects or blocks.
810 BLOCK_LAYOUT_WEAK = 5,
811
812 /// The next I+1 words are __unsafe_unretained pointers to
813 /// Objective-C objects or blocks.
814 BLOCK_LAYOUT_UNRETAINED = 6
815
816 /// The next I+1 words are block or object pointers with some
817 /// as-yet-unspecified ownership semantics. If we add more
818 /// flavors of ownership semantics, values will be taken from
819 /// this range.
820 ///
821 /// This is included so that older tools can at least continue
822 /// processing the layout past such things.
823 //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
824
825 /// All other opcodes are reserved. Halt interpretation and
826 /// treat everything else as opaque.
827 };
828
829 class RUN_SKIP {
830 public:
831 enum BLOCK_LAYOUT_OPCODE opcode;
832 CharUnits block_var_bytepos;
833 CharUnits block_var_size;
834 RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
835 CharUnits BytePos = CharUnits::Zero(),
836 CharUnits Size = CharUnits::Zero())
837 : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {}
838
839 // Allow sorting based on byte pos.
840 bool operator<(const RUN_SKIP &b) const {
841 return block_var_bytepos < b.block_var_bytepos;
842 }
843 };
844
845protected:
846 llvm::LLVMContext &VMContext;
847 // FIXME! May not be needing this after all.
848 unsigned ObjCABI;
849
850 // arc/mrr layout of captured block literal variables.
851 SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
852
853 /// LazySymbols - Symbols to generate a lazy reference for. See
854 /// DefinedSymbols and FinishModule().
855 llvm::SetVector<IdentifierInfo*> LazySymbols;
856
857 /// DefinedSymbols - External symbols which are defined by this
858 /// module. The symbols in this list and LazySymbols are used to add
859 /// special linker symbols which ensure that Objective-C modules are
860 /// linked properly.
861 llvm::SetVector<IdentifierInfo*> DefinedSymbols;
862
863 /// ClassNames - uniqued class names.
864 llvm::StringMap<llvm::GlobalVariable*> ClassNames;
865
866 /// MethodVarNames - uniqued method variable names.
867 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
868
869 /// DefinedCategoryNames - list of category names in form Class_Category.
870 llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames;
871
872 /// MethodVarTypes - uniqued method type signatures. We have to use
873 /// a StringMap here because have no other unique reference.
874 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
875
876 /// MethodDefinitions - map of methods which have been defined in
877 /// this translation unit.
878 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
879
880 /// DirectMethodDefinitions - map of direct methods which have been defined in
881 /// this translation unit.
882 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> DirectMethodDefinitions;
883
884 /// PropertyNames - uniqued method variable names.
885 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
886
887 /// ClassReferences - uniqued class references.
888 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
889
890 /// SelectorReferences - uniqued selector references.
891 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
892
893 /// Protocols - Protocols for which an objc_protocol structure has
894 /// been emitted. Forward declarations are handled by creating an
895 /// empty structure whose initializer is filled in when/if defined.
896 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
897
898 /// DefinedProtocols - Protocols which have actually been
899 /// defined. We should not need this, see FIXME in GenerateProtocol.
900 llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
901
902 /// DefinedClasses - List of defined classes.
903 SmallVector<llvm::GlobalValue*, 16> DefinedClasses;
904
905 /// ImplementedClasses - List of @implemented classes.
906 SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses;
907
908 /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
909 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
910
911 /// DefinedCategories - List of defined categories.
912 SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
913
914 /// DefinedStubCategories - List of defined categories on class stubs.
915 SmallVector<llvm::GlobalValue*, 16> DefinedStubCategories;
916
917 /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
918 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
919
920 /// Cached reference to the class for constant strings. This value has type
921 /// int * but is actually an Obj-C class pointer.
922 llvm::WeakTrackingVH ConstantStringClassRef;
923
924 /// The LLVM type corresponding to NSConstantString.
925 llvm::StructType *NSConstantStringType = nullptr;
926
927 llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap;
928
929 /// GetMethodVarName - Return a unique constant for the given
930 /// selector's name. The return value has type char *.
931 llvm::Constant *GetMethodVarName(Selector Sel);
932 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
933
934 /// GetMethodVarType - Return a unique constant for the given
935 /// method's type encoding string. The return value has type char *.
936
937 // FIXME: This is a horrible name.
938 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
939 bool Extended = false);
940 llvm::Constant *GetMethodVarType(const FieldDecl *D);
941
942 /// GetPropertyName - Return a unique constant for the given
943 /// name. The return value has type char *.
944 llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
945
946 // FIXME: This can be dropped once string functions are unified.
947 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
948 const Decl *Container);
949
950 /// GetClassName - Return a unique constant for the given selector's
951 /// runtime name (which may change via use of objc_runtime_name attribute on
952 /// class or protocol definition. The return value has type char *.
953 llvm::Constant *GetClassName(StringRef RuntimeName);
954
955 llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
956
957 /// BuildIvarLayout - Builds ivar layout bitmap for the class
958 /// implementation for the __strong or __weak case.
959 ///
960 /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there
961 /// are any weak ivars defined directly in the class. Meaningless unless
962 /// building a weak layout. Does not guarantee that the layout will
963 /// actually have any entries, because the ivar might be under-aligned.
964 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
965 CharUnits beginOffset,
966 CharUnits endOffset,
967 bool forStrongLayout,
968 bool hasMRCWeakIvars);
969
970 llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,
971 CharUnits beginOffset,
972 CharUnits endOffset) {
973 return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
974 }
975
976 llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
977 CharUnits beginOffset,
978 CharUnits endOffset,
979 bool hasMRCWeakIvars) {
980 return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
981 }
982
983 Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
984
985 void UpdateRunSkipBlockVars(bool IsByref,
986 Qualifiers::ObjCLifetime LifeTime,
987 CharUnits FieldOffset,
988 CharUnits FieldSize);
989
990 void BuildRCBlockVarRecordLayout(const RecordType *RT,
991 CharUnits BytePos, bool &HasUnion,
992 bool ByrefLayout=false);
993
994 void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
995 const RecordDecl *RD,
996 ArrayRef<const FieldDecl*> RecFields,
997 CharUnits BytePos, bool &HasUnion,
998 bool ByrefLayout);
999
1000 uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
1001
1002 llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
1003
1004 /// GetIvarLayoutName - Returns a unique constant for the given
1005 /// ivar layout bitmap.
1006 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
1007 const ObjCCommonTypesHelper &ObjCTypes);
1008
1009 /// EmitPropertyList - Emit the given property list. The return
1010 /// value has type PropertyListPtrTy.
1011 llvm::Constant *EmitPropertyList(Twine Name,
1012 const Decl *Container,
1013 const ObjCContainerDecl *OCD,
1014 const ObjCCommonTypesHelper &ObjCTypes,
1015 bool IsClassProperty);
1016
1017 /// EmitProtocolMethodTypes - Generate the array of extended method type
1018 /// strings. The return value has type Int8PtrPtrTy.
1019 llvm::Constant *EmitProtocolMethodTypes(Twine Name,
1020 ArrayRef<llvm::Constant*> MethodTypes,
1021 const ObjCCommonTypesHelper &ObjCTypes);
1022
1023 /// GetProtocolRef - Return a reference to the internal protocol
1024 /// description, creating an empty one if it has not been
1025 /// defined. The return value has type ProtocolPtrTy.
1026 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
1027
1028 /// Return a reference to the given Class using runtime calls rather than
1029 /// by a symbol reference.
1030 llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,
1031 const ObjCInterfaceDecl *ID,
1032 ObjCCommonTypesHelper &ObjCTypes);
1033
1034 std::string GetSectionName(StringRef Section, StringRef MachOAttributes);
1035
1036public:
1037 /// CreateMetadataVar - Create a global variable with internal
1038 /// linkage for use by the Objective-C runtime.
1039 ///
1040 /// This is a convenience wrapper which not only creates the
1041 /// variable, but also sets the section and alignment and adds the
1042 /// global to the "llvm.used" list.
1043 ///
1044 /// \param Name - The variable name.
1045 /// \param Init - The variable initializer; this is also used to
1046 /// define the type of the variable.
1047 /// \param Section - The section the variable should go into, or empty.
1048 /// \param Align - The alignment for the variable, or 0.
1049 /// \param AddToUsed - Whether the variable should be added to
1050 /// "llvm.used".
1051 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1052 ConstantStructBuilder &Init,
1053 StringRef Section, CharUnits Align,
1054 bool AddToUsed);
1055 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1056 llvm::Constant *Init,
1057 StringRef Section, CharUnits Align,
1058 bool AddToUsed);
1059
1060 llvm::GlobalVariable *CreateCStringLiteral(StringRef Name,
1061 ObjCLabelType LabelType,
1062 bool ForceNonFragileABI = false,
1063 bool NullTerminate = true);
1064
1065protected:
1066 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1067 ReturnValueSlot Return,
1068 QualType ResultType,
1069 Selector Sel,
1070 llvm::Value *Arg0,
1071 QualType Arg0Ty,
1072 bool IsSuper,
1073 const CallArgList &CallArgs,
1074 const ObjCMethodDecl *OMD,
1075 const ObjCInterfaceDecl *ClassReceiver,
1076 const ObjCCommonTypesHelper &ObjCTypes);
1077
1078 /// EmitImageInfo - Emit the image info marker used to encode some module
1079 /// level information.
1080 void EmitImageInfo();
1081
1082public:
1083 CGObjCCommonMac(CodeGen::CodeGenModule &cgm)
1084 : CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) {}
1085
1086 bool isNonFragileABI() const {
1087 return ObjCABI == 2;
1088 }
1089
1090 ConstantAddress GenerateConstantString(const StringLiteral *SL) override;
1091 ConstantAddress GenerateConstantNSString(const StringLiteral *SL);
1092
1093 llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1094 const ObjCContainerDecl *CD=nullptr) override;
1095
1096 llvm::Function *GenerateDirectMethod(const ObjCMethodDecl *OMD,
1097 const ObjCContainerDecl *CD);
1098
1099 void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn,
1100 const ObjCMethodDecl *OMD,
1101 const ObjCContainerDecl *CD) override;
1102
1103 void GenerateProtocol(const ObjCProtocolDecl *PD) override;
1104
1105 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1106 /// object for the given declaration, emitting it if needed. These
1107 /// forward references will be filled in with empty bodies if no
1108 /// definition is seen. The return value has type ProtocolPtrTy.
1109 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1110
1111 virtual llvm::Constant *getNSConstantStringClassRef() = 0;
1112
1113 llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1114 const CGBlockInfo &blockInfo) override;
1115 llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1116 const CGBlockInfo &blockInfo) override;
1117 std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM,
1118 const CGBlockInfo &blockInfo) override;
1119
1120 llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1121 QualType T) override;
1122
1123private:
1124 void fillRunSkipBlockVars(CodeGenModule &CGM, const CGBlockInfo &blockInfo);
1125};
1126
1127namespace {
1128
1129enum class MethodListType {
1130 CategoryInstanceMethods,
1131 CategoryClassMethods,
1132 InstanceMethods,
1133 ClassMethods,
1134 ProtocolInstanceMethods,
1135 ProtocolClassMethods,
1136 OptionalProtocolInstanceMethods,
1137 OptionalProtocolClassMethods,
1138};
1139
1140/// A convenience class for splitting the methods of a protocol into
1141/// the four interesting groups.
1142class ProtocolMethodLists {
1143public:
1144 enum Kind {
1145 RequiredInstanceMethods,
1146 RequiredClassMethods,
1147 OptionalInstanceMethods,
1148 OptionalClassMethods
1149 };
1150 enum {
1151 NumProtocolMethodLists = 4
1152 };
1153
1154 static MethodListType getMethodListKind(Kind kind) {
1155 switch (kind) {
1156 case RequiredInstanceMethods:
1157 return MethodListType::ProtocolInstanceMethods;
1158 case RequiredClassMethods:
1159 return MethodListType::ProtocolClassMethods;
1160 case OptionalInstanceMethods:
1161 return MethodListType::OptionalProtocolInstanceMethods;
1162 case OptionalClassMethods:
1163 return MethodListType::OptionalProtocolClassMethods;
1164 }
1165 llvm_unreachable("bad kind")::llvm::llvm_unreachable_internal("bad kind", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 1165)
;
1166 }
1167
1168 SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists];
1169
1170 static ProtocolMethodLists get(const ObjCProtocolDecl *PD) {
1171 ProtocolMethodLists result;
1172
1173 for (auto MD : PD->methods()) {
1174 size_t index = (2 * size_t(MD->isOptional()))
1175 + (size_t(MD->isClassMethod()));
1176 result.Methods[index].push_back(MD);
1177 }
1178
1179 return result;
1180 }
1181
1182 template <class Self>
1183 SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const {
1184 // In both ABIs, the method types list is parallel with the
1185 // concatenation of the methods arrays in the following order:
1186 // instance methods
1187 // class methods
1188 // optional instance methods
1189 // optional class methods
1190 SmallVector<llvm::Constant*, 8> result;
1191
1192 // Methods is already in the correct order for both ABIs.
1193 for (auto &list : Methods) {
1194 for (auto MD : list) {
1195 result.push_back(self->GetMethodVarType(MD, true));
1196 }
1197 }
1198
1199 return result;
1200 }
1201
1202 template <class Self>
1203 llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD,
1204 Kind kind) const {
1205 return self->emitMethodList(PD->getObjCRuntimeNameAsString(),
1206 getMethodListKind(kind), Methods[kind]);
1207 }
1208};
1209
1210} // end anonymous namespace
1211
1212class CGObjCMac : public CGObjCCommonMac {
1213private:
1214 friend ProtocolMethodLists;
1215
1216 ObjCTypesHelper ObjCTypes;
1217
1218 /// EmitModuleInfo - Another marker encoding module level
1219 /// information.
1220 void EmitModuleInfo();
1221
1222 /// EmitModuleSymols - Emit module symbols, the list of defined
1223 /// classes and categories. The result has type SymtabPtrTy.
1224 llvm::Constant *EmitModuleSymbols();
1225
1226 /// FinishModule - Write out global data structures at the end of
1227 /// processing a translation unit.
1228 void FinishModule();
1229
1230 /// EmitClassExtension - Generate the class extension structure used
1231 /// to store the weak ivar layout and properties. The return value
1232 /// has type ClassExtensionPtrTy.
1233 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID,
1234 CharUnits instanceSize,
1235 bool hasMRCWeakIvars,
1236 bool isMetaclass);
1237
1238 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1239 /// for the given class.
1240 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1241 const ObjCInterfaceDecl *ID);
1242
1243 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1244 IdentifierInfo *II);
1245
1246 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1247
1248 /// EmitSuperClassRef - Emits reference to class's main metadata class.
1249 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1250
1251 /// EmitIvarList - Emit the ivar list for the given
1252 /// implementation. If ForClass is true the list of class ivars
1253 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1254 /// interface ivars will be emitted. The return value has type
1255 /// IvarListPtrTy.
1256 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1257 bool ForClass);
1258
1259 /// EmitMetaClass - Emit a forward reference to the class structure
1260 /// for the metaclass of the given interface. The return value has
1261 /// type ClassPtrTy.
1262 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1263
1264 /// EmitMetaClass - Emit a class structure for the metaclass of the
1265 /// given implementation. The return value has type ClassPtrTy.
1266 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1267 llvm::Constant *Protocols,
1268 ArrayRef<const ObjCMethodDecl *> Methods);
1269
1270 void emitMethodConstant(ConstantArrayBuilder &builder,
1271 const ObjCMethodDecl *MD);
1272
1273 void emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
1274 const ObjCMethodDecl *MD);
1275
1276 /// EmitMethodList - Emit the method list for the given
1277 /// implementation. The return value has type MethodListPtrTy.
1278 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1279 ArrayRef<const ObjCMethodDecl *> Methods);
1280
1281 /// GetOrEmitProtocol - Get the protocol object for the given
1282 /// declaration, emitting it if necessary. The return value has type
1283 /// ProtocolPtrTy.
1284 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1285
1286 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1287 /// object for the given declaration, emitting it if needed. These
1288 /// forward references will be filled in with empty bodies if no
1289 /// definition is seen. The return value has type ProtocolPtrTy.
1290 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1291
1292 /// EmitProtocolExtension - Generate the protocol extension
1293 /// structure used to store optional instance and class methods, and
1294 /// protocol properties. The return value has type
1295 /// ProtocolExtensionPtrTy.
1296 llvm::Constant *
1297 EmitProtocolExtension(const ObjCProtocolDecl *PD,
1298 const ProtocolMethodLists &methodLists);
1299
1300 /// EmitProtocolList - Generate the list of referenced
1301 /// protocols. The return value has type ProtocolListPtrTy.
1302 llvm::Constant *EmitProtocolList(Twine Name,
1303 ObjCProtocolDecl::protocol_iterator begin,
1304 ObjCProtocolDecl::protocol_iterator end);
1305
1306 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1307 /// for the given selector.
1308 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1309 Address EmitSelectorAddr(Selector Sel);
1310
1311public:
1312 CGObjCMac(CodeGen::CodeGenModule &cgm);
1313
1314 llvm::Constant *getNSConstantStringClassRef() override;
1315
1316 llvm::Function *ModuleInitFunction() override;
1317
1318 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1319 ReturnValueSlot Return,
1320 QualType ResultType,
1321 Selector Sel, llvm::Value *Receiver,
1322 const CallArgList &CallArgs,
1323 const ObjCInterfaceDecl *Class,
1324 const ObjCMethodDecl *Method) override;
1325
1326 CodeGen::RValue
1327 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1328 ReturnValueSlot Return, QualType ResultType,
1329 Selector Sel, const ObjCInterfaceDecl *Class,
1330 bool isCategoryImpl, llvm::Value *Receiver,
1331 bool IsClassMessage, const CallArgList &CallArgs,
1332 const ObjCMethodDecl *Method) override;
1333
1334 llvm::Value *GetClass(CodeGenFunction &CGF,
1335 const ObjCInterfaceDecl *ID) override;
1336
1337 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
1338 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
1339
1340 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1341 /// untyped one.
1342 llvm::Value *GetSelector(CodeGenFunction &CGF,
1343 const ObjCMethodDecl *Method) override;
1344
1345 llvm::Constant *GetEHType(QualType T) override;
1346
1347 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1348
1349 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1350
1351 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1352
1353 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1354 const ObjCProtocolDecl *PD) override;
1355
1356 llvm::FunctionCallee GetPropertyGetFunction() override;
1357 llvm::FunctionCallee GetPropertySetFunction() override;
1358 llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
1359 bool copy) override;
1360 llvm::FunctionCallee GetGetStructFunction() override;
1361 llvm::FunctionCallee GetSetStructFunction() override;
1362 llvm::FunctionCallee GetCppAtomicObjectGetFunction() override;
1363 llvm::FunctionCallee GetCppAtomicObjectSetFunction() override;
1364 llvm::FunctionCallee EnumerationMutationFunction() override;
1365
1366 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1367 const ObjCAtTryStmt &S) override;
1368 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1369 const ObjCAtSynchronizedStmt &S) override;
1370 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1371 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1372 bool ClearInsertionPoint=true) override;
1373 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1374 Address AddrWeakObj) override;
1375 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1376 llvm::Value *src, Address dst) override;
1377 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1378 llvm::Value *src, Address dest,
1379 bool threadlocal = false) override;
1380 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1381 llvm::Value *src, Address dest,
1382 llvm::Value *ivarOffset) override;
1383 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1384 llvm::Value *src, Address dest) override;
1385 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1386 Address dest, Address src,
1387 llvm::Value *size) override;
1388
1389 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1390 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1391 unsigned CVRQualifiers) override;
1392 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1393 const ObjCInterfaceDecl *Interface,
1394 const ObjCIvarDecl *Ivar) override;
1395};
1396
1397class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1398private:
1399 friend ProtocolMethodLists;
1400 ObjCNonFragileABITypesHelper ObjCTypes;
1401 llvm::GlobalVariable* ObjCEmptyCacheVar;
1402 llvm::Constant* ObjCEmptyVtableVar;
1403
1404 /// SuperClassReferences - uniqued super class references.
1405 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1406
1407 /// MetaClassReferences - uniqued meta class references.
1408 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1409
1410 /// EHTypeReferences - uniqued class ehtype references.
1411 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1412
1413 /// VTableDispatchMethods - List of methods for which we generate
1414 /// vtable-based message dispatch.
1415 llvm::DenseSet<Selector> VTableDispatchMethods;
1416
1417 /// DefinedMetaClasses - List of defined meta-classes.
1418 std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1419
1420 /// isVTableDispatchedSelector - Returns true if SEL is a
1421 /// vtable-based selector.
1422 bool isVTableDispatchedSelector(Selector Sel);
1423
1424 /// FinishNonFragileABIModule - Write out global data structures at the end of
1425 /// processing a translation unit.
1426 void FinishNonFragileABIModule();
1427
1428 /// AddModuleClassList - Add the given list of class pointers to the
1429 /// module with the provided symbol and section names.
1430 void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container,
1431 StringRef SymbolName, StringRef SectionName);
1432
1433 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1434 unsigned InstanceStart,
1435 unsigned InstanceSize,
1436 const ObjCImplementationDecl *ID);
1437 llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI,
1438 bool isMetaclass,
1439 llvm::Constant *IsAGV,
1440 llvm::Constant *SuperClassGV,
1441 llvm::Constant *ClassRoGV,
1442 bool HiddenVisibility);
1443
1444 void emitMethodConstant(ConstantArrayBuilder &builder,
1445 const ObjCMethodDecl *MD,
1446 bool forProtocol);
1447
1448 /// Emit the method list for the given implementation. The return value
1449 /// has type MethodListnfABITy.
1450 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1451 ArrayRef<const ObjCMethodDecl *> Methods);
1452
1453 /// EmitIvarList - Emit the ivar list for the given
1454 /// implementation. If ForClass is true the list of class ivars
1455 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1456 /// interface ivars will be emitted. The return value has type
1457 /// IvarListnfABIPtrTy.
1458 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
1459
1460 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1461 const ObjCIvarDecl *Ivar,
1462 unsigned long int offset);
1463
1464 /// GetOrEmitProtocol - Get the protocol object for the given
1465 /// declaration, emitting it if necessary. The return value has type
1466 /// ProtocolPtrTy.
1467 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1468
1469 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1470 /// object for the given declaration, emitting it if needed. These
1471 /// forward references will be filled in with empty bodies if no
1472 /// definition is seen. The return value has type ProtocolPtrTy.
1473 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1474
1475 /// EmitProtocolList - Generate the list of referenced
1476 /// protocols. The return value has type ProtocolListPtrTy.
1477 llvm::Constant *EmitProtocolList(Twine Name,
1478 ObjCProtocolDecl::protocol_iterator begin,
1479 ObjCProtocolDecl::protocol_iterator end);
1480
1481 CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1482 ReturnValueSlot Return,
1483 QualType ResultType,
1484 Selector Sel,
1485 llvm::Value *Receiver,
1486 QualType Arg0Ty,
1487 bool IsSuper,
1488 const CallArgList &CallArgs,
1489 const ObjCMethodDecl *Method);
1490
1491 /// GetClassGlobal - Return the global variable for the Objective-C
1492 /// class of the given name.
1493 llvm::Constant *GetClassGlobal(StringRef Name,
1494 ForDefinition_t IsForDefinition,
1495 bool Weak = false, bool DLLImport = false);
1496 llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID,
1497 bool isMetaclass,
1498 ForDefinition_t isForDefinition);
1499
1500 llvm::Constant *GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID);
1501
1502 llvm::Value *EmitLoadOfClassRef(CodeGenFunction &CGF,
1503 const ObjCInterfaceDecl *ID,
1504 llvm::GlobalVariable *Entry);
1505
1506 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1507 /// for the given class reference.
1508 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1509 const ObjCInterfaceDecl *ID);
1510
1511 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1512 IdentifierInfo *II,
1513 const ObjCInterfaceDecl *ID);
1514
1515 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1516
1517 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1518 /// for the given super class reference.
1519 llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1520 const ObjCInterfaceDecl *ID);
1521
1522 /// EmitMetaClassRef - Return a Value * of the address of _class_t
1523 /// meta-data
1524 llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1525 const ObjCInterfaceDecl *ID, bool Weak);
1526
1527 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1528 /// the given ivar.
1529 ///
1530 llvm::GlobalVariable * ObjCIvarOffsetVariable(
1531 const ObjCInterfaceDecl *ID,
1532 const ObjCIvarDecl *Ivar);
1533
1534 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1535 /// for the given selector.
1536 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1537 Address EmitSelectorAddr(Selector Sel);
1538
1539 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1540 /// interface. The return value has type EHTypePtrTy.
1541 llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1542 ForDefinition_t IsForDefinition);
1543
1544 StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }
1545
1546 StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; }
1547
1548 void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1549 uint32_t &InstanceStart,
1550 uint32_t &InstanceSize);
1551
1552 // Shamelessly stolen from Analysis/CFRefCount.cpp
1553 Selector GetNullarySelector(const char* name) const {
1554 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1555 return CGM.getContext().Selectors.getSelector(0, &II);
1556 }
1557
1558 Selector GetUnarySelector(const char* name) const {
1559 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1560 return CGM.getContext().Selectors.getSelector(1, &II);
1561 }
1562
1563 /// ImplementationIsNonLazy - Check whether the given category or
1564 /// class implementation is "non-lazy".
1565 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1566
1567 bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1568 const ObjCIvarDecl *IV) {
1569 // Annotate the load as an invariant load iff inside an instance method
1570 // and ivar belongs to instance method's class and one of its super class.
1571 // This check is needed because the ivar offset is a lazily
1572 // initialised value that may depend on objc_msgSend to perform a fixup on
1573 // the first message dispatch.
1574 //
1575 // An additional opportunity to mark the load as invariant arises when the
1576 // base of the ivar access is a parameter to an Objective C method.
1577 // However, because the parameters are not available in the current
1578 // interface, we cannot perform this check.
1579 //
1580 // Note that for direct methods, because objc_msgSend is skipped,
1581 // and that the method may be inlined, this optimization actually
1582 // can't be performed.
1583 if (const ObjCMethodDecl *MD =
1584 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1585 if (MD->isInstanceMethod() && !MD->isDirectMethod())
1586 if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1587 return IV->getContainingInterface()->isSuperClassOf(ID);
1588 return false;
1589 }
1590
1591 bool isClassLayoutKnownStatically(const ObjCInterfaceDecl *ID) {
1592 // NSObject is a fixed size. If we can see the @implementation of a class
1593 // which inherits from NSObject then we know that all it's offsets also must
1594 // be fixed. FIXME: Can we do this if see a chain of super classes with
1595 // implementations leading to NSObject?
1596 return ID->getImplementation() && ID->getSuperClass() &&
1597 ID->getSuperClass()->getName() == "NSObject";
1598 }
1599
1600public:
1601 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1602
1603 llvm::Constant *getNSConstantStringClassRef() override;
1604
1605 llvm::Function *ModuleInitFunction() override;
1606
1607 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1608 ReturnValueSlot Return,
1609 QualType ResultType, Selector Sel,
1610 llvm::Value *Receiver,
1611 const CallArgList &CallArgs,
1612 const ObjCInterfaceDecl *Class,
1613 const ObjCMethodDecl *Method) override;
1614
1615 CodeGen::RValue
1616 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1617 ReturnValueSlot Return, QualType ResultType,
1618 Selector Sel, const ObjCInterfaceDecl *Class,
1619 bool isCategoryImpl, llvm::Value *Receiver,
1620 bool IsClassMessage, const CallArgList &CallArgs,
1621 const ObjCMethodDecl *Method) override;
1622
1623 llvm::Value *GetClass(CodeGenFunction &CGF,
1624 const ObjCInterfaceDecl *ID) override;
1625
1626 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override
1627 { return EmitSelector(CGF, Sel); }
1628 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
1629 { return EmitSelectorAddr(Sel); }
1630
1631 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1632 /// untyped one.
1633 llvm::Value *GetSelector(CodeGenFunction &CGF,
1634 const ObjCMethodDecl *Method) override
1635 { return EmitSelector(CGF, Method->getSelector()); }
1636
1637 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1638
1639 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1640
1641 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1642
1643 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1644 const ObjCProtocolDecl *PD) override;
1645
1646 llvm::Constant *GetEHType(QualType T) override;
1647
1648 llvm::FunctionCallee GetPropertyGetFunction() override {
1649 return ObjCTypes.getGetPropertyFn();
1650 }
1651 llvm::FunctionCallee GetPropertySetFunction() override {
1652 return ObjCTypes.getSetPropertyFn();
1653 }
1654
1655 llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
1656 bool copy) override {
1657 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1658 }
1659
1660 llvm::FunctionCallee GetSetStructFunction() override {
1661 return ObjCTypes.getCopyStructFn();
1662 }
1663
1664 llvm::FunctionCallee GetGetStructFunction() override {
1665 return ObjCTypes.getCopyStructFn();
1666 }
1667
1668 llvm::FunctionCallee GetCppAtomicObjectSetFunction() override {
1669 return ObjCTypes.getCppAtomicObjectFunction();
1670 }
1671
1672 llvm::FunctionCallee GetCppAtomicObjectGetFunction() override {
1673 return ObjCTypes.getCppAtomicObjectFunction();
1674 }
1675
1676 llvm::FunctionCallee EnumerationMutationFunction() override {
1677 return ObjCTypes.getEnumerationMutationFn();
1678 }
1679
1680 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1681 const ObjCAtTryStmt &S) override;
1682 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1683 const ObjCAtSynchronizedStmt &S) override;
1684 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1685 bool ClearInsertionPoint=true) override;
1686 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1687 Address AddrWeakObj) override;
1688 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1689 llvm::Value *src, Address edst) override;
1690 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1691 llvm::Value *src, Address dest,
1692 bool threadlocal = false) override;
1693 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1694 llvm::Value *src, Address dest,
1695 llvm::Value *ivarOffset) override;
1696 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1697 llvm::Value *src, Address dest) override;
1698 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1699 Address dest, Address src,
1700 llvm::Value *size) override;
1701 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1702 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1703 unsigned CVRQualifiers) override;
1704 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1705 const ObjCInterfaceDecl *Interface,
1706 const ObjCIvarDecl *Ivar) override;
1707};
1708
1709/// A helper class for performing the null-initialization of a return
1710/// value.
1711struct NullReturnState {
1712 llvm::BasicBlock *NullBB;
1713 NullReturnState() : NullBB(nullptr) {}
1714
1715 /// Perform a null-check of the given receiver.
1716 void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1717 // Make blocks for the null-receiver and call edges.
1718 NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1719 llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1720
1721 // Check for a null receiver and, if there is one, jump to the
1722 // null-receiver block. There's no point in trying to avoid it:
1723 // we're always going to put *something* there, because otherwise
1724 // we shouldn't have done this null-check in the first place.
1725 llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1726 CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1727
1728 // Otherwise, start performing the call.
1729 CGF.EmitBlock(callBB);
1730 }
1731
1732 /// Complete the null-return operation. It is valid to call this
1733 /// regardless of whether 'init' has been called.
1734 RValue complete(CodeGenFunction &CGF,
1735 ReturnValueSlot returnSlot,
1736 RValue result,
1737 QualType resultType,
1738 const CallArgList &CallArgs,
1739 const ObjCMethodDecl *Method) {
1740 // If we never had to do a null-check, just use the raw result.
1741 if (!NullBB) return result;
1742
1743 // The continuation block. This will be left null if we don't have an
1744 // IP, which can happen if the method we're calling is marked noreturn.
1745 llvm::BasicBlock *contBB = nullptr;
1746
1747 // Finish the call path.
1748 llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1749 if (callBB) {
1750 contBB = CGF.createBasicBlock("msgSend.cont");
1751 CGF.Builder.CreateBr(contBB);
1752 }
1753
1754 // Okay, start emitting the null-receiver block.
1755 CGF.EmitBlock(NullBB);
1756
1757 // Release any consumed arguments we've got.
1758 if (Method) {
1759 CallArgList::const_iterator I = CallArgs.begin();
1760 for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
1761 e = Method->param_end(); i != e; ++i, ++I) {
1762 const ParmVarDecl *ParamDecl = (*i);
1763 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1764 RValue RV = I->getRValue(CGF);
1765 assert(RV.isScalar() &&(static_cast <bool> (RV.isScalar() && "NullReturnState::complete - arg not on object"
) ? void (0) : __assert_fail ("RV.isScalar() && \"NullReturnState::complete - arg not on object\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 1766, __extension__ __PRETTY_FUNCTION__))
1766 "NullReturnState::complete - arg not on object")(static_cast <bool> (RV.isScalar() && "NullReturnState::complete - arg not on object"
) ? void (0) : __assert_fail ("RV.isScalar() && \"NullReturnState::complete - arg not on object\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 1766, __extension__ __PRETTY_FUNCTION__))
;
1767 CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime);
1768 } else {
1769 QualType QT = ParamDecl->getType();
1770 auto *RT = QT->getAs<RecordType>();
1771 if (RT && RT->getDecl()->isParamDestroyedInCallee()) {
1772 RValue RV = I->getRValue(CGF);
1773 QualType::DestructionKind DtorKind = QT.isDestructedType();
1774 switch (DtorKind) {
1775 case QualType::DK_cxx_destructor:
1776 CGF.destroyCXXObject(CGF, RV.getAggregateAddress(), QT);
1777 break;
1778 case QualType::DK_nontrivial_c_struct:
1779 CGF.destroyNonTrivialCStruct(CGF, RV.getAggregateAddress(), QT);
1780 break;
1781 default:
1782 llvm_unreachable("unexpected dtor kind")::llvm::llvm_unreachable_internal("unexpected dtor kind", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 1782)
;
1783 break;
1784 }
1785 }
1786 }
1787 }
1788 }
1789
1790 // The phi code below assumes that we haven't needed any control flow yet.
1791 assert(CGF.Builder.GetInsertBlock() == NullBB)(static_cast <bool> (CGF.Builder.GetInsertBlock() == NullBB
) ? void (0) : __assert_fail ("CGF.Builder.GetInsertBlock() == NullBB"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 1791, __extension__ __PRETTY_FUNCTION__))
;
1792
1793 // If we've got a void return, just jump to the continuation block.
1794 if (result.isScalar() && resultType->isVoidType()) {
1795 // No jumps required if the message-send was noreturn.
1796 if (contBB) CGF.EmitBlock(contBB);
1797 return result;
1798 }
1799
1800 // If we've got a scalar return, build a phi.
1801 if (result.isScalar()) {
1802 // Derive the null-initialization value.
1803 llvm::Value *null =
1804 CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(resultType), resultType);
1805
1806 // If no join is necessary, just flow out.
1807 if (!contBB) return RValue::get(null);
1808
1809 // Otherwise, build a phi.
1810 CGF.EmitBlock(contBB);
1811 llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1812 phi->addIncoming(result.getScalarVal(), callBB);
1813 phi->addIncoming(null, NullBB);
1814 return RValue::get(phi);
1815 }
1816
1817 // If we've got an aggregate return, null the buffer out.
1818 // FIXME: maybe we should be doing things differently for all the
1819 // cases where the ABI has us returning (1) non-agg values in
1820 // memory or (2) agg values in registers.
1821 if (result.isAggregate()) {
1822 assert(result.isAggregate() && "null init of non-aggregate result?")(static_cast <bool> (result.isAggregate() && "null init of non-aggregate result?"
) ? void (0) : __assert_fail ("result.isAggregate() && \"null init of non-aggregate result?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 1822, __extension__ __PRETTY_FUNCTION__))
;
1823 if (!returnSlot.isUnused())
1824 CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
1825 if (contBB) CGF.EmitBlock(contBB);
1826 return result;
1827 }
1828
1829 // Complex types.
1830 CGF.EmitBlock(contBB);
1831 CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1832
1833 // Find the scalar type and its zero value.
1834 llvm::Type *scalarTy = callResult.first->getType();
1835 llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1836
1837 // Build phis for both coordinates.
1838 llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1839 real->addIncoming(callResult.first, callBB);
1840 real->addIncoming(scalarZero, NullBB);
1841 llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1842 imag->addIncoming(callResult.second, callBB);
1843 imag->addIncoming(scalarZero, NullBB);
1844 return RValue::getComplex(real, imag);
1845 }
1846};
1847
1848} // end anonymous namespace
1849
1850/* *** Helper Functions *** */
1851
1852/// getConstantGEP() - Help routine to construct simple GEPs.
1853static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1854 llvm::GlobalVariable *C, unsigned idx0,
1855 unsigned idx1) {
1856 llvm::Value *Idxs[] = {
1857 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1858 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1859 };
1860 return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1861}
1862
1863/// hasObjCExceptionAttribute - Return true if this class or any super
1864/// class has the __objc_exception__ attribute.
1865static bool hasObjCExceptionAttribute(ASTContext &Context,
1866 const ObjCInterfaceDecl *OID) {
1867 if (OID->hasAttr<ObjCExceptionAttr>())
1868 return true;
1869 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1870 return hasObjCExceptionAttribute(Context, Super);
1871 return false;
1872}
1873
1874static llvm::GlobalValue::LinkageTypes
1875getLinkageTypeForObjCMetadata(CodeGenModule &CGM, StringRef Section) {
1876 if (CGM.getTriple().isOSBinFormatMachO() &&
1877 (Section.empty() || Section.startswith("__DATA")))
1878 return llvm::GlobalValue::InternalLinkage;
1879 return llvm::GlobalValue::PrivateLinkage;
1880}
1881
1882/// A helper function to create an internal or private global variable.
1883static llvm::GlobalVariable *
1884finishAndCreateGlobal(ConstantInitBuilder::StructBuilder &Builder,
1885 const llvm::Twine &Name, CodeGenModule &CGM) {
1886 std::string SectionName;
1887 if (CGM.getTriple().isOSBinFormatMachO())
1888 SectionName = "__DATA, __objc_const";
1889 auto *GV = Builder.finishAndCreateGlobal(
1890 Name, CGM.getPointerAlign(), /*constant*/ false,
1891 getLinkageTypeForObjCMetadata(CGM, SectionName));
1892 GV->setSection(SectionName);
1893 return GV;
1894}
1895
1896/* *** CGObjCMac Public Interface *** */
1897
1898CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1899 ObjCTypes(cgm) {
1900 ObjCABI = 1;
1901 EmitImageInfo();
1902}
1903
1904/// GetClass - Return a reference to the class for the given interface
1905/// decl.
1906llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1907 const ObjCInterfaceDecl *ID) {
1908 return EmitClassRef(CGF, ID);
1909}
1910
1911/// GetSelector - Return the pointer to the unique'd string for this selector.
1912llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1913 return EmitSelector(CGF, Sel);
1914}
1915Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1916 return EmitSelectorAddr(Sel);
1917}
1918llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1919 *Method) {
1920 return EmitSelector(CGF, Method->getSelector());
1921}
1922
1923llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1924 if (T->isObjCIdType() ||
1925 T->isObjCQualifiedIdType()) {
1926 return CGM.GetAddrOfRTTIDescriptor(
1927 CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1928 }
1929 if (T->isObjCClassType() ||
1930 T->isObjCQualifiedClassType()) {
1931 return CGM.GetAddrOfRTTIDescriptor(
1932 CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1933 }
1934 if (T->isObjCObjectPointerType())
1935 return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true);
1936
1937 llvm_unreachable("asking for catch type for ObjC type in fragile runtime")::llvm::llvm_unreachable_internal("asking for catch type for ObjC type in fragile runtime"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 1937)
;
1938}
1939
1940/// Generate a constant CFString object.
1941/*
1942 struct __builtin_CFString {
1943 const int *isa; // point to __CFConstantStringClassReference
1944 int flags;
1945 const char *str;
1946 long length;
1947 };
1948*/
1949
1950/// or Generate a constant NSString object.
1951/*
1952 struct __builtin_NSString {
1953 const int *isa; // point to __NSConstantStringClassReference
1954 const char *str;
1955 unsigned int length;
1956 };
1957*/
1958
1959ConstantAddress
1960CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) {
1961 return (!CGM.getLangOpts().NoConstantCFStrings
1962 ? CGM.GetAddrOfConstantCFString(SL)
1963 : GenerateConstantNSString(SL));
1964}
1965
1966static llvm::StringMapEntry<llvm::GlobalVariable *> &
1967GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
1968 const StringLiteral *Literal, unsigned &StringLength) {
1969 StringRef String = Literal->getString();
1970 StringLength = String.size();
1971 return *Map.insert(std::make_pair(String, nullptr)).first;
1972}
1973
1974llvm::Constant *CGObjCMac::getNSConstantStringClassRef() {
1975 if (llvm::Value *V = ConstantStringClassRef)
1976 return cast<llvm::Constant>(V);
1977
1978 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1979 std::string str =
1980 StringClass.empty() ? "_NSConstantStringClassReference"
1981 : "_" + StringClass + "ClassReference";
1982
1983 llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
1984 auto GV = CGM.CreateRuntimeVariable(PTy, str);
1985 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1986 ConstantStringClassRef = V;
1987 return V;
1988}
1989
1990llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() {
1991 if (llvm::Value *V = ConstantStringClassRef)
1992 return cast<llvm::Constant>(V);
1993
1994 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1995 std::string str =
1996 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
1997 : "OBJC_CLASS_$_" + StringClass;
1998 llvm::Constant *GV = GetClassGlobal(str, NotForDefinition);
1999
2000 // Make sure the result is of the correct type.
2001 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
2002
2003 ConstantStringClassRef = V;
2004 return V;
2005}
2006
2007ConstantAddress
2008CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) {
2009 unsigned StringLength = 0;
2010 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
2011 GetConstantStringEntry(NSConstantStringMap, Literal, StringLength);
2012
2013 if (auto *C = Entry.second)
2014 return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
2015
2016 // If we don't already have it, get _NSConstantStringClassReference.
2017 llvm::Constant *Class = getNSConstantStringClassRef();
2018
2019 // If we don't already have it, construct the type for a constant NSString.
2020 if (!NSConstantStringType) {
2021 NSConstantStringType =
2022 llvm::StructType::create({
2023 CGM.Int32Ty->getPointerTo(),
2024 CGM.Int8PtrTy,
2025 CGM.IntTy
2026 }, "struct.__builtin_NSString");
2027 }
2028
2029 ConstantInitBuilder Builder(CGM);
2030 auto Fields = Builder.beginStruct(NSConstantStringType);
2031
2032 // Class pointer.
2033 Fields.add(Class);
2034
2035 // String pointer.
2036 llvm::Constant *C =
2037 llvm::ConstantDataArray::getString(VMContext, Entry.first());
2038
2039 llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage;
2040 bool isConstant = !CGM.getLangOpts().WritableStrings;
2041
2042 auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant,
2043 Linkage, C, ".str");
2044 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2045 // Don't enforce the target's minimum global alignment, since the only use
2046 // of the string is via this class initializer.
2047 GV->setAlignment(llvm::Align(1));
2048 Fields.addBitCast(GV, CGM.Int8PtrTy);
2049
2050 // String length.
2051 Fields.addInt(CGM.IntTy, StringLength);
2052
2053 // The struct.
2054 CharUnits Alignment = CGM.getPointerAlign();
2055 GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
2056 /*constant*/ true,
2057 llvm::GlobalVariable::PrivateLinkage);
2058 const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
2059 const char *NSStringNonFragileABISection =
2060 "__DATA,__objc_stringobj,regular,no_dead_strip";
2061 // FIXME. Fix section.
2062 GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
2063 ? NSStringNonFragileABISection
2064 : NSStringSection);
2065 Entry.second = GV;
2066
2067 return ConstantAddress(GV, Alignment);
2068}
2069
2070enum {
2071 kCFTaggedObjectID_Integer = (1 << 1) + 1
2072};
2073
2074/// Generates a message send where the super is the receiver. This is
2075/// a message send to self with special delivery semantics indicating
2076/// which class's method should be called.
2077CodeGen::RValue
2078CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
2079 ReturnValueSlot Return,
2080 QualType ResultType,
2081 Selector Sel,
2082 const ObjCInterfaceDecl *Class,
2083 bool isCategoryImpl,
2084 llvm::Value *Receiver,
2085 bool IsClassMessage,
2086 const CodeGen::CallArgList &CallArgs,
2087 const ObjCMethodDecl *Method) {
2088 // Create and init a super structure; this is a (receiver, class)
2089 // pair we will pass to objc_msgSendSuper.
2090 Address ObjCSuper =
2091 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
2092 "objc_super");
2093 llvm::Value *ReceiverAsObject =
2094 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
2095 CGF.Builder.CreateStore(ReceiverAsObject,
2096 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
2097
2098 // If this is a class message the metaclass is passed as the target.
2099 llvm::Type *ClassTyPtr = llvm::PointerType::getUnqual(ObjCTypes.ClassTy);
2100 llvm::Value *Target;
2101 if (IsClassMessage) {
2102 if (isCategoryImpl) {
2103 // Message sent to 'super' in a class method defined in a category
2104 // implementation requires an odd treatment.
2105 // If we are in a class method, we must retrieve the
2106 // _metaclass_ for the current class, pointed at by
2107 // the class's "isa" pointer. The following assumes that
2108 // isa" is the first ivar in a class (which it must be).
2109 Target = EmitClassRef(CGF, Class->getSuperClass());
2110 Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
2111 Target = CGF.Builder.CreateAlignedLoad(ClassTyPtr, Target,
2112 CGF.getPointerAlign());
2113 } else {
2114 llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
2115 llvm::Value *SuperPtr =
2116 CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
2117 llvm::Value *Super = CGF.Builder.CreateAlignedLoad(ClassTyPtr, SuperPtr,
2118 CGF.getPointerAlign());
2119 Target = Super;
2120 }
2121 } else if (isCategoryImpl)
2122 Target = EmitClassRef(CGF, Class->getSuperClass());
2123 else {
2124 llvm::Value *ClassPtr = EmitSuperClassRef(Class);
2125 ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
2126 Target = CGF.Builder.CreateAlignedLoad(ClassTyPtr, ClassPtr,
2127 CGF.getPointerAlign());
2128 }
2129 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
2130 // ObjCTypes types.
2131 llvm::Type *ClassTy =
2132 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
2133 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
2134 CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
2135 return EmitMessageSend(CGF, Return, ResultType, Sel, ObjCSuper.getPointer(),
2136 ObjCTypes.SuperPtrCTy, true, CallArgs, Method, Class,
2137 ObjCTypes);
2138}
2139
2140/// Generate code for a message send expression.
2141CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
2142 ReturnValueSlot Return,
2143 QualType ResultType,
2144 Selector Sel,
2145 llvm::Value *Receiver,
2146 const CallArgList &CallArgs,
2147 const ObjCInterfaceDecl *Class,
2148 const ObjCMethodDecl *Method) {
2149 return EmitMessageSend(CGF, Return, ResultType, Sel, Receiver,
2150 CGF.getContext().getObjCIdType(), false, CallArgs,
2151 Method, Class, ObjCTypes);
2152}
2153
2154static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
2155 do {
2156 if (ID->isWeakImported())
2157 return true;
2158 } while ((ID = ID->getSuperClass()));
2159
2160 return false;
2161}
2162
2163CodeGen::RValue
2164CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
2165 ReturnValueSlot Return,
2166 QualType ResultType,
2167 Selector Sel,
2168 llvm::Value *Arg0,
2169 QualType Arg0Ty,
2170 bool IsSuper,
2171 const CallArgList &CallArgs,
2172 const ObjCMethodDecl *Method,
2173 const ObjCInterfaceDecl *ClassReceiver,
2174 const ObjCCommonTypesHelper &ObjCTypes) {
2175 CodeGenTypes &Types = CGM.getTypes();
2176 auto selTy = CGF.getContext().getObjCSelType();
2177 llvm::Value *SelValue;
2178
2179 if (Method && Method->isDirectMethod()) {
2180 // Direct methods will synthesize the proper `_cmd` internally,
2181 // so just don't bother with setting the `_cmd` argument.
2182 assert(!IsSuper)(static_cast <bool> (!IsSuper) ? void (0) : __assert_fail
("!IsSuper", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2182, __extension__ __PRETTY_FUNCTION__))
;
2183 SelValue = llvm::UndefValue::get(Types.ConvertType(selTy));
2184 } else {
2185 SelValue = GetSelector(CGF, Sel);
2186 }
2187
2188 CallArgList ActualArgs;
2189 if (!IsSuper)
2190 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
2191 ActualArgs.add(RValue::get(Arg0), Arg0Ty);
2192 ActualArgs.add(RValue::get(SelValue), selTy);
2193 ActualArgs.addFrom(CallArgs);
2194
2195 // If we're calling a method, use the formal signature.
2196 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2197
2198 if (Method)
2199 assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==(static_cast <bool> (CGM.getContext().getCanonicalType(
Method->getReturnType()) == CGM.getContext().getCanonicalType
(ResultType) && "Result type mismatch!") ? void (0) :
__assert_fail ("CGM.getContext().getCanonicalType(Method->getReturnType()) == CGM.getContext().getCanonicalType(ResultType) && \"Result type mismatch!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2201, __extension__ __PRETTY_FUNCTION__))
2200 CGM.getContext().getCanonicalType(ResultType) &&(static_cast <bool> (CGM.getContext().getCanonicalType(
Method->getReturnType()) == CGM.getContext().getCanonicalType
(ResultType) && "Result type mismatch!") ? void (0) :
__assert_fail ("CGM.getContext().getCanonicalType(Method->getReturnType()) == CGM.getContext().getCanonicalType(ResultType) && \"Result type mismatch!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2201, __extension__ __PRETTY_FUNCTION__))
2201 "Result type mismatch!")(static_cast <bool> (CGM.getContext().getCanonicalType(
Method->getReturnType()) == CGM.getContext().getCanonicalType
(ResultType) && "Result type mismatch!") ? void (0) :
__assert_fail ("CGM.getContext().getCanonicalType(Method->getReturnType()) == CGM.getContext().getCanonicalType(ResultType) && \"Result type mismatch!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2201, __extension__ __PRETTY_FUNCTION__))
;
2202
2203 bool ReceiverCanBeNull = true;
2204
2205 // Super dispatch assumes that self is non-null; even the messenger
2206 // doesn't have a null check internally.
2207 if (IsSuper) {
2208 ReceiverCanBeNull = false;
2209
2210 // If this is a direct dispatch of a class method, check whether the class,
2211 // or anything in its hierarchy, was weak-linked.
2212 } else if (ClassReceiver && Method && Method->isClassMethod()) {
2213 ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);
2214
2215 // If we're emitting a method, and self is const (meaning just ARC, for now),
2216 // and the receiver is a load of self, then self is a valid object.
2217 } else if (auto CurMethod =
2218 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
2219 auto Self = CurMethod->getSelfDecl();
2220 if (Self->getType().isConstQualified()) {
2221 if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {
2222 llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer();
2223 if (SelfAddr == LI->getPointerOperand()) {
2224 ReceiverCanBeNull = false;
2225 }
2226 }
2227 }
2228 }
2229
2230 bool RequiresNullCheck = false;
2231
2232 llvm::FunctionCallee Fn = nullptr;
2233 if (Method && Method->isDirectMethod()) {
2234 Fn = GenerateDirectMethod(Method, Method->getClassInterface());
2235 } else if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
2236 if (ReceiverCanBeNull) RequiresNullCheck = true;
2237 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
2238 : ObjCTypes.getSendStretFn(IsSuper);
2239 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
2240 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
2241 : ObjCTypes.getSendFpretFn(IsSuper);
2242 } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
2243 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
2244 : ObjCTypes.getSendFp2retFn(IsSuper);
2245 } else {
2246 // arm64 uses objc_msgSend for stret methods and yet null receiver check
2247 // must be made for it.
2248 if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
2249 RequiresNullCheck = true;
2250 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
2251 : ObjCTypes.getSendFn(IsSuper);
2252 }
2253
2254 // Cast function to proper signature
2255 llvm::Constant *BitcastFn = cast<llvm::Constant>(
2256 CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType));
2257
2258 // We don't need to emit a null check to zero out an indirect result if the
2259 // result is ignored.
2260 if (Return.isUnused())
2261 RequiresNullCheck = false;
2262
2263 // Emit a null-check if there's a consumed argument other than the receiver.
2264 if (!RequiresNullCheck && CGM.getLangOpts().ObjCAutoRefCount && Method) {
2265 for (const auto *ParamDecl : Method->parameters()) {
2266 if (ParamDecl->isDestroyedInCallee()) {
2267 RequiresNullCheck = true;
2268 break;
2269 }
2270 }
2271 }
2272
2273 NullReturnState nullReturn;
2274 if (RequiresNullCheck) {
2275 nullReturn.init(CGF, Arg0);
2276 }
2277
2278 llvm::CallBase *CallSite;
2279 CGCallee Callee = CGCallee::forDirect(BitcastFn);
2280 RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
2281 &CallSite);
2282
2283 // Mark the call as noreturn if the method is marked noreturn and the
2284 // receiver cannot be null.
2285 if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) {
2286 CallSite->setDoesNotReturn();
2287 }
2288
2289 return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs,
2290 RequiresNullCheck ? Method : nullptr);
2291}
2292
2293static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT,
2294 bool pointee = false) {
2295 // Note that GC qualification applies recursively to C pointer types
2296 // that aren't otherwise decorated. This is weird, but it's probably
2297 // an intentional workaround to the unreliable placement of GC qualifiers.
2298 if (FQT.isObjCGCStrong())
2299 return Qualifiers::Strong;
2300
2301 if (FQT.isObjCGCWeak())
2302 return Qualifiers::Weak;
2303
2304 if (auto ownership = FQT.getObjCLifetime()) {
2305 // Ownership does not apply recursively to C pointer types.
2306 if (pointee) return Qualifiers::GCNone;
2307 switch (ownership) {
2308 case Qualifiers::OCL_Weak: return Qualifiers::Weak;
2309 case Qualifiers::OCL_Strong: return Qualifiers::Strong;
2310 case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone;
2311 case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?")::llvm::llvm_unreachable_internal("autoreleasing ivar?", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2311)
;
2312 case Qualifiers::OCL_None: llvm_unreachable("known nonzero")::llvm::llvm_unreachable_internal("known nonzero", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2312)
;
2313 }
2314 llvm_unreachable("bad objc ownership")::llvm::llvm_unreachable_internal("bad objc ownership", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2314)
;
2315 }
2316
2317 // Treat unqualified retainable pointers as strong.
2318 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2319 return Qualifiers::Strong;
2320
2321 // Walk into C pointer types, but only in GC.
2322 if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
2323 if (const PointerType *PT = FQT->getAs<PointerType>())
2324 return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
2325 }
2326
2327 return Qualifiers::GCNone;
2328}
2329
2330namespace {
2331 struct IvarInfo {
2332 CharUnits Offset;
2333 uint64_t SizeInWords;
2334 IvarInfo(CharUnits offset, uint64_t sizeInWords)
2335 : Offset(offset), SizeInWords(sizeInWords) {}
2336
2337 // Allow sorting based on byte pos.
2338 bool operator<(const IvarInfo &other) const {
2339 return Offset < other.Offset;
2340 }
2341 };
2342
2343 /// A helper class for building GC layout strings.
2344 class IvarLayoutBuilder {
2345 CodeGenModule &CGM;
2346
2347 /// The start of the layout. Offsets will be relative to this value,
2348 /// and entries less than this value will be silently discarded.
2349 CharUnits InstanceBegin;
2350
2351 /// The end of the layout. Offsets will never exceed this value.
2352 CharUnits InstanceEnd;
2353
2354 /// Whether we're generating the strong layout or the weak layout.
2355 bool ForStrongLayout;
2356
2357 /// Whether the offsets in IvarsInfo might be out-of-order.
2358 bool IsDisordered = false;
2359
2360 llvm::SmallVector<IvarInfo, 8> IvarsInfo;
2361
2362 public:
2363 IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2364 CharUnits instanceEnd, bool forStrongLayout)
2365 : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
2366 ForStrongLayout(forStrongLayout) {
2367 }
2368
2369 void visitRecord(const RecordType *RT, CharUnits offset);
2370
2371 template <class Iterator, class GetOffsetFn>
2372 void visitAggregate(Iterator begin, Iterator end,
2373 CharUnits aggrOffset,
2374 const GetOffsetFn &getOffset);
2375
2376 void visitField(const FieldDecl *field, CharUnits offset);
2377
2378 /// Add the layout of a block implementation.
2379 void visitBlock(const CGBlockInfo &blockInfo);
2380
2381 /// Is there any information for an interesting bitmap?
2382 bool hasBitmapData() const { return !IvarsInfo.empty(); }
2383
2384 llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
2385 llvm::SmallVectorImpl<unsigned char> &buffer);
2386
2387 static void dump(ArrayRef<unsigned char> buffer) {
2388 const unsigned char *s = buffer.data();
2389 for (unsigned i = 0, e = buffer.size(); i < e; i++)
2390 if (!(s[i] & 0xf0))
2391 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2392 else
2393 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
2394 printf("\n");
2395 }
2396 };
2397} // end anonymous namespace
2398
2399llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
2400 const CGBlockInfo &blockInfo) {
2401
2402 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2403 if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
2404 return nullPtr;
2405
2406 IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2407 /*for strong layout*/ true);
2408
2409 builder.visitBlock(blockInfo);
2410
2411 if (!builder.hasBitmapData())
2412 return nullPtr;
2413
2414 llvm::SmallVector<unsigned char, 32> buffer;
2415 llvm::Constant *C = builder.buildBitmap(*this, buffer);
2416 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
2417 printf("\n block variable layout for block: ");
2418 builder.dump(buffer);
2419 }
2420
2421 return C;
2422}
2423
2424void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
2425 // __isa is the first field in block descriptor and must assume by runtime's
2426 // convention that it is GC'able.
2427 IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2428
2429 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2430
2431 // Ignore the optional 'this' capture: C++ objects are not assumed
2432 // to be GC'ed.
2433
2434 CharUnits lastFieldOffset;
2435
2436 // Walk the captured variables.
2437 for (const auto &CI : blockDecl->captures()) {
2438 const VarDecl *variable = CI.getVariable();
2439 QualType type = variable->getType();
2440
2441 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2442
2443 // Ignore constant captures.
2444 if (capture.isConstant()) continue;
2445
2446 CharUnits fieldOffset = capture.getOffset();
2447
2448 // Block fields are not necessarily ordered; if we detect that we're
2449 // adding them out-of-order, make sure we sort later.
2450 if (fieldOffset < lastFieldOffset)
2451 IsDisordered = true;
2452 lastFieldOffset = fieldOffset;
2453
2454 // __block variables are passed by their descriptor address.
2455 if (CI.isByRef()) {
2456 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2457 continue;
2458 }
2459
2460 assert(!type->isArrayType() && "array variable should not be caught")(static_cast <bool> (!type->isArrayType() &&
"array variable should not be caught") ? void (0) : __assert_fail
("!type->isArrayType() && \"array variable should not be caught\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2460, __extension__ __PRETTY_FUNCTION__))
;
2461 if (const RecordType *record = type->getAs<RecordType>()) {
2462 visitRecord(record, fieldOffset);
2463 continue;
2464 }
2465
2466 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);
2467
2468 if (GCAttr == Qualifiers::Strong) {
2469 assert(CGM.getContext().getTypeSize(type)(static_cast <bool> (CGM.getContext().getTypeSize(type)
== CGM.getTarget().getPointerWidth(0)) ? void (0) : __assert_fail
("CGM.getContext().getTypeSize(type) == CGM.getTarget().getPointerWidth(0)"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2470, __extension__ __PRETTY_FUNCTION__))
2470 == CGM.getTarget().getPointerWidth(0))(static_cast <bool> (CGM.getContext().getTypeSize(type)
== CGM.getTarget().getPointerWidth(0)) ? void (0) : __assert_fail
("CGM.getContext().getTypeSize(type) == CGM.getTarget().getPointerWidth(0)"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2470, __extension__ __PRETTY_FUNCTION__))
;
2471 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2472 }
2473 }
2474}
2475
2476/// getBlockCaptureLifetime - This routine returns life time of the captured
2477/// block variable for the purpose of block layout meta-data generation. FQT is
2478/// the type of the variable captured in the block.
2479Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2480 bool ByrefLayout) {
2481 // If it has an ownership qualifier, we're done.
2482 if (auto lifetime = FQT.getObjCLifetime())
2483 return lifetime;
2484
2485 // If it doesn't, and this is ARC, it has no ownership.
2486 if (CGM.getLangOpts().ObjCAutoRefCount)
2487 return Qualifiers::OCL_None;
2488
2489 // In MRC, retainable pointers are owned by non-__block variables.
2490 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2491 return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong;
2492
2493 return Qualifiers::OCL_None;
2494}
2495
2496void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2497 Qualifiers::ObjCLifetime LifeTime,
2498 CharUnits FieldOffset,
2499 CharUnits FieldSize) {
2500 // __block variables are passed by their descriptor address.
2501 if (IsByref)
2502 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2503 FieldSize));
2504 else if (LifeTime == Qualifiers::OCL_Strong)
2505 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2506 FieldSize));
2507 else if (LifeTime == Qualifiers::OCL_Weak)
2508 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2509 FieldSize));
2510 else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2511 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2512 FieldSize));
2513 else
2514 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2515 FieldOffset,
2516 FieldSize));
2517}
2518
2519void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2520 const RecordDecl *RD,
2521 ArrayRef<const FieldDecl*> RecFields,
2522 CharUnits BytePos, bool &HasUnion,
2523 bool ByrefLayout) {
2524 bool IsUnion = (RD
9.1
'RD' is non-null
9.1
'RD' is non-null
&& RD->isUnion());
2525 CharUnits MaxUnionSize = CharUnits::Zero();
2526 const FieldDecl *MaxField = nullptr;
2527 const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2528 CharUnits MaxFieldOffset = CharUnits::Zero();
2529 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2530
2531 if (RecFields.empty())
10
Assuming the condition is false
11
Taking false branch
2532 return;
2533 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2534
2535 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
12
Assuming 'i' is not equal to 'e'
13
Loop condition is true. Entering loop body
2536 const FieldDecl *Field = RecFields[i];
2537 // Note that 'i' here is actually the field index inside RD of Field,
2538 // although this dependency is hidden.
2539 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2540 CharUnits FieldOffset =
2541 CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i));
2542
2543 // Skip over unnamed or bitfields
2544 if (!Field->getIdentifier() || Field->isBitField()) {
14
Assuming the condition is false
15
Assuming the condition is false
16
Taking false branch
2545 LastFieldBitfieldOrUnnamed = Field;
2546 LastBitfieldOrUnnamedOffset = FieldOffset;
2547 continue;
2548 }
2549
2550 LastFieldBitfieldOrUnnamed = nullptr;
2551 QualType FQT = Field->getType();
2552 if (FQT->isRecordType() || FQT->isUnionType()) {
17
Calling 'Type::isRecordType'
20
Returning from 'Type::isRecordType'
2553 if (FQT->isUnionType())
21
Assuming the condition is false
22
Taking false branch
2554 HasUnion = true;
2555
2556 BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
23
Assuming the object is not a 'RecordType'
24
Passing null pointer value via 1st parameter 'RT'
25
Calling 'CGObjCCommonMac::BuildRCBlockVarRecordLayout'
2557 BytePos + FieldOffset, HasUnion);
2558 continue;
2559 }
2560
2561 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2562 auto *CArray = cast<ConstantArrayType>(Array);
2563 uint64_t ElCount = CArray->getSize().getZExtValue();
2564 assert(CArray && "only array with known element size is supported")(static_cast <bool> (CArray && "only array with known element size is supported"
) ? void (0) : __assert_fail ("CArray && \"only array with known element size is supported\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2564, __extension__ __PRETTY_FUNCTION__))
;
2565 FQT = CArray->getElementType();
2566 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2567 auto *CArray = cast<ConstantArrayType>(Array);
2568 ElCount *= CArray->getSize().getZExtValue();
2569 FQT = CArray->getElementType();
2570 }
2571 if (FQT->isRecordType() && ElCount) {
2572 int OldIndex = RunSkipBlockVars.size() - 1;
2573 auto *RT = FQT->castAs<RecordType>();
2574 BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset, HasUnion);
2575
2576 // Replicate layout information for each array element. Note that
2577 // one element is already done.
2578 uint64_t ElIx = 1;
2579 for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2580 CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2581 for (int i = OldIndex+1; i <= FirstIndex; ++i)
2582 RunSkipBlockVars.push_back(
2583 RUN_SKIP(RunSkipBlockVars[i].opcode,
2584 RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2585 RunSkipBlockVars[i].block_var_size));
2586 }
2587 continue;
2588 }
2589 }
2590 CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2591 if (IsUnion) {
2592 CharUnits UnionIvarSize = FieldSize;
2593 if (UnionIvarSize > MaxUnionSize) {
2594 MaxUnionSize = UnionIvarSize;
2595 MaxField = Field;
2596 MaxFieldOffset = FieldOffset;
2597 }
2598 } else {
2599 UpdateRunSkipBlockVars(false,
2600 getBlockCaptureLifetime(FQT, ByrefLayout),
2601 BytePos + FieldOffset,
2602 FieldSize);
2603 }
2604 }
2605
2606 if (LastFieldBitfieldOrUnnamed) {
2607 if (LastFieldBitfieldOrUnnamed->isBitField()) {
2608 // Last field was a bitfield. Must update the info.
2609 uint64_t BitFieldSize
2610 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2611 unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2612 ((BitFieldSize % ByteSizeInBits) != 0);
2613 CharUnits Size = CharUnits::fromQuantity(UnsSize);
2614 Size += LastBitfieldOrUnnamedOffset;
2615 UpdateRunSkipBlockVars(false,
2616 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2617 ByrefLayout),
2618 BytePos + LastBitfieldOrUnnamedOffset,
2619 Size);
2620 } else {
2621 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed")(static_cast <bool> (!LastFieldBitfieldOrUnnamed->getIdentifier
() &&"Expected unnamed") ? void (0) : __assert_fail (
"!LastFieldBitfieldOrUnnamed->getIdentifier() &&\"Expected unnamed\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2621, __extension__ __PRETTY_FUNCTION__))
;
2622 // Last field was unnamed. Must update skip info.
2623 CharUnits FieldSize
2624 = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2625 UpdateRunSkipBlockVars(false,
2626 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2627 ByrefLayout),
2628 BytePos + LastBitfieldOrUnnamedOffset,
2629 FieldSize);
2630 }
2631 }
2632
2633 if (MaxField)
2634 UpdateRunSkipBlockVars(false,
2635 getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2636 BytePos + MaxFieldOffset,
2637 MaxUnionSize);
2638}
2639
2640void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2641 CharUnits BytePos,
2642 bool &HasUnion,
2643 bool ByrefLayout) {
2644 const RecordDecl *RD = RT->getDecl();
26
Called C++ object pointer is null
2645 SmallVector<const FieldDecl*, 16> Fields(RD->fields());
2646 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2647 const llvm::StructLayout *RecLayout =
2648 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
8
'Ty' is a 'StructType'
2649
2650 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
9
Calling 'CGObjCCommonMac::BuildRCRecordLayout'
2651}
2652
2653/// InlineLayoutInstruction - This routine produce an inline instruction for the
2654/// block variable layout if it can. If not, it returns 0. Rules are as follow:
2655/// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2656/// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2657/// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2658/// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2659/// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2660/// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2661/// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2662uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2663 SmallVectorImpl<unsigned char> &Layout) {
2664 uint64_t Result = 0;
2665 if (Layout.size() <= 3) {
2666 unsigned size = Layout.size();
2667 unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2668 unsigned char inst;
2669 enum BLOCK_LAYOUT_OPCODE opcode ;
2670 switch (size) {
2671 case 3:
2672 inst = Layout[0];
2673 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2674 if (opcode == BLOCK_LAYOUT_STRONG)
2675 strong_word_count = (inst & 0xF)+1;
2676 else
2677 return 0;
2678 inst = Layout[1];
2679 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2680 if (opcode == BLOCK_LAYOUT_BYREF)
2681 byref_word_count = (inst & 0xF)+1;
2682 else
2683 return 0;
2684 inst = Layout[2];
2685 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2686 if (opcode == BLOCK_LAYOUT_WEAK)
2687 weak_word_count = (inst & 0xF)+1;
2688 else
2689 return 0;
2690 break;
2691
2692 case 2:
2693 inst = Layout[0];
2694 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2695 if (opcode == BLOCK_LAYOUT_STRONG) {
2696 strong_word_count = (inst & 0xF)+1;
2697 inst = Layout[1];
2698 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2699 if (opcode == BLOCK_LAYOUT_BYREF)
2700 byref_word_count = (inst & 0xF)+1;
2701 else if (opcode == BLOCK_LAYOUT_WEAK)
2702 weak_word_count = (inst & 0xF)+1;
2703 else
2704 return 0;
2705 }
2706 else if (opcode == BLOCK_LAYOUT_BYREF) {
2707 byref_word_count = (inst & 0xF)+1;
2708 inst = Layout[1];
2709 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2710 if (opcode == BLOCK_LAYOUT_WEAK)
2711 weak_word_count = (inst & 0xF)+1;
2712 else
2713 return 0;
2714 }
2715 else
2716 return 0;
2717 break;
2718
2719 case 1:
2720 inst = Layout[0];
2721 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2722 if (opcode == BLOCK_LAYOUT_STRONG)
2723 strong_word_count = (inst & 0xF)+1;
2724 else if (opcode == BLOCK_LAYOUT_BYREF)
2725 byref_word_count = (inst & 0xF)+1;
2726 else if (opcode == BLOCK_LAYOUT_WEAK)
2727 weak_word_count = (inst & 0xF)+1;
2728 else
2729 return 0;
2730 break;
2731
2732 default:
2733 return 0;
2734 }
2735
2736 // Cannot inline when any of the word counts is 15. Because this is one less
2737 // than the actual work count (so 15 means 16 actual word counts),
2738 // and we can only display 0 thru 15 word counts.
2739 if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2740 return 0;
2741
2742 unsigned count =
2743 (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2744
2745 if (size == count) {
2746 if (strong_word_count)
2747 Result = strong_word_count;
2748 Result <<= 4;
2749 if (byref_word_count)
2750 Result += byref_word_count;
2751 Result <<= 4;
2752 if (weak_word_count)
2753 Result += weak_word_count;
2754 }
2755 }
2756 return Result;
2757}
2758
2759llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2760 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2761 if (RunSkipBlockVars.empty())
2762 return nullPtr;
2763 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2764 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2765 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2766
2767 // Sort on byte position; captures might not be allocated in order,
2768 // and unions can do funny things.
2769 llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2770 SmallVector<unsigned char, 16> Layout;
2771
2772 unsigned size = RunSkipBlockVars.size();
2773 for (unsigned i = 0; i < size; i++) {
2774 enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2775 CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2776 CharUnits end_byte_pos = start_byte_pos;
2777 unsigned j = i+1;
2778 while (j < size) {
2779 if (opcode == RunSkipBlockVars[j].opcode) {
2780 end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2781 i++;
2782 }
2783 else
2784 break;
2785 }
2786 CharUnits size_in_bytes =
2787 end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2788 if (j < size) {
2789 CharUnits gap =
2790 RunSkipBlockVars[j].block_var_bytepos -
2791 RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2792 size_in_bytes += gap;
2793 }
2794 CharUnits residue_in_bytes = CharUnits::Zero();
2795 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2796 residue_in_bytes = size_in_bytes % WordSizeInBytes;
2797 size_in_bytes -= residue_in_bytes;
2798 opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2799 }
2800
2801 unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2802 while (size_in_words >= 16) {
2803 // Note that value in imm. is one less that the actual
2804 // value. So, 0xf means 16 words follow!
2805 unsigned char inst = (opcode << 4) | 0xf;
2806 Layout.push_back(inst);
2807 size_in_words -= 16;
2808 }
2809 if (size_in_words > 0) {
2810 // Note that value in imm. is one less that the actual
2811 // value. So, we subtract 1 away!
2812 unsigned char inst = (opcode << 4) | (size_in_words-1);
2813 Layout.push_back(inst);
2814 }
2815 if (residue_in_bytes > CharUnits::Zero()) {
2816 unsigned char inst =
2817 (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2818 Layout.push_back(inst);
2819 }
2820 }
2821
2822 while (!Layout.empty()) {
2823 unsigned char inst = Layout.back();
2824 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2825 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2826 Layout.pop_back();
2827 else
2828 break;
2829 }
2830
2831 uint64_t Result = InlineLayoutInstruction(Layout);
2832 if (Result != 0) {
2833 // Block variable layout instruction has been inlined.
2834 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2835 if (ComputeByrefLayout)
2836 printf("\n Inline BYREF variable layout: ");
2837 else
2838 printf("\n Inline block variable layout: ");
2839 printf("0x0%" PRIx64"l" "x" "", Result);
2840 if (auto numStrong = (Result & 0xF00) >> 8)
2841 printf(", BL_STRONG:%d", (int) numStrong);
2842 if (auto numByref = (Result & 0x0F0) >> 4)
2843 printf(", BL_BYREF:%d", (int) numByref);
2844 if (auto numWeak = (Result & 0x00F) >> 0)
2845 printf(", BL_WEAK:%d", (int) numWeak);
2846 printf(", BL_OPERATOR:0\n");
2847 }
2848 return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2849 }
2850
2851 unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2852 Layout.push_back(inst);
2853 std::string BitMap;
2854 for (unsigned i = 0, e = Layout.size(); i != e; i++)
2855 BitMap += Layout[i];
2856
2857 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2858 if (ComputeByrefLayout)
2859 printf("\n Byref variable layout: ");
2860 else
2861 printf("\n Block variable layout: ");
2862 for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2863 unsigned char inst = BitMap[i];
2864 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2865 unsigned delta = 1;
2866 switch (opcode) {
2867 case BLOCK_LAYOUT_OPERATOR:
2868 printf("BL_OPERATOR:");
2869 delta = 0;
2870 break;
2871 case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2872 printf("BL_NON_OBJECT_BYTES:");
2873 break;
2874 case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2875 printf("BL_NON_OBJECT_WORD:");
2876 break;
2877 case BLOCK_LAYOUT_STRONG:
2878 printf("BL_STRONG:");
2879 break;
2880 case BLOCK_LAYOUT_BYREF:
2881 printf("BL_BYREF:");
2882 break;
2883 case BLOCK_LAYOUT_WEAK:
2884 printf("BL_WEAK:");
2885 break;
2886 case BLOCK_LAYOUT_UNRETAINED:
2887 printf("BL_UNRETAINED:");
2888 break;
2889 }
2890 // Actual value of word count is one more that what is in the imm.
2891 // field of the instruction
2892 printf("%d", (inst & 0xf) + delta);
2893 if (i < e-1)
2894 printf(", ");
2895 else
2896 printf("\n");
2897 }
2898 }
2899
2900 auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
2901 /*ForceNonFragileABI=*/true,
2902 /*NullTerminate=*/false);
2903 return getConstantGEP(VMContext, Entry, 0, 0);
2904}
2905
2906static std::string getBlockLayoutInfoString(
2907 const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars,
2908 bool HasCopyDisposeHelpers) {
2909 std::string Str;
2910 for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) {
2911 if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) {
2912 // Copy/dispose helpers don't have any information about
2913 // __unsafe_unretained captures, so unconditionally concatenate a string.
2914 Str += "u";
2915 } else if (HasCopyDisposeHelpers) {
2916 // Information about __strong, __weak, or byref captures has already been
2917 // encoded into the names of the copy/dispose helpers. We have to add a
2918 // string here only when the copy/dispose helpers aren't generated (which
2919 // happens when the block is non-escaping).
2920 continue;
2921 } else {
2922 switch (R.opcode) {
2923 case CGObjCCommonMac::BLOCK_LAYOUT_STRONG:
2924 Str += "s";
2925 break;
2926 case CGObjCCommonMac::BLOCK_LAYOUT_BYREF:
2927 Str += "r";
2928 break;
2929 case CGObjCCommonMac::BLOCK_LAYOUT_WEAK:
2930 Str += "w";
2931 break;
2932 default:
2933 continue;
2934 }
2935 }
2936 Str += llvm::to_string(R.block_var_bytepos.getQuantity());
2937 Str += "l" + llvm::to_string(R.block_var_size.getQuantity());
2938 }
2939 return Str;
2940}
2941
2942void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM,
2943 const CGBlockInfo &blockInfo) {
2944 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC)(static_cast <bool> (CGM.getLangOpts().getGC() == LangOptions
::NonGC) ? void (0) : __assert_fail ("CGM.getLangOpts().getGC() == LangOptions::NonGC"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2944, __extension__ __PRETTY_FUNCTION__))
;
2945
2946 RunSkipBlockVars.clear();
2947 bool hasUnion = false;
2948
2949 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2950 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2951 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2952
2953 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2954
2955 // Calculate the basic layout of the block structure.
2956 const llvm::StructLayout *layout =
2957 CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2958
2959 // Ignore the optional 'this' capture: C++ objects are not assumed
2960 // to be GC'ed.
2961 if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2962 UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2963 blockInfo.BlockHeaderForcedGapOffset,
2964 blockInfo.BlockHeaderForcedGapSize);
2965 // Walk the captured variables.
2966 for (const auto &CI : blockDecl->captures()) {
2967 const VarDecl *variable = CI.getVariable();
2968 QualType type = variable->getType();
2969
2970 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2971
2972 // Ignore constant captures.
2973 if (capture.isConstant()) continue;
2974
2975 CharUnits fieldOffset =
2976 CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2977
2978 assert(!type->isArrayType() && "array variable should not be caught")(static_cast <bool> (!type->isArrayType() &&
"array variable should not be caught") ? void (0) : __assert_fail
("!type->isArrayType() && \"array variable should not be caught\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 2978, __extension__ __PRETTY_FUNCTION__))
;
2979 if (!CI.isByRef())
2980 if (const RecordType *record = type->getAs<RecordType>()) {
2981 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2982 continue;
2983 }
2984 CharUnits fieldSize;
2985 if (CI.isByRef())
2986 fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2987 else
2988 fieldSize = CGM.getContext().getTypeSizeInChars(type);
2989 UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2990 fieldOffset, fieldSize);
2991 }
2992}
2993
2994llvm::Constant *
2995CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2996 const CGBlockInfo &blockInfo) {
2997 fillRunSkipBlockVars(CGM, blockInfo);
2998 return getBitmapBlockLayout(false);
2999}
3000
3001std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM,
3002 const CGBlockInfo &blockInfo) {
3003 fillRunSkipBlockVars(CGM, blockInfo);
3004 return getBlockLayoutInfoString(RunSkipBlockVars,
3005 blockInfo.needsCopyDisposeHelpers());
3006}
3007
3008llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
3009 QualType T) {
3010 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC)(static_cast <bool> (CGM.getLangOpts().getGC() == LangOptions
::NonGC) ? void (0) : __assert_fail ("CGM.getLangOpts().getGC() == LangOptions::NonGC"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3010, __extension__ __PRETTY_FUNCTION__))
;
1
Assuming the condition is true
2
'?' condition is true
3011 assert(!T->isArrayType() && "__block array variable should not be caught")(static_cast <bool> (!T->isArrayType() && "__block array variable should not be caught"
) ? void (0) : __assert_fail ("!T->isArrayType() && \"__block array variable should not be caught\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3011, __extension__ __PRETTY_FUNCTION__))
;
3
'?' condition is true
3012 CharUnits fieldOffset;
3013 RunSkipBlockVars.clear();
3014 bool hasUnion = false;
3015 if (const RecordType *record = T->getAs<RecordType>()) {
4
Assuming the object is a 'RecordType'
5
Assuming 'record' is non-null
6
Taking true branch
3016 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
7
Calling 'CGObjCCommonMac::BuildRCBlockVarRecordLayout'
3017 llvm::Constant *Result = getBitmapBlockLayout(true);
3018 if (isa<llvm::ConstantInt>(Result))
3019 Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
3020 return Result;
3021 }
3022 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
3023 return nullPtr;
3024}
3025
3026llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
3027 const ObjCProtocolDecl *PD) {
3028 // FIXME: I don't understand why gcc generates this, or where it is
3029 // resolved. Investigate. Its also wasteful to look this up over and over.
3030 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3031
3032 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
3033 ObjCTypes.getExternalProtocolPtrTy());
3034}
3035
3036void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
3037 // FIXME: We shouldn't need this, the protocol decl should contain enough
3038 // information to tell us whether this was a declaration or a definition.
3039 DefinedProtocols.insert(PD->getIdentifier());
3040
3041 // If we have generated a forward reference to this protocol, emit
3042 // it now. Otherwise do nothing, the protocol objects are lazily
3043 // emitted.
3044 if (Protocols.count(PD->getIdentifier()))
3045 GetOrEmitProtocol(PD);
3046}
3047
3048llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
3049 if (DefinedProtocols.count(PD->getIdentifier()))
3050 return GetOrEmitProtocol(PD);
3051
3052 return GetOrEmitProtocolRef(PD);
3053}
3054
3055llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
3056 CodeGenFunction &CGF,
3057 const ObjCInterfaceDecl *ID,
3058 ObjCCommonTypesHelper &ObjCTypes) {
3059 llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn();
3060
3061 llvm::Value *className = CGF.CGM
3062 .GetAddrOfConstantCString(std::string(
3063 ID->getObjCRuntimeNameAsString()))
3064 .getPointer();
3065 ASTContext &ctx = CGF.CGM.getContext();
3066 className =
3067 CGF.Builder.CreateBitCast(className,
3068 CGF.ConvertType(
3069 ctx.getPointerType(ctx.CharTy.withConst())));
3070 llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
3071 call->setDoesNotThrow();
3072 return call;
3073}
3074
3075/*
3076// Objective-C 1.0 extensions
3077struct _objc_protocol {
3078struct _objc_protocol_extension *isa;
3079char *protocol_name;
3080struct _objc_protocol_list *protocol_list;
3081struct _objc__method_prototype_list *instance_methods;
3082struct _objc__method_prototype_list *class_methods
3083};
3084
3085See EmitProtocolExtension().
3086*/
3087llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
3088 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
3089
3090 // Early exit if a defining object has already been generated.
3091 if (Entry && Entry->hasInitializer())
3092 return Entry;
3093
3094 // Use the protocol definition, if there is one.
3095 if (const ObjCProtocolDecl *Def = PD->getDefinition())
3096 PD = Def;
3097
3098 // FIXME: I don't understand why gcc generates this, or where it is
3099 // resolved. Investigate. Its also wasteful to look this up over and over.
3100 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3101
3102 // Construct method lists.
3103 auto methodLists = ProtocolMethodLists::get(PD);
3104
3105 ConstantInitBuilder builder(CGM);
3106 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
3107 values.add(EmitProtocolExtension(PD, methodLists));
3108 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
3109 values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
3110 PD->protocol_begin(), PD->protocol_end()));
3111 values.add(methodLists.emitMethodList(this, PD,
3112 ProtocolMethodLists::RequiredInstanceMethods));
3113 values.add(methodLists.emitMethodList(this, PD,
3114 ProtocolMethodLists::RequiredClassMethods));
3115
3116 if (Entry) {
3117 // Already created, update the initializer.
3118 assert(Entry->hasPrivateLinkage())(static_cast <bool> (Entry->hasPrivateLinkage()) ? void
(0) : __assert_fail ("Entry->hasPrivateLinkage()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3118, __extension__ __PRETTY_FUNCTION__))
;
3119 values.finishAndSetAsInitializer(Entry);
3120 } else {
3121 Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
3122 CGM.getPointerAlign(),
3123 /*constant*/ false,
3124 llvm::GlobalValue::PrivateLinkage);
3125 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3126
3127 Protocols[PD->getIdentifier()] = Entry;
3128 }
3129 CGM.addCompilerUsedGlobal(Entry);
3130
3131 return Entry;
3132}
3133
3134llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
3135 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
3136
3137 if (!Entry) {
3138 // We use the initializer as a marker of whether this is a forward
3139 // reference or not. At module finalization we add the empty
3140 // contents for protocols which were referenced but never defined.
3141 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
3142 false, llvm::GlobalValue::PrivateLinkage,
3143 nullptr, "OBJC_PROTOCOL_" + PD->getName());
3144 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3145 // FIXME: Is this necessary? Why only for protocol?
3146 Entry->setAlignment(llvm::Align(4));
3147 }
3148
3149 return Entry;
3150}
3151
3152/*
3153 struct _objc_protocol_extension {
3154 uint32_t size;
3155 struct objc_method_description_list *optional_instance_methods;
3156 struct objc_method_description_list *optional_class_methods;
3157 struct objc_property_list *instance_properties;
3158 const char ** extendedMethodTypes;
3159 struct objc_property_list *class_properties;
3160 };
3161*/
3162llvm::Constant *
3163CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
3164 const ProtocolMethodLists &methodLists) {
3165 auto optInstanceMethods =
3166 methodLists.emitMethodList(this, PD,
3167 ProtocolMethodLists::OptionalInstanceMethods);
3168 auto optClassMethods =
3169 methodLists.emitMethodList(this, PD,
3170 ProtocolMethodLists::OptionalClassMethods);
3171
3172 auto extendedMethodTypes =
3173 EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3174 methodLists.emitExtendedTypesArray(this),
3175 ObjCTypes);
3176
3177 auto instanceProperties =
3178 EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3179 ObjCTypes, false);
3180 auto classProperties =
3181 EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3182 PD, ObjCTypes, true);
3183
3184 // Return null if no extension bits are used.
3185 if (optInstanceMethods->isNullValue() &&
3186 optClassMethods->isNullValue() &&
3187 extendedMethodTypes->isNullValue() &&
3188 instanceProperties->isNullValue() &&
3189 classProperties->isNullValue()) {
3190 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3191 }
3192
3193 uint64_t size =
3194 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3195
3196 ConstantInitBuilder builder(CGM);
3197 auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3198 values.addInt(ObjCTypes.IntTy, size);
3199 values.add(optInstanceMethods);
3200 values.add(optClassMethods);
3201 values.add(instanceProperties);
3202 values.add(extendedMethodTypes);
3203 values.add(classProperties);
3204
3205 // No special section, but goes in llvm.used
3206 return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3207 StringRef(), CGM.getPointerAlign(), true);
3208}
3209
3210/*
3211 struct objc_protocol_list {
3212 struct objc_protocol_list *next;
3213 long count;
3214 Protocol *list[];
3215 };
3216*/
3217llvm::Constant *
3218CGObjCMac::EmitProtocolList(Twine name,
3219 ObjCProtocolDecl::protocol_iterator begin,
3220 ObjCProtocolDecl::protocol_iterator end) {
3221 // Just return null for empty protocol lists
3222 auto PDs = GetRuntimeProtocolList(begin, end);
3223 if (PDs.empty())
3224 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3225
3226 ConstantInitBuilder builder(CGM);
3227 auto values = builder.beginStruct();
3228
3229 // This field is only used by the runtime.
3230 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3231
3232 // Reserve a slot for the count.
3233 auto countSlot = values.addPlaceholder();
3234
3235 auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3236 for (const auto *Proto : PDs)
3237 refsArray.add(GetProtocolRef(Proto));
3238
3239 auto count = refsArray.size();
3240
3241 // This list is null terminated.
3242 refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3243
3244 refsArray.finishAndAddTo(values);
3245 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3246
3247 StringRef section;
3248 if (CGM.getTriple().isOSBinFormatMachO())
3249 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3250
3251 llvm::GlobalVariable *GV =
3252 CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3253 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3254}
3255
3256static void
3257PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
3258 SmallVectorImpl<const ObjCPropertyDecl *> &Properties,
3259 const ObjCProtocolDecl *Proto,
3260 bool IsClassProperty) {
3261 for (const auto *PD : Proto->properties()) {
3262 if (IsClassProperty != PD->isClassProperty())
3263 continue;
3264 if (!PropertySet.insert(PD->getIdentifier()).second)
3265 continue;
3266 Properties.push_back(PD);
3267 }
3268
3269 for (const auto *P : Proto->protocols())
3270 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3271}
3272
3273/*
3274 struct _objc_property {
3275 const char * const name;
3276 const char * const attributes;
3277 };
3278
3279 struct _objc_property_list {
3280 uint32_t entsize; // sizeof (struct _objc_property)
3281 uint32_t prop_count;
3282 struct _objc_property[prop_count];
3283 };
3284*/
3285llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3286 const Decl *Container,
3287 const ObjCContainerDecl *OCD,
3288 const ObjCCommonTypesHelper &ObjCTypes,
3289 bool IsClassProperty) {
3290 if (IsClassProperty) {
3291 // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3292 // with deployment target < 9.0.
3293 const llvm::Triple &Triple = CGM.getTarget().getTriple();
3294 if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
3295 (Triple.isiOS() && Triple.isOSVersionLT(9)))
3296 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3297 }
3298
3299 SmallVector<const ObjCPropertyDecl *, 16> Properties;
3300 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3301
3302 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3303 for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3304 for (auto *PD : ClassExt->properties()) {
3305 if (IsClassProperty != PD->isClassProperty())
3306 continue;
3307 if (PD->isDirectProperty())
3308 continue;
3309 PropertySet.insert(PD->getIdentifier());
3310 Properties.push_back(PD);
3311 }
3312
3313 for (const auto *PD : OCD->properties()) {
3314 if (IsClassProperty != PD->isClassProperty())
3315 continue;
3316 // Don't emit duplicate metadata for properties that were already in a
3317 // class extension.
3318 if (!PropertySet.insert(PD->getIdentifier()).second)
3319 continue;
3320 if (PD->isDirectProperty())
3321 continue;
3322 Properties.push_back(PD);
3323 }
3324
3325 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3326 for (const auto *P : OID->all_referenced_protocols())
3327 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3328 }
3329 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3330 for (const auto *P : CD->protocols())
3331 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3332 }
3333
3334 // Return null for empty list.
3335 if (Properties.empty())
3336 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3337
3338 unsigned propertySize =
3339 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3340
3341 ConstantInitBuilder builder(CGM);
3342 auto values = builder.beginStruct();
3343 values.addInt(ObjCTypes.IntTy, propertySize);
3344 values.addInt(ObjCTypes.IntTy, Properties.size());
3345 auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3346 for (auto PD : Properties) {
3347 auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3348 property.add(GetPropertyName(PD->getIdentifier()));
3349 property.add(GetPropertyTypeString(PD, Container));
3350 property.finishAndAddTo(propertiesArray);
3351 }
3352 propertiesArray.finishAndAddTo(values);
3353
3354 StringRef Section;
3355 if (CGM.getTriple().isOSBinFormatMachO())
3356 Section = (ObjCABI == 2) ? "__DATA, __objc_const"
3357 : "__OBJC,__property,regular,no_dead_strip";
3358
3359 llvm::GlobalVariable *GV =
3360 CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3361 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3362}
3363
3364llvm::Constant *
3365CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3366 ArrayRef<llvm::Constant*> MethodTypes,
3367 const ObjCCommonTypesHelper &ObjCTypes) {
3368 // Return null for empty list.
3369 if (MethodTypes.empty())
3370 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3371
3372 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3373 MethodTypes.size());
3374 llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3375
3376 StringRef Section;
3377 if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
3378 Section = "__DATA, __objc_const";
3379
3380 llvm::GlobalVariable *GV =
3381 CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3382 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3383}
3384
3385/*
3386 struct _objc_category {
3387 char *category_name;
3388 char *class_name;
3389 struct _objc_method_list *instance_methods;
3390 struct _objc_method_list *class_methods;
3391 struct _objc_protocol_list *protocols;
3392 uint32_t size; // <rdar://4585769>
3393 struct _objc_property_list *instance_properties;
3394 struct _objc_property_list *class_properties;
3395 };
3396*/
3397void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3398 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3399
3400 // FIXME: This is poor design, the OCD should have a pointer to the category
3401 // decl. Additionally, note that Category can be null for the @implementation
3402 // w/o an @interface case. Sema should just create one for us as it does for
3403 // @implementation so everyone else can live life under a clear blue sky.
3404 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3405 const ObjCCategoryDecl *Category =
3406 Interface->FindCategoryDeclaration(OCD->getIdentifier());
3407
3408 SmallString<256> ExtName;
3409 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3410 << OCD->getName();
3411
3412 ConstantInitBuilder Builder(CGM);
3413 auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3414
3415 enum {
3416 InstanceMethods,
3417 ClassMethods,
3418 NumMethodLists
3419 };
3420 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3421 for (const auto *MD : OCD->methods()) {
3422 if (!MD->isDirectMethod())
3423 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3424 }
3425
3426 Values.add(GetClassName(OCD->getName()));
3427 Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3428 LazySymbols.insert(Interface->getIdentifier());
3429
3430 Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3431 Methods[InstanceMethods]));
3432 Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3433 Methods[ClassMethods]));
3434 if (Category) {
3435 Values.add(
3436 EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3437 Category->protocol_begin(), Category->protocol_end()));
3438 } else {
3439 Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3440 }
3441 Values.addInt(ObjCTypes.IntTy, Size);
3442
3443 // If there is no category @interface then there can be no properties.
3444 if (Category) {
3445 Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
3446 OCD, Category, ObjCTypes, false));
3447 Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3448 OCD, Category, ObjCTypes, true));
3449 } else {
3450 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3451 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3452 }
3453
3454 llvm::GlobalVariable *GV =
3455 CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3456 "__OBJC,__category,regular,no_dead_strip",
3457 CGM.getPointerAlign(), true);
3458 DefinedCategories.push_back(GV);
3459 DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3460 // method definition entries must be clear for next implementation.
3461 MethodDefinitions.clear();
3462}
3463
3464enum FragileClassFlags {
3465 /// Apparently: is not a meta-class.
3466 FragileABI_Class_Factory = 0x00001,
3467
3468 /// Is a meta-class.
3469 FragileABI_Class_Meta = 0x00002,
3470
3471 /// Has a non-trivial constructor or destructor.
3472 FragileABI_Class_HasCXXStructors = 0x02000,
3473
3474 /// Has hidden visibility.
3475 FragileABI_Class_Hidden = 0x20000,
3476
3477 /// Class implementation was compiled under ARC.
3478 FragileABI_Class_CompiledByARC = 0x04000000,
3479
3480 /// Class implementation was compiled under MRC and has MRC weak ivars.
3481 /// Exclusive with CompiledByARC.
3482 FragileABI_Class_HasMRCWeakIvars = 0x08000000,
3483};
3484
3485enum NonFragileClassFlags {
3486 /// Is a meta-class.
3487 NonFragileABI_Class_Meta = 0x00001,
3488
3489 /// Is a root class.
3490 NonFragileABI_Class_Root = 0x00002,
3491
3492 /// Has a non-trivial constructor or destructor.
3493 NonFragileABI_Class_HasCXXStructors = 0x00004,
3494
3495 /// Has hidden visibility.
3496 NonFragileABI_Class_Hidden = 0x00010,
3497
3498 /// Has the exception attribute.
3499 NonFragileABI_Class_Exception = 0x00020,
3500
3501 /// (Obsolete) ARC-specific: this class has a .release_ivars method
3502 NonFragileABI_Class_HasIvarReleaser = 0x00040,
3503
3504 /// Class implementation was compiled under ARC.
3505 NonFragileABI_Class_CompiledByARC = 0x00080,
3506
3507 /// Class has non-trivial destructors, but zero-initialization is okay.
3508 NonFragileABI_Class_HasCXXDestructorOnly = 0x00100,
3509
3510 /// Class implementation was compiled under MRC and has MRC weak ivars.
3511 /// Exclusive with CompiledByARC.
3512 NonFragileABI_Class_HasMRCWeakIvars = 0x00200,
3513};
3514
3515static bool hasWeakMember(QualType type) {
3516 if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3517 return true;
3518 }
3519
3520 if (auto recType = type->getAs<RecordType>()) {
3521 for (auto field : recType->getDecl()->fields()) {
3522 if (hasWeakMember(field->getType()))
3523 return true;
3524 }
3525 }
3526
3527 return false;
3528}
3529
3530/// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3531/// (and actually fill in a layout string) if we really do have any
3532/// __weak ivars.
3533static bool hasMRCWeakIvars(CodeGenModule &CGM,
3534 const ObjCImplementationDecl *ID) {
3535 if (!CGM.getLangOpts().ObjCWeak) return false;
3536 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC)(static_cast <bool> (CGM.getLangOpts().getGC() == LangOptions
::NonGC) ? void (0) : __assert_fail ("CGM.getLangOpts().getGC() == LangOptions::NonGC"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3536, __extension__ __PRETTY_FUNCTION__))
;
3537
3538 for (const ObjCIvarDecl *ivar =
3539 ID->getClassInterface()->all_declared_ivar_begin();
3540 ivar; ivar = ivar->getNextIvar()) {
3541 if (hasWeakMember(ivar->getType()))
3542 return true;
3543 }
3544
3545 return false;
3546}
3547
3548/*
3549 struct _objc_class {
3550 Class isa;
3551 Class super_class;
3552 const char *name;
3553 long version;
3554 long info;
3555 long instance_size;
3556 struct _objc_ivar_list *ivars;
3557 struct _objc_method_list *methods;
3558 struct _objc_cache *cache;
3559 struct _objc_protocol_list *protocols;
3560 // Objective-C 1.0 extensions (<rdr://4585769>)
3561 const char *ivar_layout;
3562 struct _objc_class_ext *ext;
3563 };
3564
3565 See EmitClassExtension();
3566*/
3567void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3568 IdentifierInfo *RuntimeName =
3569 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
3570 DefinedSymbols.insert(RuntimeName);
3571
3572 std::string ClassName = ID->getNameAsString();
3573 // FIXME: Gross
3574 ObjCInterfaceDecl *Interface =
3575 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3576 llvm::Constant *Protocols =
3577 EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3578 Interface->all_referenced_protocol_begin(),
3579 Interface->all_referenced_protocol_end());
3580 unsigned Flags = FragileABI_Class_Factory;
3581 if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3582 Flags |= FragileABI_Class_HasCXXStructors;
3583
3584 bool hasMRCWeak = false;
3585
3586 if (CGM.getLangOpts().ObjCAutoRefCount)
3587 Flags |= FragileABI_Class_CompiledByARC;
3588 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3589 Flags |= FragileABI_Class_HasMRCWeakIvars;
3590
3591 CharUnits Size =
3592 CGM.getContext().getASTObjCImplementationLayout(ID).getSize();
3593
3594 // FIXME: Set CXX-structors flag.
3595 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3596 Flags |= FragileABI_Class_Hidden;
3597
3598 enum {
3599 InstanceMethods,
3600 ClassMethods,
3601 NumMethodLists
3602 };
3603 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3604 for (const auto *MD : ID->methods()) {
3605 if (!MD->isDirectMethod())
3606 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3607 }
3608
3609 for (const auto *PID : ID->property_impls()) {
3610 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3611 if (PID->getPropertyDecl()->isDirectProperty())
3612 continue;
3613 if (ObjCMethodDecl *MD = PID->getGetterMethodDecl())
3614 if (GetMethodDefinition(MD))
3615 Methods[InstanceMethods].push_back(MD);
3616 if (ObjCMethodDecl *MD = PID->getSetterMethodDecl())
3617 if (GetMethodDefinition(MD))
3618 Methods[InstanceMethods].push_back(MD);
3619 }
3620 }
3621
3622 ConstantInitBuilder builder(CGM);
3623 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3624 values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3625 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3626 // Record a reference to the super class.
3627 LazySymbols.insert(Super->getIdentifier());
3628
3629 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3630 ObjCTypes.ClassPtrTy);
3631 } else {
3632 values.addNullPointer(ObjCTypes.ClassPtrTy);
3633 }
3634 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3635 // Version is always 0.
3636 values.addInt(ObjCTypes.LongTy, 0);
3637 values.addInt(ObjCTypes.LongTy, Flags);
3638 values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3639 values.add(EmitIvarList(ID, false));
3640 values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3641 Methods[InstanceMethods]));
3642 // cache is always NULL.
3643 values.addNullPointer(ObjCTypes.CachePtrTy);
3644 values.add(Protocols);
3645 values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3646 values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3647 /*isMetaclass*/ false));
3648
3649 std::string Name("OBJC_CLASS_");
3650 Name += ClassName;
3651 const char *Section = "__OBJC,__class,regular,no_dead_strip";
3652 // Check for a forward reference.
3653 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3654 if (GV) {
3655 assert(GV->getValueType() == ObjCTypes.ClassTy &&(static_cast <bool> (GV->getValueType() == ObjCTypes
.ClassTy && "Forward metaclass reference has incorrect type."
) ? void (0) : __assert_fail ("GV->getValueType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3656, __extension__ __PRETTY_FUNCTION__))
3656 "Forward metaclass reference has incorrect type.")(static_cast <bool> (GV->getValueType() == ObjCTypes
.ClassTy && "Forward metaclass reference has incorrect type."
) ? void (0) : __assert_fail ("GV->getValueType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3656, __extension__ __PRETTY_FUNCTION__))
;
3657 values.finishAndSetAsInitializer(GV);
3658 GV->setSection(Section);
3659 GV->setAlignment(CGM.getPointerAlign().getAsAlign());
3660 CGM.addCompilerUsedGlobal(GV);
3661 } else
3662 GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3663 DefinedClasses.push_back(GV);
3664 ImplementedClasses.push_back(Interface);
3665 // method definition entries must be clear for next implementation.
3666 MethodDefinitions.clear();
3667}
3668
3669llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3670 llvm::Constant *Protocols,
3671 ArrayRef<const ObjCMethodDecl*> Methods) {
3672 unsigned Flags = FragileABI_Class_Meta;
3673 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3674
3675 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3676 Flags |= FragileABI_Class_Hidden;
3677
3678 ConstantInitBuilder builder(CGM);
3679 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3680 // The isa for the metaclass is the root of the hierarchy.
3681 const ObjCInterfaceDecl *Root = ID->getClassInterface();
3682 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3683 Root = Super;
3684 values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3685 ObjCTypes.ClassPtrTy);
3686 // The super class for the metaclass is emitted as the name of the
3687 // super class. The runtime fixes this up to point to the
3688 // *metaclass* for the super class.
3689 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3690 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3691 ObjCTypes.ClassPtrTy);
3692 } else {
3693 values.addNullPointer(ObjCTypes.ClassPtrTy);
3694 }
3695 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3696 // Version is always 0.
3697 values.addInt(ObjCTypes.LongTy, 0);
3698 values.addInt(ObjCTypes.LongTy, Flags);
3699 values.addInt(ObjCTypes.LongTy, Size);
3700 values.add(EmitIvarList(ID, true));
3701 values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3702 Methods));
3703 // cache is always NULL.
3704 values.addNullPointer(ObjCTypes.CachePtrTy);
3705 values.add(Protocols);
3706 // ivar_layout for metaclass is always NULL.
3707 values.addNullPointer(ObjCTypes.Int8PtrTy);
3708 // The class extension is used to store class properties for metaclasses.
3709 values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3710 /*isMetaclass*/true));
3711
3712 std::string Name("OBJC_METACLASS_");
3713 Name += ID->getName();
3714
3715 // Check for a forward reference.
3716 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3717 if (GV) {
3718 assert(GV->getValueType() == ObjCTypes.ClassTy &&(static_cast <bool> (GV->getValueType() == ObjCTypes
.ClassTy && "Forward metaclass reference has incorrect type."
) ? void (0) : __assert_fail ("GV->getValueType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3719, __extension__ __PRETTY_FUNCTION__))
3719 "Forward metaclass reference has incorrect type.")(static_cast <bool> (GV->getValueType() == ObjCTypes
.ClassTy && "Forward metaclass reference has incorrect type."
) ? void (0) : __assert_fail ("GV->getValueType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3719, __extension__ __PRETTY_FUNCTION__))
;
3720 values.finishAndSetAsInitializer(GV);
3721 } else {
3722 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3723 /*constant*/ false,
3724 llvm::GlobalValue::PrivateLinkage);
3725 }
3726 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3727 CGM.addCompilerUsedGlobal(GV);
3728
3729 return GV;
3730}
3731
3732llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3733 std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3734
3735 // FIXME: Should we look these up somewhere other than the module. Its a bit
3736 // silly since we only generate these while processing an implementation, so
3737 // exactly one pointer would work if know when we entered/exitted an
3738 // implementation block.
3739
3740 // Check for an existing forward reference.
3741 // Previously, metaclass with internal linkage may have been defined.
3742 // pass 'true' as 2nd argument so it is returned.
3743 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3744 if (!GV)
3745 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3746 llvm::GlobalValue::PrivateLinkage, nullptr,
3747 Name);
3748
3749 assert(GV->getValueType() == ObjCTypes.ClassTy &&(static_cast <bool> (GV->getValueType() == ObjCTypes
.ClassTy && "Forward metaclass reference has incorrect type."
) ? void (0) : __assert_fail ("GV->getValueType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3750, __extension__ __PRETTY_FUNCTION__))
3750 "Forward metaclass reference has incorrect type.")(static_cast <bool> (GV->getValueType() == ObjCTypes
.ClassTy && "Forward metaclass reference has incorrect type."
) ? void (0) : __assert_fail ("GV->getValueType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3750, __extension__ __PRETTY_FUNCTION__))
;
3751 return GV;
3752}
3753
3754llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3755 std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3756 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3757
3758 if (!GV)
3759 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3760 llvm::GlobalValue::PrivateLinkage, nullptr,
3761 Name);
3762
3763 assert(GV->getValueType() == ObjCTypes.ClassTy &&(static_cast <bool> (GV->getValueType() == ObjCTypes
.ClassTy && "Forward class metadata reference has incorrect type."
) ? void (0) : __assert_fail ("GV->getValueType() == ObjCTypes.ClassTy && \"Forward class metadata reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3764, __extension__ __PRETTY_FUNCTION__))
3764 "Forward class metadata reference has incorrect type.")(static_cast <bool> (GV->getValueType() == ObjCTypes
.ClassTy && "Forward class metadata reference has incorrect type."
) ? void (0) : __assert_fail ("GV->getValueType() == ObjCTypes.ClassTy && \"Forward class metadata reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3764, __extension__ __PRETTY_FUNCTION__))
;
3765 return GV;
3766}
3767
3768/*
3769 Emit a "class extension", which in this specific context means extra
3770 data that doesn't fit in the normal fragile-ABI class structure, and
3771 has nothing to do with the language concept of a class extension.
3772
3773 struct objc_class_ext {
3774 uint32_t size;
3775 const char *weak_ivar_layout;
3776 struct _objc_property_list *properties;
3777 };
3778*/
3779llvm::Constant *
3780CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3781 CharUnits InstanceSize, bool hasMRCWeakIvars,
3782 bool isMetaclass) {
3783 // Weak ivar layout.
3784 llvm::Constant *layout;
3785 if (isMetaclass) {
3786 layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3787 } else {
3788 layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3789 hasMRCWeakIvars);
3790 }
3791
3792 // Properties.
3793 llvm::Constant *propertyList =
3794 EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_")
3795 : Twine("_OBJC_$_PROP_LIST_"))
3796 + ID->getName(),
3797 ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3798
3799 // Return null if no extension bits are used.
3800 if (layout->isNullValue() && propertyList->isNullValue()) {
3801 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3802 }
3803
3804 uint64_t size =
3805 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3806
3807 ConstantInitBuilder builder(CGM);
3808 auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3809 values.addInt(ObjCTypes.IntTy, size);
3810 values.add(layout);
3811 values.add(propertyList);
3812
3813 return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3814 "__OBJC,__class_ext,regular,no_dead_strip",
3815 CGM.getPointerAlign(), true);
3816}
3817
3818/*
3819 struct objc_ivar {
3820 char *ivar_name;
3821 char *ivar_type;
3822 int ivar_offset;
3823 };
3824
3825 struct objc_ivar_list {
3826 int ivar_count;
3827 struct objc_ivar list[count];
3828 };
3829*/
3830llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3831 bool ForClass) {
3832 // When emitting the root class GCC emits ivar entries for the
3833 // actual class structure. It is not clear if we need to follow this
3834 // behavior; for now lets try and get away with not doing it. If so,
3835 // the cleanest solution would be to make up an ObjCInterfaceDecl
3836 // for the class.
3837 if (ForClass)
3838 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3839
3840 const ObjCInterfaceDecl *OID = ID->getClassInterface();
3841
3842 ConstantInitBuilder builder(CGM);
3843 auto ivarList = builder.beginStruct();
3844 auto countSlot = ivarList.addPlaceholder();
3845 auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3846
3847 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3848 IVD; IVD = IVD->getNextIvar()) {
3849 // Ignore unnamed bit-fields.
3850 if (!IVD->getDeclName())
3851 continue;
3852
3853 auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3854 ivar.add(GetMethodVarName(IVD->getIdentifier()));
3855 ivar.add(GetMethodVarType(IVD));
3856 ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3857 ivar.finishAndAddTo(ivars);
3858 }
3859
3860 // Return null for empty list.
3861 auto count = ivars.size();
3862 if (count == 0) {
3863 ivars.abandon();
3864 ivarList.abandon();
3865 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3866 }
3867
3868 ivars.finishAndAddTo(ivarList);
3869 ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3870
3871 llvm::GlobalVariable *GV;
3872 if (ForClass)
3873 GV =
3874 CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3875 "__OBJC,__class_vars,regular,no_dead_strip",
3876 CGM.getPointerAlign(), true);
3877 else
3878 GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3879 "__OBJC,__instance_vars,regular,no_dead_strip",
3880 CGM.getPointerAlign(), true);
3881 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3882}
3883
3884/// Build a struct objc_method_description constant for the given method.
3885///
3886/// struct objc_method_description {
3887/// SEL method_name;
3888/// char *method_types;
3889/// };
3890void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3891 const ObjCMethodDecl *MD) {
3892 auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3893 description.addBitCast(GetMethodVarName(MD->getSelector()),
3894 ObjCTypes.SelectorPtrTy);
3895 description.add(GetMethodVarType(MD));
3896 description.finishAndAddTo(builder);
3897}
3898
3899/// Build a struct objc_method constant for the given method.
3900///
3901/// struct objc_method {
3902/// SEL method_name;
3903/// char *method_types;
3904/// void *method;
3905/// };
3906void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3907 const ObjCMethodDecl *MD) {
3908 llvm::Function *fn = GetMethodDefinition(MD);
3909 assert(fn && "no definition registered for method")(static_cast <bool> (fn && "no definition registered for method"
) ? void (0) : __assert_fail ("fn && \"no definition registered for method\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 3909, __extension__ __PRETTY_FUNCTION__))
;
3910
3911 auto method = builder.beginStruct(ObjCTypes.MethodTy);
3912 method.addBitCast(GetMethodVarName(MD->getSelector()),
3913 ObjCTypes.SelectorPtrTy);
3914 method.add(GetMethodVarType(MD));
3915 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3916 method.finishAndAddTo(builder);
3917}
3918
3919/// Build a struct objc_method_list or struct objc_method_description_list,
3920/// as appropriate.
3921///
3922/// struct objc_method_list {
3923/// struct objc_method_list *obsolete;
3924/// int count;
3925/// struct objc_method methods_list[count];
3926/// };
3927///
3928/// struct objc_method_description_list {
3929/// int count;
3930/// struct objc_method_description list[count];
3931/// };
3932llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3933 ArrayRef<const ObjCMethodDecl *> methods) {
3934 StringRef prefix;
3935 StringRef section;
3936 bool forProtocol = false;
3937 switch (MLT) {
3938 case MethodListType::CategoryInstanceMethods:
3939 prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3940 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3941 forProtocol = false;
3942 break;
3943 case MethodListType::CategoryClassMethods:
3944 prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3945 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3946 forProtocol = false;
3947 break;
3948 case MethodListType::InstanceMethods:
3949 prefix = "OBJC_INSTANCE_METHODS_";
3950 section = "__OBJC,__inst_meth,regular,no_dead_strip";
3951 forProtocol = false;
3952 break;
3953 case MethodListType::ClassMethods:
3954 prefix = "OBJC_CLASS_METHODS_";
3955 section = "__OBJC,__cls_meth,regular,no_dead_strip";
3956 forProtocol = false;
3957 break;
3958 case MethodListType::ProtocolInstanceMethods:
3959 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3960 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3961 forProtocol = true;
3962 break;
3963 case MethodListType::ProtocolClassMethods:
3964 prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3965 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3966 forProtocol = true;
3967 break;
3968 case MethodListType::OptionalProtocolInstanceMethods:
3969 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3970 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3971 forProtocol = true;
3972 break;
3973 case MethodListType::OptionalProtocolClassMethods:
3974 prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3975 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3976 forProtocol = true;
3977 break;
3978 }
3979
3980 // Return null for empty list.
3981 if (methods.empty())
3982 return llvm::Constant::getNullValue(forProtocol
3983 ? ObjCTypes.MethodDescriptionListPtrTy
3984 : ObjCTypes.MethodListPtrTy);
3985
3986 // For protocols, this is an objc_method_description_list, which has
3987 // a slightly different structure.
3988 if (forProtocol) {
3989 ConstantInitBuilder builder(CGM);
3990 auto values = builder.beginStruct();
3991 values.addInt(ObjCTypes.IntTy, methods.size());
3992 auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3993 for (auto MD : methods) {
3994 emitMethodDescriptionConstant(methodArray, MD);
3995 }
3996 methodArray.finishAndAddTo(values);
3997
3998 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3999 CGM.getPointerAlign(), true);
4000 return llvm::ConstantExpr::getBitCast(GV,
4001 ObjCTypes.MethodDescriptionListPtrTy);
4002 }
4003
4004 // Otherwise, it's an objc_method_list.
4005 ConstantInitBuilder builder(CGM);
4006 auto values = builder.beginStruct();
4007 values.addNullPointer(ObjCTypes.Int8PtrTy);
4008 values.addInt(ObjCTypes.IntTy, methods.size());
4009 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
4010 for (auto MD : methods) {
4011 if (!MD->isDirectMethod())
4012 emitMethodConstant(methodArray, MD);
4013 }
4014 methodArray.finishAndAddTo(values);
4015
4016 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
4017 CGM.getPointerAlign(), true);
4018 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
4019}
4020
4021llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
4022 const ObjCContainerDecl *CD) {
4023 llvm::Function *Method;
4024
4025 if (OMD->isDirectMethod()) {
4026 Method = GenerateDirectMethod(OMD, CD);
4027 } else {
4028 auto Name = getSymbolNameForMethod(OMD);
4029
4030 CodeGenTypes &Types = CGM.getTypes();
4031 llvm::FunctionType *MethodTy =
4032 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
4033 Method =
4034 llvm::Function::Create(MethodTy, llvm::GlobalValue::InternalLinkage,
4035 Name, &CGM.getModule());
4036 }
4037
4038 MethodDefinitions.insert(std::make_pair(OMD, Method));
4039
4040 return Method;
4041}
4042
4043llvm::Function *
4044CGObjCCommonMac::GenerateDirectMethod(const ObjCMethodDecl *OMD,
4045 const ObjCContainerDecl *CD) {
4046 auto *COMD = OMD->getCanonicalDecl();
4047 auto I = DirectMethodDefinitions.find(COMD);
4048 llvm::Function *OldFn = nullptr, *Fn = nullptr;
4049
4050 if (I != DirectMethodDefinitions.end()) {
4051 // Objective-C allows for the declaration and implementation types
4052 // to differ slightly.
4053 //
4054 // If we're being asked for the Function associated for a method
4055 // implementation, a previous value might have been cached
4056 // based on the type of the canonical declaration.
4057 //
4058 // If these do not match, then we'll replace this function with
4059 // a new one that has the proper type below.
4060 if (!OMD->getBody() || COMD->getReturnType() == OMD->getReturnType())
4061 return I->second;
4062 OldFn = I->second;
4063 }
4064
4065 CodeGenTypes &Types = CGM.getTypes();
4066 llvm::FunctionType *MethodTy =
4067 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
4068
4069 if (OldFn) {
4070 Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
4071 "", &CGM.getModule());
4072 Fn->takeName(OldFn);
4073 OldFn->replaceAllUsesWith(
4074 llvm::ConstantExpr::getBitCast(Fn, OldFn->getType()));
4075 OldFn->eraseFromParent();
4076
4077 // Replace the cached function in the map.
4078 I->second = Fn;
4079 } else {
4080 auto Name = getSymbolNameForMethod(OMD, /*include category*/ false);
4081
4082 Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
4083 Name, &CGM.getModule());
4084 DirectMethodDefinitions.insert(std::make_pair(COMD, Fn));
4085 }
4086
4087 return Fn;
4088}
4089
4090void CGObjCCommonMac::GenerateDirectMethodPrologue(
4091 CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD,
4092 const ObjCContainerDecl *CD) {
4093 auto &Builder = CGF.Builder;
4094 bool ReceiverCanBeNull = true;
4095 auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
4096 auto selfValue = Builder.CreateLoad(selfAddr);
4097
4098 // Generate:
4099 //
4100 // /* for class methods only to force class lazy initialization */
4101 // self = [self self];
4102 //
4103 // /* unless the receiver is never NULL */
4104 // if (self == nil) {
4105 // return (ReturnType){ };
4106 // }
4107 //
4108 // _cmd = @selector(...)
4109 // ...
4110
4111 if (OMD->isClassMethod()) {
4112 const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD);
4113 assert(OID &&(static_cast <bool> (OID && "GenerateDirectMethod() should be called with the Class Interface"
) ? void (0) : __assert_fail ("OID && \"GenerateDirectMethod() should be called with the Class Interface\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4114, __extension__ __PRETTY_FUNCTION__))
4114 "GenerateDirectMethod() should be called with the Class Interface")(static_cast <bool> (OID && "GenerateDirectMethod() should be called with the Class Interface"
) ? void (0) : __assert_fail ("OID && \"GenerateDirectMethod() should be called with the Class Interface\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4114, __extension__ __PRETTY_FUNCTION__))
;
4115 Selector SelfSel = GetNullarySelector("self", CGM.getContext());
4116 auto ResultType = CGF.getContext().getObjCIdType();
4117 RValue result;
4118 CallArgList Args;
4119
4120 // TODO: If this method is inlined, the caller might know that `self` is
4121 // already initialized; for example, it might be an ordinary Objective-C
4122 // method which always receives an initialized `self`, or it might have just
4123 // forced initialization on its own.
4124 //
4125 // We should find a way to eliminate this unnecessary initialization in such
4126 // cases in LLVM.
4127 result = GeneratePossiblySpecializedMessageSend(
4128 CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID,
4129 nullptr, true);
4130 Builder.CreateStore(result.getScalarVal(), selfAddr);
4131
4132 // Nullable `Class` expressions cannot be messaged with a direct method
4133 // so the only reason why the receive can be null would be because
4134 // of weak linking.
4135 ReceiverCanBeNull = isWeakLinkedClass(OID);
4136 }
4137
4138 if (ReceiverCanBeNull) {
4139 llvm::BasicBlock *SelfIsNilBlock =
4140 CGF.createBasicBlock("objc_direct_method.self_is_nil");
4141 llvm::BasicBlock *ContBlock =
4142 CGF.createBasicBlock("objc_direct_method.cont");
4143
4144 // if (self == nil) {
4145 auto selfTy = cast<llvm::PointerType>(selfValue->getType());
4146 auto Zero = llvm::ConstantPointerNull::get(selfTy);
4147
4148 llvm::MDBuilder MDHelper(CGM.getLLVMContext());
4149 Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock,
4150 ContBlock, MDHelper.createBranchWeights(1, 1 << 20));
4151
4152 CGF.EmitBlock(SelfIsNilBlock);
4153
4154 // return (ReturnType){ };
4155 auto retTy = OMD->getReturnType();
4156 Builder.SetInsertPoint(SelfIsNilBlock);
4157 if (!retTy->isVoidType()) {
4158 CGF.EmitNullInitialization(CGF.ReturnValue, retTy);
4159 }
4160 CGF.EmitBranchThroughCleanup(CGF.ReturnBlock);
4161 // }
4162
4163 // rest of the body
4164 CGF.EmitBlock(ContBlock);
4165 Builder.SetInsertPoint(ContBlock);
4166 }
4167
4168 // only synthesize _cmd if it's referenced
4169 if (OMD->getCmdDecl()->isUsed()) {
4170 Builder.CreateStore(GetSelector(CGF, OMD),
4171 CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
4172 }
4173}
4174
4175llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4176 ConstantStructBuilder &Init,
4177 StringRef Section,
4178 CharUnits Align,
4179 bool AddToUsed) {
4180 llvm::GlobalValue::LinkageTypes LT =
4181 getLinkageTypeForObjCMetadata(CGM, Section);
4182 llvm::GlobalVariable *GV =
4183 Init.finishAndCreateGlobal(Name, Align, /*constant*/ false, LT);
4184 if (!Section.empty())
4185 GV->setSection(Section);
4186 if (AddToUsed)
4187 CGM.addCompilerUsedGlobal(GV);
4188 return GV;
4189}
4190
4191llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4192 llvm::Constant *Init,
4193 StringRef Section,
4194 CharUnits Align,
4195 bool AddToUsed) {
4196 llvm::Type *Ty = Init->getType();
4197 llvm::GlobalValue::LinkageTypes LT =
4198 getLinkageTypeForObjCMetadata(CGM, Section);
4199 llvm::GlobalVariable *GV =
4200 new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name);
4201 if (!Section.empty())
4202 GV->setSection(Section);
4203 GV->setAlignment(Align.getAsAlign());
4204 if (AddToUsed)
4205 CGM.addCompilerUsedGlobal(GV);
4206 return GV;
4207}
4208
4209llvm::GlobalVariable *
4210CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
4211 bool ForceNonFragileABI,
4212 bool NullTerminate) {
4213 StringRef Label;
4214 switch (Type) {
4215 case ObjCLabelType::ClassName: Label = "OBJC_CLASS_NAME_"; break;
4216 case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
4217 case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
4218 case ObjCLabelType::PropertyName: Label = "OBJC_PROP_NAME_ATTR_"; break;
4219 }
4220
4221 bool NonFragile = ForceNonFragileABI || isNonFragileABI();
4222
4223 StringRef Section;
4224 switch (Type) {
4225 case ObjCLabelType::ClassName:
4226 Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
4227 : "__TEXT,__cstring,cstring_literals";
4228 break;
4229 case ObjCLabelType::MethodVarName:
4230 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4231 : "__TEXT,__cstring,cstring_literals";
4232 break;
4233 case ObjCLabelType::MethodVarType:
4234 Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
4235 : "__TEXT,__cstring,cstring_literals";
4236 break;
4237 case ObjCLabelType::PropertyName:
4238 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4239 : "__TEXT,__cstring,cstring_literals";
4240 break;
4241 }
4242
4243 llvm::Constant *Value =
4244 llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
4245 llvm::GlobalVariable *GV =
4246 new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
4247 /*isConstant=*/true,
4248 llvm::GlobalValue::PrivateLinkage, Value, Label);
4249 if (CGM.getTriple().isOSBinFormatMachO())
4250 GV->setSection(Section);
4251 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4252 GV->setAlignment(CharUnits::One().getAsAlign());
4253 CGM.addCompilerUsedGlobal(GV);
4254
4255 return GV;
4256}
4257
4258llvm::Function *CGObjCMac::ModuleInitFunction() {
4259 // Abuse this interface function as a place to finalize.
4260 FinishModule();
4261 return nullptr;
4262}
4263
4264llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() {
4265 return ObjCTypes.getGetPropertyFn();
4266}
4267
4268llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() {
4269 return ObjCTypes.getSetPropertyFn();
4270}
4271
4272llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
4273 bool copy) {
4274 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
4275}
4276
4277llvm::FunctionCallee CGObjCMac::GetGetStructFunction() {
4278 return ObjCTypes.getCopyStructFn();
4279}
4280
4281llvm::FunctionCallee CGObjCMac::GetSetStructFunction() {
4282 return ObjCTypes.getCopyStructFn();
4283}
4284
4285llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() {
4286 return ObjCTypes.getCppAtomicObjectFunction();
4287}
4288
4289llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() {
4290 return ObjCTypes.getCppAtomicObjectFunction();
4291}
4292
4293llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() {
4294 return ObjCTypes.getEnumerationMutationFn();
4295}
4296
4297void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
4298 return EmitTryOrSynchronizedStmt(CGF, S);
4299}
4300
4301void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
4302 const ObjCAtSynchronizedStmt &S) {
4303 return EmitTryOrSynchronizedStmt(CGF, S);
4304}
4305
4306namespace {
4307 struct PerformFragileFinally final : EHScopeStack::Cleanup {
4308 const Stmt &S;
4309 Address SyncArgSlot;
4310 Address CallTryExitVar;
4311 Address ExceptionData;
4312 ObjCTypesHelper &ObjCTypes;
4313 PerformFragileFinally(const Stmt *S,
4314 Address SyncArgSlot,
4315 Address CallTryExitVar,
4316 Address ExceptionData,
4317 ObjCTypesHelper *ObjCTypes)
4318 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4319 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4320
4321 void Emit(CodeGenFunction &CGF, Flags flags) override {
4322 // Check whether we need to call objc_exception_try_exit.
4323 // In optimized code, this branch will always be folded.
4324 llvm::BasicBlock *FinallyCallExit =
4325 CGF.createBasicBlock("finally.call_exit");
4326 llvm::BasicBlock *FinallyNoCallExit =
4327 CGF.createBasicBlock("finally.no_call_exit");
4328 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4329 FinallyCallExit, FinallyNoCallExit);
4330
4331 CGF.EmitBlock(FinallyCallExit);
4332 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4333 ExceptionData.getPointer());
4334
4335 CGF.EmitBlock(FinallyNoCallExit);
4336
4337 if (isa<ObjCAtTryStmt>(S)) {
4338 if (const ObjCAtFinallyStmt* FinallyStmt =
4339 cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4340 // Don't try to do the @finally if this is an EH cleanup.
4341 if (flags.isForEHCleanup()) return;
4342
4343 // Save the current cleanup destination in case there's
4344 // control flow inside the finally statement.
4345 llvm::Value *CurCleanupDest =
4346 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
4347
4348 CGF.EmitStmt(FinallyStmt->getFinallyBody());
4349
4350 if (CGF.HaveInsertPoint()) {
4351 CGF.Builder.CreateStore(CurCleanupDest,
4352 CGF.getNormalCleanupDestSlot());
4353 } else {
4354 // Currently, the end of the cleanup must always exist.
4355 CGF.EnsureInsertPoint();
4356 }
4357 }
4358 } else {
4359 // Emit objc_sync_exit(expr); as finally's sole statement for
4360 // @synchronized.
4361 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4362 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4363 }
4364 }
4365 };
4366
4367 class FragileHazards {
4368 CodeGenFunction &CGF;
4369 SmallVector<llvm::Value*, 20> Locals;
4370 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4371
4372 llvm::InlineAsm *ReadHazard;
4373 llvm::InlineAsm *WriteHazard;
4374
4375 llvm::FunctionType *GetAsmFnType();
4376
4377 void collectLocals();
4378 void emitReadHazard(CGBuilderTy &Builder);
4379
4380 public:
4381 FragileHazards(CodeGenFunction &CGF);
4382
4383 void emitWriteHazard();
4384 void emitHazardsInNewBlocks();
4385 };
4386} // end anonymous namespace
4387
4388/// Create the fragile-ABI read and write hazards based on the current
4389/// state of the function, which is presumed to be immediately prior
4390/// to a @try block. These hazards are used to maintain correct
4391/// semantics in the face of optimization and the fragile ABI's
4392/// cavalier use of setjmp/longjmp.
4393FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4394 collectLocals();
4395
4396 if (Locals.empty()) return;
4397
4398 // Collect all the blocks in the function.
4399 for (llvm::Function::iterator
4400 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
4401 BlocksBeforeTry.insert(&*I);
4402
4403 llvm::FunctionType *AsmFnTy = GetAsmFnType();
4404
4405 // Create a read hazard for the allocas. This inhibits dead-store
4406 // optimizations and forces the values to memory. This hazard is
4407 // inserted before any 'throwing' calls in the protected scope to
4408 // reflect the possibility that the variables might be read from the
4409 // catch block if the call throws.
4410 {
4411 std::string Constraint;
4412 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4413 if (I) Constraint += ',';
4414 Constraint += "*m";
4415 }
4416
4417 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4418 }
4419
4420 // Create a write hazard for the allocas. This inhibits folding
4421 // loads across the hazard. This hazard is inserted at the
4422 // beginning of the catch path to reflect the possibility that the
4423 // variables might have been written within the protected scope.
4424 {
4425 std::string Constraint;
4426 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4427 if (I) Constraint += ',';
4428 Constraint += "=*m";
4429 }
4430
4431 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4432 }
4433}
4434
4435/// Emit a write hazard at the current location.
4436void FragileHazards::emitWriteHazard() {
4437 if (Locals.empty()) return;
4438
4439 CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4440}
4441
4442void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4443 assert(!Locals.empty())(static_cast <bool> (!Locals.empty()) ? void (0) : __assert_fail
("!Locals.empty()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4443, __extension__ __PRETTY_FUNCTION__))
;
4444 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4445 call->setDoesNotThrow();
4446 call->setCallingConv(CGF.getRuntimeCC());
4447}
4448
4449/// Emit read hazards in all the protected blocks, i.e. all the blocks
4450/// which have been inserted since the beginning of the try.
4451void FragileHazards::emitHazardsInNewBlocks() {
4452 if (Locals.empty()) return;
4453
4454 CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4455
4456 // Iterate through all blocks, skipping those prior to the try.
4457 for (llvm::Function::iterator
4458 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
4459 llvm::BasicBlock &BB = *FI;
4460 if (BlocksBeforeTry.count(&BB)) continue;
4461
4462 // Walk through all the calls in the block.
4463 for (llvm::BasicBlock::iterator
4464 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
4465 llvm::Instruction &I = *BI;
4466
4467 // Ignore instructions that aren't non-intrinsic calls.
4468 // These are the only calls that can possibly call longjmp.
4469 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I))
4470 continue;
4471 if (isa<llvm::IntrinsicInst>(I))
4472 continue;
4473
4474 // Ignore call sites marked nounwind. This may be questionable,
4475 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4476 if (cast<llvm::CallBase>(I).doesNotThrow())
4477 continue;
4478
4479 // Insert a read hazard before the call. This will ensure that
4480 // any writes to the locals are performed before making the
4481 // call. If the call throws, then this is sufficient to
4482 // guarantee correctness as long as it doesn't also write to any
4483 // locals.
4484 Builder.SetInsertPoint(&BB, BI);
4485 emitReadHazard(Builder);
4486 }
4487 }
4488}
4489
4490static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
4491 if (V.isValid()) S.insert(V.getPointer());
4492}
4493
4494void FragileHazards::collectLocals() {
4495 // Compute a set of allocas to ignore.
4496 llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4497 addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4498 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4499
4500 // Collect all the allocas currently in the function. This is
4501 // probably way too aggressive.
4502 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4503 for (llvm::BasicBlock::iterator
4504 I = Entry.begin(), E = Entry.end(); I != E; ++I)
4505 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
4506 Locals.push_back(&*I);
4507}
4508
4509llvm::FunctionType *FragileHazards::GetAsmFnType() {
4510 SmallVector<llvm::Type *, 16> tys(Locals.size());
4511 for (unsigned i = 0, e = Locals.size(); i != e; ++i)
4512 tys[i] = Locals[i]->getType();
4513 return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4514}
4515
4516/*
4517
4518 Objective-C setjmp-longjmp (sjlj) Exception Handling
4519 --
4520
4521 A catch buffer is a setjmp buffer plus:
4522 - a pointer to the exception that was caught
4523 - a pointer to the previous exception data buffer
4524 - two pointers of reserved storage
4525 Therefore catch buffers form a stack, with a pointer to the top
4526 of the stack kept in thread-local storage.
4527
4528 objc_exception_try_enter pushes a catch buffer onto the EH stack.
4529 objc_exception_try_exit pops the given catch buffer, which is
4530 required to be the top of the EH stack.
4531 objc_exception_throw pops the top of the EH stack, writes the
4532 thrown exception into the appropriate field, and longjmps
4533 to the setjmp buffer. It crashes the process (with a printf
4534 and an abort()) if there are no catch buffers on the stack.
4535 objc_exception_extract just reads the exception pointer out of the
4536 catch buffer.
4537
4538 There's no reason an implementation couldn't use a light-weight
4539 setjmp here --- something like __builtin_setjmp, but API-compatible
4540 with the heavyweight setjmp. This will be more important if we ever
4541 want to implement correct ObjC/C++ exception interactions for the
4542 fragile ABI.
4543
4544 Note that for this use of setjmp/longjmp to be correct, we may need
4545 to mark some local variables volatile: if a non-volatile local
4546 variable is modified between the setjmp and the longjmp, it has
4547 indeterminate value. For the purposes of LLVM IR, it may be
4548 sufficient to make loads and stores within the @try (to variables
4549 declared outside the @try) volatile. This is necessary for
4550 optimized correctness, but is not currently being done; this is
4551 being tracked as rdar://problem/8160285
4552
4553 The basic framework for a @try-catch-finally is as follows:
4554 {
4555 objc_exception_data d;
4556 id _rethrow = null;
4557 bool _call_try_exit = true;
4558
4559 objc_exception_try_enter(&d);
4560 if (!setjmp(d.jmp_buf)) {
4561 ... try body ...
4562 } else {
4563 // exception path
4564 id _caught = objc_exception_extract(&d);
4565
4566 // enter new try scope for handlers
4567 if (!setjmp(d.jmp_buf)) {
4568 ... match exception and execute catch blocks ...
4569
4570 // fell off end, rethrow.
4571 _rethrow = _caught;
4572 ... jump-through-finally to finally_rethrow ...
4573 } else {
4574 // exception in catch block
4575 _rethrow = objc_exception_extract(&d);
4576 _call_try_exit = false;
4577 ... jump-through-finally to finally_rethrow ...
4578 }
4579 }
4580 ... jump-through-finally to finally_end ...
4581
4582 finally:
4583 if (_call_try_exit)
4584 objc_exception_try_exit(&d);
4585
4586 ... finally block ....
4587 ... dispatch to finally destination ...
4588
4589 finally_rethrow:
4590 objc_exception_throw(_rethrow);
4591
4592 finally_end:
4593 }
4594
4595 This framework differs slightly from the one gcc uses, in that gcc
4596 uses _rethrow to determine if objc_exception_try_exit should be called
4597 and if the object should be rethrown. This breaks in the face of
4598 throwing nil and introduces unnecessary branches.
4599
4600 We specialize this framework for a few particular circumstances:
4601
4602 - If there are no catch blocks, then we avoid emitting the second
4603 exception handling context.
4604
4605 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4606 e)) we avoid emitting the code to rethrow an uncaught exception.
4607
4608 - FIXME: If there is no @finally block we can do a few more
4609 simplifications.
4610
4611 Rethrows and Jumps-Through-Finally
4612 --
4613
4614 '@throw;' is supported by pushing the currently-caught exception
4615 onto ObjCEHStack while the @catch blocks are emitted.
4616
4617 Branches through the @finally block are handled with an ordinary
4618 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
4619 exceptions are not compatible with C++ exceptions, and this is
4620 hardly the only place where this will go wrong.
4621
4622 @synchronized(expr) { stmt; } is emitted as if it were:
4623 id synch_value = expr;
4624 objc_sync_enter(synch_value);
4625 @try { stmt; } @finally { objc_sync_exit(synch_value); }
4626*/
4627
4628void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4629 const Stmt &S) {
4630 bool isTry = isa<ObjCAtTryStmt>(S);
4631
4632 // A destination for the fall-through edges of the catch handlers to
4633 // jump to.
4634 CodeGenFunction::JumpDest FinallyEnd =
4635 CGF.getJumpDestInCurrentScope("finally.end");
4636
4637 // A destination for the rethrow edge of the catch handlers to jump
4638 // to.
4639 CodeGenFunction::JumpDest FinallyRethrow =
4640 CGF.getJumpDestInCurrentScope("finally.rethrow");
4641
4642 // For @synchronized, call objc_sync_enter(sync.expr). The
4643 // evaluation of the expression must occur before we enter the
4644 // @synchronized. We can't avoid a temp here because we need the
4645 // value to be preserved. If the backend ever does liveness
4646 // correctly after setjmp, this will be unnecessary.
4647 Address SyncArgSlot = Address::invalid();
4648 if (!isTry) {
4649 llvm::Value *SyncArg =
4650 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4651 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4652 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4653
4654 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4655 CGF.getPointerAlign(), "sync.arg");
4656 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4657 }
4658
4659 // Allocate memory for the setjmp buffer. This needs to be kept
4660 // live throughout the try and catch blocks.
4661 Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4662 CGF.getPointerAlign(),
4663 "exceptiondata.ptr");
4664
4665 // Create the fragile hazards. Note that this will not capture any
4666 // of the allocas required for exception processing, but will
4667 // capture the current basic block (which extends all the way to the
4668 // setjmp call) as "before the @try".
4669 FragileHazards Hazards(CGF);
4670
4671 // Create a flag indicating whether the cleanup needs to call
4672 // objc_exception_try_exit. This is true except when
4673 // - no catches match and we're branching through the cleanup
4674 // just to rethrow the exception, or
4675 // - a catch matched and we're falling out of the catch handler.
4676 // The setjmp-safety rule here is that we should always store to this
4677 // variable in a place that dominates the branch through the cleanup
4678 // without passing through any setjmps.
4679 Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4680 CharUnits::One(),
4681 "_call_try_exit");
4682
4683 // A slot containing the exception to rethrow. Only needed when we
4684 // have both a @catch and a @finally.
4685 Address PropagatingExnVar = Address::invalid();
4686
4687 // Push a normal cleanup to leave the try scope.
4688 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4689 SyncArgSlot,
4690 CallTryExitVar,
4691 ExceptionData,
4692 &ObjCTypes);
4693
4694 // Enter a try block:
4695 // - Call objc_exception_try_enter to push ExceptionData on top of
4696 // the EH stack.
4697 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4698 ExceptionData.getPointer());
4699
4700 // - Call setjmp on the exception data buffer.
4701 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4702 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4703 llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4704 ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4705 "setjmp_buffer");
4706 llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4707 ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4708 SetJmpResult->setCanReturnTwice();
4709
4710 // If setjmp returned 0, enter the protected block; otherwise,
4711 // branch to the handler.
4712 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4713 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4714 llvm::Value *DidCatch =
4715 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4716 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4717
4718 // Emit the protected block.
4719 CGF.EmitBlock(TryBlock);
4720 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4721 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4722 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4723
4724 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4725
4726 // Emit the exception handler block.
4727 CGF.EmitBlock(TryHandler);
4728
4729 // Don't optimize loads of the in-scope locals across this point.
4730 Hazards.emitWriteHazard();
4731
4732 // For a @synchronized (or a @try with no catches), just branch
4733 // through the cleanup to the rethrow block.
4734 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4735 // Tell the cleanup not to re-pop the exit.
4736 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4737 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4738
4739 // Otherwise, we have to match against the caught exceptions.
4740 } else {
4741 // Retrieve the exception object. We may emit multiple blocks but
4742 // nothing can cross this so the value is already in SSA form.
4743 llvm::CallInst *Caught =
4744 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4745 ExceptionData.getPointer(), "caught");
4746
4747 // Push the exception to rethrow onto the EH value stack for the
4748 // benefit of any @throws in the handlers.
4749 CGF.ObjCEHValueStack.push_back(Caught);
4750
4751 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4752
4753 bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4754
4755 llvm::BasicBlock *CatchBlock = nullptr;
4756 llvm::BasicBlock *CatchHandler = nullptr;
4757 if (HasFinally) {
4758 // Save the currently-propagating exception before
4759 // objc_exception_try_enter clears the exception slot.
4760 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4761 CGF.getPointerAlign(),
4762 "propagating_exception");
4763 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4764
4765 // Enter a new exception try block (in case a @catch block
4766 // throws an exception).
4767 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4768 ExceptionData.getPointer());
4769
4770 llvm::CallInst *SetJmpResult =
4771 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4772 SetJmpBuffer, "setjmp.result");
4773 SetJmpResult->setCanReturnTwice();
4774
4775 llvm::Value *Threw =
4776 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4777
4778 CatchBlock = CGF.createBasicBlock("catch");
4779 CatchHandler = CGF.createBasicBlock("catch_for_catch");
4780 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4781
4782 CGF.EmitBlock(CatchBlock);
4783 }
4784
4785 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4786
4787 // Handle catch list. As a special case we check if everything is
4788 // matched and avoid generating code for falling off the end if
4789 // so.
4790 bool AllMatched = false;
4791 for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
4792 const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4793
4794 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4795 const ObjCObjectPointerType *OPT = nullptr;
4796
4797 // catch(...) always matches.
4798 if (!CatchParam) {
4799 AllMatched = true;
4800 } else {
4801 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4802
4803 // catch(id e) always matches under this ABI, since only
4804 // ObjC exceptions end up here in the first place.
4805 // FIXME: For the time being we also match id<X>; this should
4806 // be rejected by Sema instead.
4807 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4808 AllMatched = true;
4809 }
4810
4811 // If this is a catch-all, we don't need to test anything.
4812 if (AllMatched) {
4813 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4814
4815 if (CatchParam) {
4816 CGF.EmitAutoVarDecl(*CatchParam);
4817 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?")(static_cast <bool> (CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"
) ? void (0) : __assert_fail ("CGF.HaveInsertPoint() && \"DeclStmt destroyed insert point?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4817, __extension__ __PRETTY_FUNCTION__))
;
4818
4819 // These types work out because ConvertType(id) == i8*.
4820 EmitInitOfCatchParam(CGF, Caught, CatchParam);
4821 }
4822
4823 CGF.EmitStmt(CatchStmt->getCatchBody());
4824
4825 // The scope of the catch variable ends right here.
4826 CatchVarCleanups.ForceCleanup();
4827
4828 CGF.EmitBranchThroughCleanup(FinallyEnd);
4829 break;
4830 }
4831
4832 assert(OPT && "Unexpected non-object pointer type in @catch")(static_cast <bool> (OPT && "Unexpected non-object pointer type in @catch"
) ? void (0) : __assert_fail ("OPT && \"Unexpected non-object pointer type in @catch\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4832, __extension__ __PRETTY_FUNCTION__))
;
4833 const ObjCObjectType *ObjTy = OPT->getObjectType();
4834
4835 // FIXME: @catch (Class c) ?
4836 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4837 assert(IDecl && "Catch parameter must have Objective-C type!")(static_cast <bool> (IDecl && "Catch parameter must have Objective-C type!"
) ? void (0) : __assert_fail ("IDecl && \"Catch parameter must have Objective-C type!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4837, __extension__ __PRETTY_FUNCTION__))
;
4838
4839 // Check if the @catch block matches the exception object.
4840 llvm::Value *Class = EmitClassRef(CGF, IDecl);
4841
4842 llvm::Value *matchArgs[] = { Class, Caught };
4843 llvm::CallInst *Match =
4844 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4845 matchArgs, "match");
4846
4847 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4848 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4849
4850 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4851 MatchedBlock, NextCatchBlock);
4852
4853 // Emit the @catch block.
4854 CGF.EmitBlock(MatchedBlock);
4855
4856 // Collect any cleanups for the catch variable. The scope lasts until
4857 // the end of the catch body.
4858 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4859
4860 CGF.EmitAutoVarDecl(*CatchParam);
4861 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?")(static_cast <bool> (CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"
) ? void (0) : __assert_fail ("CGF.HaveInsertPoint() && \"DeclStmt destroyed insert point?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4861, __extension__ __PRETTY_FUNCTION__))
;
4862
4863 // Initialize the catch variable.
4864 llvm::Value *Tmp =
4865 CGF.Builder.CreateBitCast(Caught,
4866 CGF.ConvertType(CatchParam->getType()));
4867 EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4868
4869 CGF.EmitStmt(CatchStmt->getCatchBody());
4870
4871 // We're done with the catch variable.
4872 CatchVarCleanups.ForceCleanup();
4873
4874 CGF.EmitBranchThroughCleanup(FinallyEnd);
4875
4876 CGF.EmitBlock(NextCatchBlock);
4877 }
4878
4879 CGF.ObjCEHValueStack.pop_back();
4880
4881 // If nothing wanted anything to do with the caught exception,
4882 // kill the extract call.
4883 if (Caught->use_empty())
4884 Caught->eraseFromParent();
4885
4886 if (!AllMatched)
4887 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4888
4889 if (HasFinally) {
4890 // Emit the exception handler for the @catch blocks.
4891 CGF.EmitBlock(CatchHandler);
4892
4893 // In theory we might now need a write hazard, but actually it's
4894 // unnecessary because there's no local-accessing code between
4895 // the try's write hazard and here.
4896 //Hazards.emitWriteHazard();
4897
4898 // Extract the new exception and save it to the
4899 // propagating-exception slot.
4900 assert(PropagatingExnVar.isValid())(static_cast <bool> (PropagatingExnVar.isValid()) ? void
(0) : __assert_fail ("PropagatingExnVar.isValid()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4900, __extension__ __PRETTY_FUNCTION__))
;
4901 llvm::CallInst *NewCaught =
4902 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4903 ExceptionData.getPointer(), "caught");
4904 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4905
4906 // Don't pop the catch handler; the throw already did.
4907 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4908 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4909 }
4910 }
4911
4912 // Insert read hazards as required in the new blocks.
4913 Hazards.emitHazardsInNewBlocks();
4914
4915 // Pop the cleanup.
4916 CGF.Builder.restoreIP(TryFallthroughIP);
4917 if (CGF.HaveInsertPoint())
4918 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4919 CGF.PopCleanupBlock();
4920 CGF.EmitBlock(FinallyEnd.getBlock(), true);
4921
4922 // Emit the rethrow block.
4923 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4924 CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4925 if (CGF.HaveInsertPoint()) {
4926 // If we have a propagating-exception variable, check it.
4927 llvm::Value *PropagatingExn;
4928 if (PropagatingExnVar.isValid()) {
4929 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4930
4931 // Otherwise, just look in the buffer for the exception to throw.
4932 } else {
4933 llvm::CallInst *Caught =
4934 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4935 ExceptionData.getPointer());
4936 PropagatingExn = Caught;
4937 }
4938
4939 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4940 PropagatingExn);
4941 CGF.Builder.CreateUnreachable();
4942 }
4943
4944 CGF.Builder.restoreIP(SavedIP);
4945}
4946
4947void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4948 const ObjCAtThrowStmt &S,
4949 bool ClearInsertionPoint) {
4950 llvm::Value *ExceptionAsObject;
4951
4952 if (const Expr *ThrowExpr = S.getThrowExpr()) {
4953 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4954 ExceptionAsObject =
4955 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4956 } else {
4957 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&(static_cast <bool> ((!CGF.ObjCEHValueStack.empty() &&
CGF.ObjCEHValueStack.back()) && "Unexpected rethrow outside @catch block."
) ? void (0) : __assert_fail ("(!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && \"Unexpected rethrow outside @catch block.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4958, __extension__ __PRETTY_FUNCTION__))
4958 "Unexpected rethrow outside @catch block.")(static_cast <bool> ((!CGF.ObjCEHValueStack.empty() &&
CGF.ObjCEHValueStack.back()) && "Unexpected rethrow outside @catch block."
) ? void (0) : __assert_fail ("(!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && \"Unexpected rethrow outside @catch block.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4958, __extension__ __PRETTY_FUNCTION__))
;
4959 ExceptionAsObject = CGF.ObjCEHValueStack.back();
4960 }
4961
4962 CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4963 ->setDoesNotReturn();
4964 CGF.Builder.CreateUnreachable();
4965
4966 // Clear the insertion point to indicate we are in unreachable code.
4967 if (ClearInsertionPoint)
4968 CGF.Builder.ClearInsertionPoint();
4969}
4970
4971/// EmitObjCWeakRead - Code gen for loading value of a __weak
4972/// object: objc_read_weak (id *src)
4973///
4974llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4975 Address AddrWeakObj) {
4976 llvm::Type* DestTy = AddrWeakObj.getElementType();
4977 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4978 ObjCTypes.PtrObjectPtrTy);
4979 llvm::Value *read_weak =
4980 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4981 AddrWeakObj.getPointer(), "weakread");
4982 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4983 return read_weak;
4984}
4985
4986/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4987/// objc_assign_weak (id src, id *dst)
4988///
4989void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4990 llvm::Value *src, Address dst) {
4991 llvm::Type * SrcTy = src->getType();
4992 if (!isa<llvm::PointerType>(SrcTy)) {
4993 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4994 assert(Size <= 8 && "does not support size > 8")(static_cast <bool> (Size <= 8 && "does not support size > 8"
) ? void (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 4994, __extension__ __PRETTY_FUNCTION__))
;
4995 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4996 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4997 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4998 }
4999 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5000 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5001 llvm::Value *args[] = { src, dst.getPointer() };
5002 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
5003 args, "weakassign");
5004}
5005
5006/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
5007/// objc_assign_global (id src, id *dst)
5008///
5009void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
5010 llvm::Value *src, Address dst,
5011 bool threadlocal) {
5012 llvm::Type * SrcTy = src->getType();
5013 if (!isa<llvm::PointerType>(SrcTy)) {
5014 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5015 assert(Size <= 8 && "does not support size > 8")(static_cast <bool> (Size <= 8 && "does not support size > 8"
) ? void (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5015, __extension__ __PRETTY_FUNCTION__))
;
5016 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5017 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5018 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5019 }
5020 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5021 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5022 llvm::Value *args[] = { src, dst.getPointer() };
5023 if (!threadlocal)
5024 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
5025 args, "globalassign");
5026 else
5027 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
5028 args, "threadlocalassign");
5029}
5030
5031/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
5032/// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
5033///
5034void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
5035 llvm::Value *src, Address dst,
5036 llvm::Value *ivarOffset) {
5037 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL")(static_cast <bool> (ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL"
) ? void (0) : __assert_fail ("ivarOffset && \"EmitObjCIvarAssign - ivarOffset is NULL\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5037, __extension__ __PRETTY_FUNCTION__))
;
5038 llvm::Type * SrcTy = src->getType();
5039 if (!isa<llvm::PointerType>(SrcTy)) {
5040 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5041 assert(Size <= 8 && "does not support size > 8")(static_cast <bool> (Size <= 8 && "does not support size > 8"
) ? void (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5041, __extension__ __PRETTY_FUNCTION__))
;
5042 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5043 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5044 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5045 }
5046 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5047 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5048 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
5049 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
5050}
5051
5052/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
5053/// objc_assign_strongCast (id src, id *dst)
5054///
5055void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
5056 llvm::Value *src, Address dst) {
5057 llvm::Type * SrcTy = src->getType();
5058 if (!isa<llvm::PointerType>(SrcTy)) {
5059 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5060 assert(Size <= 8 && "does not support size > 8")(static_cast <bool> (Size <= 8 && "does not support size > 8"
) ? void (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5060, __extension__ __PRETTY_FUNCTION__))
;
5061 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5062 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5063 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5064 }
5065 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5066 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5067 llvm::Value *args[] = { src, dst.getPointer() };
5068 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
5069 args, "strongassign");
5070}
5071
5072void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
5073 Address DestPtr,
5074 Address SrcPtr,
5075 llvm::Value *size) {
5076 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
5077 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
5078 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
5079 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
5080}
5081
5082/// EmitObjCValueForIvar - Code Gen for ivar reference.
5083///
5084LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
5085 QualType ObjectTy,
5086 llvm::Value *BaseValue,
5087 const ObjCIvarDecl *Ivar,
5088 unsigned CVRQualifiers) {
5089 const ObjCInterfaceDecl *ID =
5090 ObjectTy->castAs<ObjCObjectType>()->getInterface();
5091 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
5092 EmitIvarOffset(CGF, ID, Ivar));
5093}
5094
5095llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
5096 const ObjCInterfaceDecl *Interface,
5097 const ObjCIvarDecl *Ivar) {
5098 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
5099 return llvm::ConstantInt::get(
5100 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
5101 Offset);
5102}
5103
5104/* *** Private Interface *** */
5105
5106std::string CGObjCCommonMac::GetSectionName(StringRef Section,
5107 StringRef MachOAttributes) {
5108 switch (CGM.getTriple().getObjectFormat()) {
5109 case llvm::Triple::UnknownObjectFormat:
5110 llvm_unreachable("unexpected object file format")::llvm::llvm_unreachable_internal("unexpected object file format"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5110)
;
5111 case llvm::Triple::MachO: {
5112 if (MachOAttributes.empty())
5113 return ("__DATA," + Section).str();
5114 return ("__DATA," + Section + "," + MachOAttributes).str();
5115 }
5116 case llvm::Triple::ELF:
5117 assert(Section.substr(0, 2) == "__" &&(static_cast <bool> (Section.substr(0, 2) == "__" &&
"expected the name to begin with __") ? void (0) : __assert_fail
("Section.substr(0, 2) == \"__\" && \"expected the name to begin with __\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5118, __extension__ __PRETTY_FUNCTION__))
5118 "expected the name to begin with __")(static_cast <bool> (Section.substr(0, 2) == "__" &&
"expected the name to begin with __") ? void (0) : __assert_fail
("Section.substr(0, 2) == \"__\" && \"expected the name to begin with __\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5118, __extension__ __PRETTY_FUNCTION__))
;
5119 return Section.substr(2).str();
5120 case llvm::Triple::COFF:
5121 assert(Section.substr(0, 2) == "__" &&(static_cast <bool> (Section.substr(0, 2) == "__" &&
"expected the name to begin with __") ? void (0) : __assert_fail
("Section.substr(0, 2) == \"__\" && \"expected the name to begin with __\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5122, __extension__ __PRETTY_FUNCTION__))
5122 "expected the name to begin with __")(static_cast <bool> (Section.substr(0, 2) == "__" &&
"expected the name to begin with __") ? void (0) : __assert_fail
("Section.substr(0, 2) == \"__\" && \"expected the name to begin with __\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5122, __extension__ __PRETTY_FUNCTION__))
;
5123 return ("." + Section.substr(2) + "$B").str();
5124 case llvm::Triple::Wasm:
5125 case llvm::Triple::GOFF:
5126 case llvm::Triple::XCOFF:
5127 llvm::report_fatal_error(
5128 "Objective-C support is unimplemented for object file format");
5129 }
5130
5131 llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum")::llvm::llvm_unreachable_internal("Unhandled llvm::Triple::ObjectFormatType enum"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5131)
;
5132}
5133
5134/// EmitImageInfo - Emit the image info marker used to encode some module
5135/// level information.
5136///
5137/// See: <rdr://4810609&4810587&4810587>
5138/// struct IMAGE_INFO {
5139/// unsigned version;
5140/// unsigned flags;
5141/// };
5142enum ImageInfoFlags {
5143 eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang.
5144 eImageInfo_GarbageCollected = (1 << 1),
5145 eImageInfo_GCOnly = (1 << 2),
5146 eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache.
5147
5148 // A flag indicating that the module has no instances of a @synthesize of a
5149 // superclass variable. <rdar://problem/6803242>
5150 eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
5151 eImageInfo_ImageIsSimulated = (1 << 5),
5152 eImageInfo_ClassProperties = (1 << 6)
5153};
5154
5155void CGObjCCommonMac::EmitImageInfo() {
5156 unsigned version = 0; // Version is unused?
5157 std::string Section =
5158 (ObjCABI == 1)
5159 ? "__OBJC,__image_info,regular"
5160 : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");
5161
5162 // Generate module-level named metadata to convey this information to the
5163 // linker and code-gen.
5164 llvm::Module &Mod = CGM.getModule();
5165
5166 // Add the ObjC ABI version to the module flags.
5167 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
5168 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
5169 version);
5170 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
5171 llvm::MDString::get(VMContext, Section));
5172
5173 auto Int8Ty = llvm::Type::getInt8Ty(VMContext);
5174 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5175 // Non-GC overrides those files which specify GC.
5176 Mod.addModuleFlag(llvm::Module::Error,
5177 "Objective-C Garbage Collection",
5178 llvm::ConstantInt::get(Int8Ty,0));
5179 } else {
5180 // Add the ObjC garbage collection value.
5181 Mod.addModuleFlag(llvm::Module::Error,
5182 "Objective-C Garbage Collection",
5183 llvm::ConstantInt::get(Int8Ty,
5184 (uint8_t)eImageInfo_GarbageCollected));
5185
5186 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
5187 // Add the ObjC GC Only value.
5188 Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
5189 eImageInfo_GCOnly);
5190
5191 // Require that GC be specified and set to eImageInfo_GarbageCollected.
5192 llvm::Metadata *Ops[2] = {
5193 llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
5194 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
5195 Int8Ty, eImageInfo_GarbageCollected))};
5196 Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
5197 llvm::MDNode::get(VMContext, Ops));
5198 }
5199 }
5200
5201 // Indicate whether we're compiling this to run on a simulator.
5202 if (CGM.getTarget().getTriple().isSimulatorEnvironment())
5203 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
5204 eImageInfo_ImageIsSimulated);
5205
5206 // Indicate whether we are generating class properties.
5207 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
5208 eImageInfo_ClassProperties);
5209}
5210
5211// struct objc_module {
5212// unsigned long version;
5213// unsigned long size;
5214// const char *name;
5215// Symtab symtab;
5216// };
5217
5218// FIXME: Get from somewhere
5219static const int ModuleVersion = 7;
5220
5221void CGObjCMac::EmitModuleInfo() {
5222 uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
5223
5224 ConstantInitBuilder builder(CGM);
5225 auto values = builder.beginStruct(ObjCTypes.ModuleTy);
5226 values.addInt(ObjCTypes.LongTy, ModuleVersion);
5227 values.addInt(ObjCTypes.LongTy, Size);
5228 // This used to be the filename, now it is unused. <rdr://4327263>
5229 values.add(GetClassName(StringRef("")));
5230 values.add(EmitModuleSymbols());
5231 CreateMetadataVar("OBJC_MODULES", values,
5232 "__OBJC,__module_info,regular,no_dead_strip",
5233 CGM.getPointerAlign(), true);
5234}
5235
5236llvm::Constant *CGObjCMac::EmitModuleSymbols() {
5237 unsigned NumClasses = DefinedClasses.size();
5238 unsigned NumCategories = DefinedCategories.size();
5239
5240 // Return null if no symbols were defined.
5241 if (!NumClasses && !NumCategories)
5242 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
5243
5244 ConstantInitBuilder builder(CGM);
5245 auto values = builder.beginStruct();
5246 values.addInt(ObjCTypes.LongTy, 0);
5247 values.addNullPointer(ObjCTypes.SelectorPtrTy);
5248 values.addInt(ObjCTypes.ShortTy, NumClasses);
5249 values.addInt(ObjCTypes.ShortTy, NumCategories);
5250
5251 // The runtime expects exactly the list of defined classes followed
5252 // by the list of defined categories, in a single array.
5253 auto array = values.beginArray(ObjCTypes.Int8PtrTy);
5254 for (unsigned i=0; i<NumClasses; i++) {
5255 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
5256 assert(ID)(static_cast <bool> (ID) ? void (0) : __assert_fail ("ID"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5256, __extension__ __PRETTY_FUNCTION__))
;
5257 if (ObjCImplementationDecl *IMP = ID->getImplementation())
5258 // We are implementing a weak imported interface. Give it external linkage
5259 if (ID->isWeakImported() && !IMP->isWeakImported())
5260 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5261
5262 array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy);
5263 }
5264 for (unsigned i=0; i<NumCategories; i++)
5265 array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy);
5266
5267 array.finishAndAddTo(values);
5268
5269 llvm::GlobalVariable *GV = CreateMetadataVar(
5270 "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip",
5271 CGM.getPointerAlign(), true);
5272 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
5273}
5274
5275llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
5276 IdentifierInfo *II) {
5277 LazySymbols.insert(II);
5278
5279 llvm::GlobalVariable *&Entry = ClassReferences[II];
5280
5281 if (!Entry) {
5282 llvm::Constant *Casted =
5283 llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
5284 ObjCTypes.ClassPtrTy);
5285 Entry = CreateMetadataVar(
5286 "OBJC_CLASS_REFERENCES_", Casted,
5287 "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
5288 CGM.getPointerAlign(), true);
5289 }
5290
5291 return CGF.Builder.CreateAlignedLoad(Entry->getValueType(), Entry,
5292 CGF.getPointerAlign());
5293}
5294
5295llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
5296 const ObjCInterfaceDecl *ID) {
5297 // If the class has the objc_runtime_visible attribute, we need to
5298 // use the Objective-C runtime to get the class.
5299 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
5300 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
5301
5302 IdentifierInfo *RuntimeName =
5303 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
5304 return EmitClassRefFromId(CGF, RuntimeName);
5305}
5306
5307llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
5308 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
5309 return EmitClassRefFromId(CGF, II);
5310}
5311
5312llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
5313 return CGF.Builder.CreateLoad(EmitSelectorAddr(Sel));
5314}
5315
5316Address CGObjCMac::EmitSelectorAddr(Selector Sel) {
5317 CharUnits Align = CGM.getPointerAlign();
5318
5319 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
5320 if (!Entry) {
5321 llvm::Constant *Casted =
5322 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5323 ObjCTypes.SelectorPtrTy);
5324 Entry = CreateMetadataVar(
5325 "OBJC_SELECTOR_REFERENCES_", Casted,
5326 "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
5327 Entry->setExternallyInitialized(true);
5328 }
5329
5330 return Address(Entry, Align);
5331}
5332
5333llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
5334 llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
5335 if (!Entry)
5336 Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
5337 return getConstantGEP(VMContext, Entry, 0, 0);
5338}
5339
5340llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
5341 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
5342 I = MethodDefinitions.find(MD);
5343 if (I != MethodDefinitions.end())
5344 return I->second;
5345
5346 return nullptr;
5347}
5348
5349/// GetIvarLayoutName - Returns a unique constant for the given
5350/// ivar layout bitmap.
5351llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
5352 const ObjCCommonTypesHelper &ObjCTypes) {
5353 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5354}
5355
5356void IvarLayoutBuilder::visitRecord(const RecordType *RT,
5357 CharUnits offset) {
5358 const RecordDecl *RD = RT->getDecl();
5359
5360 // If this is a union, remember that we had one, because it might mess
5361 // up the ordering of layout entries.
5362 if (RD->isUnion())
5363 IsDisordered = true;
5364
5365 const ASTRecordLayout *recLayout = nullptr;
5366 visitAggregate(RD->field_begin(), RD->field_end(), offset,
5367 [&](const FieldDecl *field) -> CharUnits {
5368 if (!recLayout)
5369 recLayout = &CGM.getContext().getASTRecordLayout(RD);
5370 auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
5371 return CGM.getContext().toCharUnitsFromBits(offsetInBits);
5372 });
5373}
5374
5375template <class Iterator, class GetOffsetFn>
5376void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
5377 CharUnits aggregateOffset,
5378 const GetOffsetFn &getOffset) {
5379 for (; begin != end; ++begin) {
5380 auto field = *begin;
5381
5382 // Skip over bitfields.
5383 if (field->isBitField()) {
5384 continue;
5385 }
5386
5387 // Compute the offset of the field within the aggregate.
5388 CharUnits fieldOffset = aggregateOffset + getOffset(field);
5389
5390 visitField(field, fieldOffset);
5391 }
5392}
5393
5394/// Collect layout information for the given fields into IvarsInfo.
5395void IvarLayoutBuilder::visitField(const FieldDecl *field,
5396 CharUnits fieldOffset) {
5397 QualType fieldType = field->getType();
5398
5399 // Drill down into arrays.
5400 uint64_t numElts = 1;
5401 if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) {
5402 numElts = 0;
5403 fieldType = arrayType->getElementType();
5404 }
5405 // Unlike incomplete arrays, constant arrays can be nested.
5406 while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
5407 numElts *= arrayType->getSize().getZExtValue();
5408 fieldType = arrayType->getElementType();
5409 }
5410
5411 assert(!fieldType->isArrayType() && "ivar of non-constant array type?")(static_cast <bool> (!fieldType->isArrayType() &&
"ivar of non-constant array type?") ? void (0) : __assert_fail
("!fieldType->isArrayType() && \"ivar of non-constant array type?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5411, __extension__ __PRETTY_FUNCTION__))
;
5412
5413 // If we ended up with a zero-sized array, we've done what we can do within
5414 // the limits of this layout encoding.
5415 if (numElts == 0) return;
5416
5417 // Recurse if the base element type is a record type.
5418 if (auto recType = fieldType->getAs<RecordType>()) {
5419 size_t oldEnd = IvarsInfo.size();
5420
5421 visitRecord(recType, fieldOffset);
5422
5423 // If we have an array, replicate the first entry's layout information.
5424 auto numEltEntries = IvarsInfo.size() - oldEnd;
5425 if (numElts != 1 && numEltEntries != 0) {
5426 CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5427 for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
5428 // Copy the last numEltEntries onto the end of the array, adjusting
5429 // each for the element size.
5430 for (size_t i = 0; i != numEltEntries; ++i) {
5431 auto firstEntry = IvarsInfo[oldEnd + i];
5432 IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
5433 firstEntry.SizeInWords));
5434 }
5435 }
5436 }
5437
5438 return;
5439 }
5440
5441 // Classify the element type.
5442 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
5443
5444 // If it matches what we're looking for, add an entry.
5445 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
5446 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
5447 assert(CGM.getContext().getTypeSizeInChars(fieldType)(static_cast <bool> (CGM.getContext().getTypeSizeInChars
(fieldType) == CGM.getPointerSize()) ? void (0) : __assert_fail
("CGM.getContext().getTypeSizeInChars(fieldType) == CGM.getPointerSize()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5448, __extension__ __PRETTY_FUNCTION__))
5448 == CGM.getPointerSize())(static_cast <bool> (CGM.getContext().getTypeSizeInChars
(fieldType) == CGM.getPointerSize()) ? void (0) : __assert_fail
("CGM.getContext().getTypeSizeInChars(fieldType) == CGM.getPointerSize()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5448, __extension__ __PRETTY_FUNCTION__))
;
5449 IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
5450 }
5451}
5452
5453/// buildBitmap - This routine does the horsework of taking the offsets of
5454/// strong/weak references and creating a bitmap. The bitmap is also
5455/// returned in the given buffer, suitable for being passed to \c dump().
5456llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
5457 llvm::SmallVectorImpl<unsigned char> &buffer) {
5458 // The bitmap is a series of skip/scan instructions, aligned to word
5459 // boundaries. The skip is performed first.
5460 const unsigned char MaxNibble = 0xF;
5461 const unsigned char SkipMask = 0xF0, SkipShift = 4;
5462 const unsigned char ScanMask = 0x0F, ScanShift = 0;
5463
5464 assert(!IvarsInfo.empty() && "generating bitmap for no data")(static_cast <bool> (!IvarsInfo.empty() && "generating bitmap for no data"
) ? void (0) : __assert_fail ("!IvarsInfo.empty() && \"generating bitmap for no data\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5464, __extension__ __PRETTY_FUNCTION__))
;
5465
5466 // Sort the ivar info on byte position in case we encounterred a
5467 // union nested in the ivar list.
5468 if (IsDisordered) {
5469 // This isn't a stable sort, but our algorithm should handle it fine.
5470 llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
5471 } else {
5472 assert(llvm::is_sorted(IvarsInfo))(static_cast <bool> (llvm::is_sorted(IvarsInfo)) ? void
(0) : __assert_fail ("llvm::is_sorted(IvarsInfo)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5472, __extension__ __PRETTY_FUNCTION__))
;
5473 }
5474 assert(IvarsInfo.back().Offset < InstanceEnd)(static_cast <bool> (IvarsInfo.back().Offset < InstanceEnd
) ? void (0) : __assert_fail ("IvarsInfo.back().Offset < InstanceEnd"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5474, __extension__ __PRETTY_FUNCTION__))
;
5475
5476 assert(buffer.empty())(static_cast <bool> (buffer.empty()) ? void (0) : __assert_fail
("buffer.empty()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5476, __extension__ __PRETTY_FUNCTION__))
;
5477
5478 // Skip the next N words.
5479 auto skip = [&](unsigned numWords) {
5480 assert(numWords > 0)(static_cast <bool> (numWords > 0) ? void (0) : __assert_fail
("numWords > 0", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5480, __extension__ __PRETTY_FUNCTION__))
;
5481
5482 // Try to merge into the previous byte. Since scans happen second, we
5483 // can't do this if it includes a scan.
5484 if (!buffer.empty() && !(buffer.back() & ScanMask)) {
5485 unsigned lastSkip = buffer.back() >> SkipShift;
5486 if (lastSkip < MaxNibble) {
5487 unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
5488 numWords -= claimed;
5489 lastSkip += claimed;
5490 buffer.back() = (lastSkip << SkipShift);
5491 }
5492 }
5493
5494 while (numWords >= MaxNibble) {
5495 buffer.push_back(MaxNibble << SkipShift);
5496 numWords -= MaxNibble;
5497 }
5498 if (numWords) {
5499 buffer.push_back(numWords << SkipShift);
5500 }
5501 };
5502
5503 // Scan the next N words.
5504 auto scan = [&](unsigned numWords) {
5505 assert(numWords > 0)(static_cast <bool> (numWords > 0) ? void (0) : __assert_fail
("numWords > 0", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5505, __extension__ __PRETTY_FUNCTION__))
;
5506
5507 // Try to merge into the previous byte. Since scans happen second, we can
5508 // do this even if it includes a skip.
5509 if (!buffer.empty()) {
5510 unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
5511 if (lastScan < MaxNibble) {
5512 unsigned claimed = std::min(MaxNibble - lastScan, numWords);
5513 numWords -= claimed;
5514 lastScan += claimed;
5515 buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
5516 }
5517 }
5518
5519 while (numWords >= MaxNibble) {
5520 buffer.push_back(MaxNibble << ScanShift);
5521 numWords -= MaxNibble;
5522 }
5523 if (numWords) {
5524 buffer.push_back(numWords << ScanShift);
5525 }
5526 };
5527
5528 // One past the end of the last scan.
5529 unsigned endOfLastScanInWords = 0;
5530 const CharUnits WordSize = CGM.getPointerSize();
5531
5532 // Consider all the scan requests.
5533 for (auto &request : IvarsInfo) {
5534 CharUnits beginOfScan = request.Offset - InstanceBegin;
5535
5536 // Ignore scan requests that don't start at an even multiple of the
5537 // word size. We can't encode them.
5538 if ((beginOfScan % WordSize) != 0) continue;
5539
5540 // Ignore scan requests that start before the instance start.
5541 // This assumes that scans never span that boundary. The boundary
5542 // isn't the true start of the ivars, because in the fragile-ARC case
5543 // it's rounded up to word alignment, but the test above should leave
5544 // us ignoring that possibility.
5545 if (beginOfScan.isNegative()) {
5546 assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin)(static_cast <bool> (request.Offset + request.SizeInWords
* WordSize <= InstanceBegin) ? void (0) : __assert_fail (
"request.Offset + request.SizeInWords * WordSize <= InstanceBegin"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5546, __extension__ __PRETTY_FUNCTION__))
;
5547 continue;
5548 }
5549
5550 unsigned beginOfScanInWords = beginOfScan / WordSize;
5551 unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
5552
5553 // If the scan starts some number of words after the last one ended,
5554 // skip forward.
5555 if (beginOfScanInWords > endOfLastScanInWords) {
5556 skip(beginOfScanInWords - endOfLastScanInWords);
5557
5558 // Otherwise, start scanning where the last left off.
5559 } else {
5560 beginOfScanInWords = endOfLastScanInWords;
5561
5562 // If that leaves us with nothing to scan, ignore this request.
5563 if (beginOfScanInWords >= endOfScanInWords) continue;
5564 }
5565
5566 // Scan to the end of the request.
5567 assert(beginOfScanInWords < endOfScanInWords)(static_cast <bool> (beginOfScanInWords < endOfScanInWords
) ? void (0) : __assert_fail ("beginOfScanInWords < endOfScanInWords"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 5567, __extension__ __PRETTY_FUNCTION__))
;
5568 scan(endOfScanInWords - beginOfScanInWords);
5569 endOfLastScanInWords = endOfScanInWords;
5570 }
5571
5572 if (buffer.empty())
5573 return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
5574
5575 // For GC layouts, emit a skip to the end of the allocation so that we
5576 // have precise information about the entire thing. This isn't useful
5577 // or necessary for the ARC-style layout strings.
5578 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5579 unsigned lastOffsetInWords =
5580 (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5581 if (lastOffsetInWords > endOfLastScanInWords) {
5582 skip(lastOffsetInWords - endOfLastScanInWords);
5583 }
5584 }
5585
5586 // Null terminate the string.
5587 buffer.push_back(0);
5588
5589 auto *Entry = CGObjC.CreateCStringLiteral(
5590 reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
5591 return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5592}
5593
5594/// BuildIvarLayout - Builds ivar layout bitmap for the class
5595/// implementation for the __strong or __weak case.
5596/// The layout map displays which words in ivar list must be skipped
5597/// and which must be scanned by GC (see below). String is built of bytes.
5598/// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5599/// of words to skip and right nibble is count of words to scan. So, each
5600/// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5601/// represented by a 0x00 byte which also ends the string.
5602/// 1. when ForStrongLayout is true, following ivars are scanned:
5603/// - id, Class
5604/// - object *
5605/// - __strong anything
5606///
5607/// 2. When ForStrongLayout is false, following ivars are scanned:
5608/// - __weak anything
5609///
5610llvm::Constant *
5611CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
5612 CharUnits beginOffset, CharUnits endOffset,
5613 bool ForStrongLayout, bool HasMRCWeakIvars) {
5614 // If this is MRC, and we're either building a strong layout or there
5615 // are no weak ivars, bail out early.
5616 llvm::Type *PtrTy = CGM.Int8PtrTy;
5617 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5618 !CGM.getLangOpts().ObjCAutoRefCount &&
5619 (ForStrongLayout || !HasMRCWeakIvars))
5620 return llvm::Constant::getNullValue(PtrTy);
5621
5622 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5623 SmallVector<const ObjCIvarDecl*, 32> ivars;
5624
5625 // GC layout strings include the complete object layout, possibly
5626 // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5627 // up.
5628 //
5629 // ARC layout strings only include the class's ivars. In non-fragile
5630 // runtimes, that means starting at InstanceStart, rounded up to word
5631 // alignment. In fragile runtimes, there's no InstanceStart, so it means
5632 // starting at the offset of the first ivar, rounded up to word alignment.
5633 //
5634 // MRC weak layout strings follow the ARC style.
5635 CharUnits baseOffset;
5636 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5637 for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5638 IVD; IVD = IVD->getNextIvar())
5639 ivars.push_back(IVD);
5640
5641 if (isNonFragileABI()) {
5642 baseOffset = beginOffset; // InstanceStart
5643 } else if (!ivars.empty()) {
5644 baseOffset =
5645 CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5646 } else {
5647 baseOffset = CharUnits::Zero();
5648 }
5649
5650 baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5651 }
5652 else {
5653 CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5654
5655 baseOffset = CharUnits::Zero();
5656 }
5657
5658 if (ivars.empty())
5659 return llvm::Constant::getNullValue(PtrTy);
5660
5661 IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5662
5663 builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5664 [&](const ObjCIvarDecl *ivar) -> CharUnits {
5665 return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5666 });
5667
5668 if (!builder.hasBitmapData())
5669 return llvm::Constant::getNullValue(PtrTy);
5670
5671 llvm::SmallVector<unsigned char, 4> buffer;
5672 llvm::Constant *C = builder.buildBitmap(*this, buffer);
5673
5674 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5675 printf("\n%s ivar layout for class '%s': ",
5676 ForStrongLayout ? "strong" : "weak",
5677 OMD->getClassInterface()->getName().str().c_str());
5678 builder.dump(buffer);
5679 }
5680 return C;
5681}
5682
5683llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5684 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5685 // FIXME: Avoid std::string in "Sel.getAsString()"
5686 if (!Entry)
5687 Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
5688 return getConstantGEP(VMContext, Entry, 0, 0);
5689}
5690
5691// FIXME: Merge into a single cstring creation function.
5692llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5693 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5694}
5695
5696llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5697 std::string TypeStr;
5698 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5699
5700 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5701 if (!Entry)
5702 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5703 return getConstantGEP(VMContext, Entry, 0, 0);
5704}
5705
5706llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5707 bool Extended) {
5708 std::string TypeStr =
5709 CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);
5710
5711 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5712 if (!Entry)
5713 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5714 return getConstantGEP(VMContext, Entry, 0, 0);
5715}
5716
5717// FIXME: Merge into a single cstring creation function.
5718llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5719 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5720 if (!Entry)
5721 Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
5722 return getConstantGEP(VMContext, Entry, 0, 0);
5723}
5724
5725// FIXME: Merge into a single cstring creation function.
5726// FIXME: This Decl should be more precise.
5727llvm::Constant *
5728CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5729 const Decl *Container) {
5730 std::string TypeStr =
5731 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
5732 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5733}
5734
5735void CGObjCMac::FinishModule() {
5736 EmitModuleInfo();
5737
5738 // Emit the dummy bodies for any protocols which were referenced but
5739 // never defined.
5740 for (auto &entry : Protocols) {
5741 llvm::GlobalVariable *global = entry.second;
5742 if (global->hasInitializer())
5743 continue;
5744
5745 ConstantInitBuilder builder(CGM);
5746 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
5747 values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
5748 values.add(GetClassName(entry.first->getName()));
5749 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
5750 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5751 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5752 values.finishAndSetAsInitializer(global);
5753 CGM.addCompilerUsedGlobal(global);
5754 }
5755
5756 // Add assembler directives to add lazy undefined symbol references
5757 // for classes which are referenced but not defined. This is
5758 // important for correct linker interaction.
5759 //
5760 // FIXME: It would be nice if we had an LLVM construct for this.
5761 if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
5762 CGM.getTriple().isOSBinFormatMachO()) {
5763 SmallString<256> Asm;
5764 Asm += CGM.getModule().getModuleInlineAsm();
5765 if (!Asm.empty() && Asm.back() != '\n')
5766 Asm += '\n';
5767
5768 llvm::raw_svector_ostream OS(Asm);
5769 for (const auto *Sym : DefinedSymbols)
5770 OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
5771 << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
5772 for (const auto *Sym : LazySymbols)
5773 OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
5774 for (const auto &Category : DefinedCategoryNames)
5775 OS << "\t.objc_category_name_" << Category << "=0\n"
5776 << "\t.globl .objc_category_name_" << Category << "\n";
5777
5778 CGM.getModule().setModuleInlineAsm(OS.str());
5779 }
5780}
5781
5782CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5783 : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
5784 ObjCEmptyVtableVar(nullptr) {
5785 ObjCABI = 2;
5786}
5787
5788/* *** */
5789
5790ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5791 : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5792{
5793 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5794 ASTContext &Ctx = CGM.getContext();
5795
5796 ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
5797 IntTy = CGM.IntTy;
5798 LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
5799 Int8PtrTy = CGM.Int8PtrTy;
5800 Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5801
5802 // arm64 targets use "int" ivar offset variables. All others,
5803 // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5804 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5805 IvarOffsetVarTy = IntTy;
5806 else
5807 IvarOffsetVarTy = LongTy;
5808
5809 ObjectPtrTy =
5810 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
5811 PtrObjectPtrTy =
5812 llvm::PointerType::getUnqual(ObjectPtrTy);
5813 SelectorPtrTy =
5814 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
5815
5816 // I'm not sure I like this. The implicit coordination is a bit
5817 // gross. We should solve this in a reasonable fashion because this
5818 // is a pretty common task (match some runtime data structure with
5819 // an LLVM data structure).
5820
5821 // FIXME: This is leaked.
5822 // FIXME: Merge with rewriter code?
5823
5824 // struct _objc_super {
5825 // id self;
5826 // Class cls;
5827 // }
5828 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5829 Ctx.getTranslationUnitDecl(),
5830 SourceLocation(), SourceLocation(),
5831 &Ctx.Idents.get("_objc_super"));
5832 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5833 nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5834 false, ICIS_NoInit));
5835 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5836 nullptr, Ctx.getObjCClassType(), nullptr,
5837 nullptr, false, ICIS_NoInit));
5838 RD->completeDefinition();
5839
5840 SuperCTy = Ctx.getTagDeclType(RD);
5841 SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5842
5843 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5844 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5845
5846 // struct _prop_t {
5847 // char *name;
5848 // char *attributes;
5849 // }
5850 PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy);
5851
5852 // struct _prop_list_t {
5853 // uint32_t entsize; // sizeof(struct _prop_t)
5854 // uint32_t count_of_properties;
5855 // struct _prop_t prop_list[count_of_properties];
5856 // }
5857 PropertyListTy = llvm::StructType::create(
5858 "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0));
5859 // struct _prop_list_t *
5860 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5861
5862 // struct _objc_method {
5863 // SEL _cmd;
5864 // char *method_type;
5865 // char *_imp;
5866 // }
5867 MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy,
5868 Int8PtrTy, Int8PtrTy);
5869
5870 // struct _objc_cache *
5871 CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5872 CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5873}
5874
5875ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5876 : ObjCCommonTypesHelper(cgm) {
5877 // struct _objc_method_description {
5878 // SEL name;
5879 // char *types;
5880 // }
5881 MethodDescriptionTy = llvm::StructType::create(
5882 "struct._objc_method_description", SelectorPtrTy, Int8PtrTy);
5883
5884 // struct _objc_method_description_list {
5885 // int count;
5886 // struct _objc_method_description[1];
5887 // }
5888 MethodDescriptionListTy =
5889 llvm::StructType::create("struct._objc_method_description_list", IntTy,
5890 llvm::ArrayType::get(MethodDescriptionTy, 0));
5891
5892 // struct _objc_method_description_list *
5893 MethodDescriptionListPtrTy =
5894 llvm::PointerType::getUnqual(MethodDescriptionListTy);
5895
5896 // Protocol description structures
5897
5898 // struct _objc_protocol_extension {
5899 // uint32_t size; // sizeof(struct _objc_protocol_extension)
5900 // struct _objc_method_description_list *optional_instance_methods;
5901 // struct _objc_method_description_list *optional_class_methods;
5902 // struct _objc_property_list *instance_properties;
5903 // const char ** extendedMethodTypes;
5904 // struct _objc_property_list *class_properties;
5905 // }
5906 ProtocolExtensionTy = llvm::StructType::create(
5907 "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy,
5908 MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy,
5909 PropertyListPtrTy);
5910
5911 // struct _objc_protocol_extension *
5912 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5913
5914 // Handle recursive construction of Protocol and ProtocolList types
5915
5916 ProtocolTy =
5917 llvm::StructType::create(VMContext, "struct._objc_protocol");
5918
5919 ProtocolListTy =
5920 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5921 ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy,
5922 llvm::ArrayType::get(ProtocolTy, 0));
5923
5924 // struct _objc_protocol {
5925 // struct _objc_protocol_extension *isa;
5926 // char *protocol_name;
5927 // struct _objc_protocol **_objc_protocol_list;
5928 // struct _objc_method_description_list *instance_methods;
5929 // struct _objc_method_description_list *class_methods;
5930 // }
5931 ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5932 llvm::PointerType::getUnqual(ProtocolListTy),
5933 MethodDescriptionListPtrTy, MethodDescriptionListPtrTy);
5934
5935 // struct _objc_protocol_list *
5936 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5937
5938 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5939
5940 // Class description structures
5941
5942 // struct _objc_ivar {
5943 // char *ivar_name;
5944 // char *ivar_type;
5945 // int ivar_offset;
5946 // }
5947 IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy,
5948 IntTy);
5949
5950 // struct _objc_ivar_list *
5951 IvarListTy =
5952 llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5953 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5954
5955 // struct _objc_method_list *
5956 MethodListTy =
5957 llvm::StructType::create(VMContext, "struct._objc_method_list");
5958 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5959
5960 // struct _objc_class_extension *
5961 ClassExtensionTy = llvm::StructType::create(
5962 "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy);
5963 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5964
5965 ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5966
5967 // struct _objc_class {
5968 // Class isa;
5969 // Class super_class;
5970 // char *name;
5971 // long version;
5972 // long info;
5973 // long instance_size;
5974 // struct _objc_ivar_list *ivars;
5975 // struct _objc_method_list *methods;
5976 // struct _objc_cache *cache;
5977 // struct _objc_protocol_list *protocols;
5978 // char *ivar_layout;
5979 // struct _objc_class_ext *ext;
5980 // };
5981 ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5982 llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy,
5983 LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy,
5984 ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy);
5985
5986 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5987
5988 // struct _objc_category {
5989 // char *category_name;
5990 // char *class_name;
5991 // struct _objc_method_list *instance_method;
5992 // struct _objc_method_list *class_method;
5993 // struct _objc_protocol_list *protocols;
5994 // uint32_t size; // sizeof(struct _objc_category)
5995 // struct _objc_property_list *instance_properties;// category's @property
5996 // struct _objc_property_list *class_properties;
5997 // }
5998 CategoryTy = llvm::StructType::create(
5999 "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy,
6000 MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy,
6001 PropertyListPtrTy);
6002
6003 // Global metadata structures
6004
6005 // struct _objc_symtab {
6006 // long sel_ref_cnt;
6007 // SEL *refs;
6008 // short cls_def_cnt;
6009 // short cat_def_cnt;
6010 // char *defs[cls_def_cnt + cat_def_cnt];
6011 // }
6012 SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy,
6013 SelectorPtrTy, ShortTy, ShortTy,
6014 llvm::ArrayType::get(Int8PtrTy, 0));
6015 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
6016
6017 // struct _objc_module {
6018 // long version;
6019 // long size; // sizeof(struct _objc_module)
6020 // char *name;
6021 // struct _objc_symtab* symtab;
6022 // }
6023 ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy,
6024 Int8PtrTy, SymtabPtrTy);
6025
6026 // FIXME: This is the size of the setjmp buffer and should be target
6027 // specific. 18 is what's used on 32-bit X86.
6028 uint64_t SetJmpBufferSize = 18;
6029
6030 // Exceptions
6031 llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
6032
6033 ExceptionDataTy = llvm::StructType::create(
6034 "struct._objc_exception_data",
6035 llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy);
6036}
6037
6038ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
6039 : ObjCCommonTypesHelper(cgm) {
6040 // struct _method_list_t {
6041 // uint32_t entsize; // sizeof(struct _objc_method)
6042 // uint32_t method_count;
6043 // struct _objc_method method_list[method_count];
6044 // }
6045 MethodListnfABITy =
6046 llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
6047 llvm::ArrayType::get(MethodTy, 0));
6048 // struct method_list_t *
6049 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
6050
6051 // struct _protocol_t {
6052 // id isa; // NULL
6053 // const char * const protocol_name;
6054 // const struct _protocol_list_t * protocol_list; // super protocols
6055 // const struct method_list_t * const instance_methods;
6056 // const struct method_list_t * const class_methods;
6057 // const struct method_list_t *optionalInstanceMethods;
6058 // const struct method_list_t *optionalClassMethods;
6059 // const struct _prop_list_t * properties;
6060 // const uint32_t size; // sizeof(struct _protocol_t)
6061 // const uint32_t flags; // = 0
6062 // const char ** extendedMethodTypes;
6063 // const char *demangledName;
6064 // const struct _prop_list_t * class_properties;
6065 // }
6066
6067 // Holder for struct _protocol_list_t *
6068 ProtocolListnfABITy =
6069 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
6070
6071 ProtocolnfABITy = llvm::StructType::create(
6072 "struct._protocol_t", ObjectPtrTy, Int8PtrTy,
6073 llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy,
6074 MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy,
6075 PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy,
6076 PropertyListPtrTy);
6077
6078 // struct _protocol_t*
6079 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
6080
6081 // struct _protocol_list_t {
6082 // long protocol_count; // Note, this is 32/64 bit
6083 // struct _protocol_t *[protocol_count];
6084 // }
6085 ProtocolListnfABITy->setBody(LongTy,
6086 llvm::ArrayType::get(ProtocolnfABIPtrTy, 0));
6087
6088 // struct _objc_protocol_list*
6089 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
6090
6091 // struct _ivar_t {
6092 // unsigned [long] int *offset; // pointer to ivar offset location
6093 // char *name;
6094 // char *type;
6095 // uint32_t alignment;
6096 // uint32_t size;
6097 // }
6098 IvarnfABITy = llvm::StructType::create(
6099 "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
6100 Int8PtrTy, Int8PtrTy, IntTy, IntTy);
6101
6102 // struct _ivar_list_t {
6103 // uint32 entsize; // sizeof(struct _ivar_t)
6104 // uint32 count;
6105 // struct _iver_t list[count];
6106 // }
6107 IvarListnfABITy =
6108 llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
6109 llvm::ArrayType::get(IvarnfABITy, 0));
6110
6111 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
6112
6113 // struct _class_ro_t {
6114 // uint32_t const flags;
6115 // uint32_t const instanceStart;
6116 // uint32_t const instanceSize;
6117 // uint32_t const reserved; // only when building for 64bit targets
6118 // const uint8_t * const ivarLayout;
6119 // const char *const name;
6120 // const struct _method_list_t * const baseMethods;
6121 // const struct _objc_protocol_list *const baseProtocols;
6122 // const struct _ivar_list_t *const ivars;
6123 // const uint8_t * const weakIvarLayout;
6124 // const struct _prop_list_t * const properties;
6125 // }
6126
6127 // FIXME. Add 'reserved' field in 64bit abi mode!
6128 ClassRonfABITy = llvm::StructType::create(
6129 "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy,
6130 MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy,
6131 Int8PtrTy, PropertyListPtrTy);
6132
6133 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
6134 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
6135 ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
6136 ->getPointerTo();
6137
6138 // struct _class_t {
6139 // struct _class_t *isa;
6140 // struct _class_t * const superclass;
6141 // void *cache;
6142 // IMP *vtable;
6143 // struct class_ro_t *ro;
6144 // }
6145
6146 ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
6147 ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
6148 llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy,
6149 llvm::PointerType::getUnqual(ImpnfABITy),
6150 llvm::PointerType::getUnqual(ClassRonfABITy));
6151
6152 // LLVM for struct _class_t *
6153 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
6154
6155 // struct _category_t {
6156 // const char * const name;
6157 // struct _class_t *const cls;
6158 // const struct _method_list_t * const instance_methods;
6159 // const struct _method_list_t * const class_methods;
6160 // const struct _protocol_list_t * const protocols;
6161 // const struct _prop_list_t * const properties;
6162 // const struct _prop_list_t * const class_properties;
6163 // const uint32_t size;
6164 // }
6165 CategorynfABITy = llvm::StructType::create(
6166 "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy,
6167 MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy,
6168 PropertyListPtrTy, IntTy);
6169
6170 // New types for nonfragile abi messaging.
6171 CodeGen::CodeGenTypes &Types = CGM.getTypes();
6172 ASTContext &Ctx = CGM.getContext();
6173
6174 // MessageRefTy - LLVM for:
6175 // struct _message_ref_t {
6176 // IMP messenger;
6177 // SEL name;
6178 // };
6179
6180 // First the clang type for struct _message_ref_t
6181 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
6182 Ctx.getTranslationUnitDecl(),
6183 SourceLocation(), SourceLocation(),
6184 &Ctx.Idents.get("_message_ref_t"));
6185 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
6186 nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
6187 ICIS_NoInit));
6188 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
6189 nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
6190 false, ICIS_NoInit));
6191 RD->completeDefinition();
6192
6193 MessageRefCTy = Ctx.getTagDeclType(RD);
6194 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
6195 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
6196
6197 // MessageRefPtrTy - LLVM for struct _message_ref_t*
6198 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
6199
6200 // SuperMessageRefTy - LLVM for:
6201 // struct _super_message_ref_t {
6202 // SUPER_IMP messenger;
6203 // SEL name;
6204 // };
6205 SuperMessageRefTy = llvm::StructType::create("struct._super_message_ref_t",
6206 ImpnfABITy, SelectorPtrTy);
6207
6208 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
6209 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
6210
6211
6212 // struct objc_typeinfo {
6213 // const void** vtable; // objc_ehtype_vtable + 2
6214 // const char* name; // c++ typeinfo string
6215 // Class cls;
6216 // };
6217 EHTypeTy = llvm::StructType::create("struct._objc_typeinfo",
6218 llvm::PointerType::getUnqual(Int8PtrTy),
6219 Int8PtrTy, ClassnfABIPtrTy);
6220 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
6221}
6222
6223llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
6224 FinishNonFragileABIModule();
6225
6226 return nullptr;
6227}
6228
6229void CGObjCNonFragileABIMac::AddModuleClassList(
6230 ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName,
6231 StringRef SectionName) {
6232 unsigned NumClasses = Container.size();
6233
6234 if (!NumClasses)
6235 return;
6236
6237 SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
6238 for (unsigned i=0; i<NumClasses; i++)
6239 Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
6240 ObjCTypes.Int8PtrTy);
6241 llvm::Constant *Init =
6242 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
6243 Symbols.size()),
6244 Symbols);
6245
6246 // Section name is obtained by calling GetSectionName, which returns
6247 // sections in the __DATA segment on MachO.
6248 assert((!CGM.getTriple().isOSBinFormatMachO() ||(static_cast <bool> ((!CGM.getTriple().isOSBinFormatMachO
() || SectionName.startswith("__DATA")) && "SectionName expected to start with __DATA on MachO"
) ? void (0) : __assert_fail ("(!CGM.getTriple().isOSBinFormatMachO() || SectionName.startswith(\"__DATA\")) && \"SectionName expected to start with __DATA on MachO\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 6250, __extension__ __PRETTY_FUNCTION__))
6249 SectionName.startswith("__DATA")) &&(static_cast <bool> ((!CGM.getTriple().isOSBinFormatMachO
() || SectionName.startswith("__DATA")) && "SectionName expected to start with __DATA on MachO"
) ? void (0) : __assert_fail ("(!CGM.getTriple().isOSBinFormatMachO() || SectionName.startswith(\"__DATA\")) && \"SectionName expected to start with __DATA on MachO\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 6250, __extension__ __PRETTY_FUNCTION__))
6250 "SectionName expected to start with __DATA on MachO")(static_cast <bool> ((!CGM.getTriple().isOSBinFormatMachO
() || SectionName.startswith("__DATA")) && "SectionName expected to start with __DATA on MachO"
) ? void (0) : __assert_fail ("(!CGM.getTriple().isOSBinFormatMachO() || SectionName.startswith(\"__DATA\")) && \"SectionName expected to start with __DATA on MachO\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 6250, __extension__ __PRETTY_FUNCTION__))
;
6251 llvm::GlobalVariable *GV = new llvm::GlobalVariable(
6252 CGM.getModule(), Init->getType(), false,
6253 llvm::GlobalValue::PrivateLinkage, Init, SymbolName);
6254 GV->setAlignment(
6255 llvm::Align(CGM.getDataLayout().getABITypeAlignment(Init->getType())));
6256 GV->setSection(SectionName);
6257 CGM.addCompilerUsedGlobal(GV);
6258}
6259
6260void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
6261 // nonfragile abi has no module definition.
6262
6263 // Build list of all implemented class addresses in array
6264 // L_OBJC_LABEL_CLASS_$.
6265
6266 for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
6267 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
6268 assert(ID)(static_cast <bool> (ID) ? void (0) : __assert_fail ("ID"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 6268, __extension__ __PRETTY_FUNCTION__))
;
6269 if (ObjCImplementationDecl *IMP = ID->getImplementation())
6270 // We are implementing a weak imported interface. Give it external linkage
6271 if (ID->isWeakImported() && !IMP->isWeakImported()) {
6272 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6273 DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6274 }
6275 }
6276
6277 AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
6278 GetSectionName("__objc_classlist",
6279 "regular,no_dead_strip"));
6280
6281 AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$",
6282 GetSectionName("__objc_nlclslist",
6283 "regular,no_dead_strip"));
6284
6285 // Build list of all implemented category addresses in array
6286 // L_OBJC_LABEL_CATEGORY_$.
6287 AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$",
6288 GetSectionName("__objc_catlist",
6289 "regular,no_dead_strip"));
6290 AddModuleClassList(DefinedStubCategories, "OBJC_LABEL_STUB_CATEGORY_$",
6291 GetSectionName("__objc_catlist2",
6292 "regular,no_dead_strip"));
6293 AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$",
6294 GetSectionName("__objc_nlcatlist",
6295 "regular,no_dead_strip"));
6296
6297 EmitImageInfo();
6298}
6299
6300/// isVTableDispatchedSelector - Returns true if SEL is not in the list of
6301/// VTableDispatchMethods; false otherwise. What this means is that
6302/// except for the 19 selectors in the list, we generate 32bit-style
6303/// message dispatch call for all the rest.
6304bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
6305 // At various points we've experimented with using vtable-based
6306 // dispatch for all methods.
6307 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
6308 case CodeGenOptions::Legacy:
6309 return false;
6310 case CodeGenOptions::NonLegacy:
6311 return true;
6312 case CodeGenOptions::Mixed:
6313 break;
6314 }
6315
6316 // If so, see whether this selector is in the white-list of things which must
6317 // use the new dispatch convention. We lazily build a dense set for this.
6318 if (VTableDispatchMethods.empty()) {
6319 VTableDispatchMethods.insert(GetNullarySelector("alloc"));
6320 VTableDispatchMethods.insert(GetNullarySelector("class"));
6321 VTableDispatchMethods.insert(GetNullarySelector("self"));
6322 VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
6323 VTableDispatchMethods.insert(GetNullarySelector("length"));
6324 VTableDispatchMethods.insert(GetNullarySelector("count"));
6325
6326 // These are vtable-based if GC is disabled.
6327 // Optimistically use vtable dispatch for hybrid compiles.
6328 if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
6329 VTableDispatchMethods.insert(GetNullarySelector("retain"));
6330 VTableDispatchMethods.insert(GetNullarySelector("release"));
6331 VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
6332 }
6333
6334 VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
6335 VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
6336 VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
6337 VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
6338 VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
6339 VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
6340 VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
6341
6342 // These are vtable-based if GC is enabled.
6343 // Optimistically use vtable dispatch for hybrid compiles.
6344 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
6345 VTableDispatchMethods.insert(GetNullarySelector("hash"));
6346 VTableDispatchMethods.insert(GetUnarySelector("addObject"));
6347
6348 // "countByEnumeratingWithState:objects:count"
6349 IdentifierInfo *KeyIdents[] = {
6350 &CGM.getContext().Idents.get("countByEnumeratingWithState"),
6351 &CGM.getContext().Idents.get("objects"),
6352 &CGM.getContext().Idents.get("count")
6353 };
6354 VTableDispatchMethods.insert(
6355 CGM.getContext().Selectors.getSelector(3, KeyIdents));
6356 }
6357 }
6358
6359 return VTableDispatchMethods.count(Sel);
6360}
6361
6362/// BuildClassRoTInitializer - generate meta-data for:
6363/// struct _class_ro_t {
6364/// uint32_t const flags;
6365/// uint32_t const instanceStart;
6366/// uint32_t const instanceSize;
6367/// uint32_t const reserved; // only when building for 64bit targets
6368/// const uint8_t * const ivarLayout;
6369/// const char *const name;
6370/// const struct _method_list_t * const baseMethods;
6371/// const struct _protocol_list_t *const baseProtocols;
6372/// const struct _ivar_list_t *const ivars;
6373/// const uint8_t * const weakIvarLayout;
6374/// const struct _prop_list_t * const properties;
6375/// }
6376///
6377llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
6378 unsigned flags,
6379 unsigned InstanceStart,
6380 unsigned InstanceSize,
6381 const ObjCImplementationDecl *ID) {
6382 std::string ClassName = std::string(ID->getObjCRuntimeNameAsString());
6383
6384 CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
6385 CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
6386
6387 bool hasMRCWeak = false;
6388 if (CGM.getLangOpts().ObjCAutoRefCount)
6389 flags |= NonFragileABI_Class_CompiledByARC;
6390 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
6391 flags |= NonFragileABI_Class_HasMRCWeakIvars;
6392
6393 ConstantInitBuilder builder(CGM);
6394 auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy);
6395
6396 values.addInt(ObjCTypes.IntTy, flags);
6397 values.addInt(ObjCTypes.IntTy, InstanceStart);
6398 values.addInt(ObjCTypes.IntTy, InstanceSize);
6399 values.add((flags & NonFragileABI_Class_Meta)
6400 ? GetIvarLayoutName(nullptr, ObjCTypes)
6401 : BuildStrongIvarLayout(ID, beginInstance, endInstance));
6402 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
6403
6404 // const struct _method_list_t * const baseMethods;
6405 SmallVector<const ObjCMethodDecl*, 16> methods;
6406 if (flags & NonFragileABI_Class_Meta) {
6407 for (const auto *MD : ID->class_methods())
6408 if (!MD->isDirectMethod())
6409 methods.push_back(MD);
6410 } else {
6411 for (const auto *MD : ID->instance_methods())
6412 if (!MD->isDirectMethod())
6413 methods.push_back(MD);
6414 }
6415
6416 values.add(emitMethodList(ID->getObjCRuntimeNameAsString(),
6417 (flags & NonFragileABI_Class_Meta)
6418 ? MethodListType::ClassMethods
6419 : MethodListType::InstanceMethods,
6420 methods));
6421
6422 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6423 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer")(static_cast <bool> (OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer"
) ? void (0) : __assert_fail ("OID && \"CGObjCNonFragileABIMac::BuildClassRoTInitializer\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 6423, __extension__ __PRETTY_FUNCTION__))
;
6424 values.add(EmitProtocolList("_OBJC_CLASS_PROTOCOLS_$_"
6425 + OID->getObjCRuntimeNameAsString(),
6426 OID->all_referenced_protocol_begin(),
6427 OID->all_referenced_protocol_end()));
6428
6429 if (flags & NonFragileABI_Class_Meta) {
6430 values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy);
6431 values.add(GetIvarLayoutName(nullptr, ObjCTypes));
6432 values.add(EmitPropertyList(
6433 "_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6434 ID, ID->getClassInterface(), ObjCTypes, true));
6435 } else {
6436 values.add(EmitIvarList(ID));
6437 values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak));
6438 values.add(EmitPropertyList(
6439 "_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6440 ID, ID->getClassInterface(), ObjCTypes, false));
6441 }
6442
6443 llvm::SmallString<64> roLabel;
6444 llvm::raw_svector_ostream(roLabel)
6445 << ((flags & NonFragileABI_Class_Meta) ? "_OBJC_METACLASS_RO_$_"
6446 : "_OBJC_CLASS_RO_$_")
6447 << ClassName;
6448
6449 return finishAndCreateGlobal(values, roLabel, CGM);
6450}
6451
6452/// Build the metaclass object for a class.
6453///
6454/// struct _class_t {
6455/// struct _class_t *isa;
6456/// struct _class_t * const superclass;
6457/// void *cache;
6458/// IMP *vtable;
6459/// struct class_ro_t *ro;
6460/// }
6461///
6462llvm::GlobalVariable *
6463CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI,
6464 bool isMetaclass,
6465 llvm::Constant *IsAGV,
6466 llvm::Constant *SuperClassGV,
6467 llvm::Constant *ClassRoGV,
6468 bool HiddenVisibility) {
6469 ConstantInitBuilder builder(CGM);
6470 auto values = builder.beginStruct(ObjCTypes.ClassnfABITy);
6471 values.add(IsAGV);
6472 if (SuperClassGV) {
6473 values.add(SuperClassGV);
6474 } else {
6475 values.addNullPointer(ObjCTypes.ClassnfABIPtrTy);
6476 }
6477 values.add(ObjCEmptyCacheVar);
6478 values.add(ObjCEmptyVtableVar);
6479 values.add(ClassRoGV);
6480
6481 llvm::GlobalVariable *GV =
6482 cast<llvm::GlobalVariable>(GetClassGlobal(CI, isMetaclass, ForDefinition));
6483 values.finishAndSetAsInitializer(GV);
6484
6485 if (CGM.getTriple().isOSBinFormatMachO())
6486 GV->setSection("__DATA, __objc_data");
6487 GV->setAlignment(llvm::Align(
6488 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy)));
6489 if (!CGM.getTriple().isOSBinFormatCOFF())
6490 if (HiddenVisibility)
6491 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6492 return GV;
6493}
6494
6495bool CGObjCNonFragileABIMac::ImplementationIsNonLazy(
6496 const ObjCImplDecl *OD) const {
6497 return OD->getClassMethod(GetNullarySelector("load")) != nullptr ||
6498 OD->getClassInterface()->hasAttr<ObjCNonLazyClassAttr>() ||
6499 OD->hasAttr<ObjCNonLazyClassAttr>();
6500}
6501
6502void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
6503 uint32_t &InstanceStart,
6504 uint32_t &InstanceSize) {
6505 const ASTRecordLayout &RL =
6506 CGM.getContext().getASTObjCImplementationLayout(OID);
6507
6508 // InstanceSize is really instance end.
6509 InstanceSize = RL.getDataSize().getQuantity();
6510
6511 // If there are no fields, the start is the same as the end.
6512 if (!RL.getFieldCount())
6513 InstanceStart = InstanceSize;
6514 else
6515 InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
6516}
6517
6518static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM,
6519 StringRef Name) {
6520 IdentifierInfo &II = CGM.getContext().Idents.get(Name);
6521 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
6522 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
6523
6524 const VarDecl *VD = nullptr;
6525 for (const auto *Result : DC->lookup(&II))
6526 if ((VD = dyn_cast<VarDecl>(Result)))
6527 break;
6528
6529 if (!VD)
6530 return llvm::GlobalValue::DLLImportStorageClass;
6531 if (VD->hasAttr<DLLExportAttr>())
6532 return llvm::GlobalValue::DLLExportStorageClass;
6533 if (VD->hasAttr<DLLImportAttr>())
6534 return llvm::GlobalValue::DLLImportStorageClass;
6535 return llvm::GlobalValue::DefaultStorageClass;
6536}
6537
6538void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
6539 if (!ObjCEmptyCacheVar) {
6540 ObjCEmptyCacheVar =
6541 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false,
6542 llvm::GlobalValue::ExternalLinkage, nullptr,
6543 "_objc_empty_cache");
6544 if (CGM.getTriple().isOSBinFormatCOFF())
6545 ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache"));
6546
6547 // Only OS X with deployment version <10.9 use the empty vtable symbol
6548 const llvm::Triple &Triple = CGM.getTarget().getTriple();
6549 if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9))
6550 ObjCEmptyVtableVar =
6551 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false,
6552 llvm::GlobalValue::ExternalLinkage, nullptr,
6553 "_objc_empty_vtable");
6554 else
6555 ObjCEmptyVtableVar =
6556 llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo());
6557 }
6558
6559 // FIXME: Is this correct (that meta class size is never computed)?
6560 uint32_t InstanceStart =
6561 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
6562 uint32_t InstanceSize = InstanceStart;
6563 uint32_t flags = NonFragileABI_Class_Meta;
6564
6565 llvm::Constant *SuperClassGV, *IsAGV;
6566
6567 const auto *CI = ID->getClassInterface();
6568 assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0")(static_cast <bool> (CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0"
) ? void (0) : __assert_fail ("CI && \"CGObjCNonFragileABIMac::GenerateClass - class is 0\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 6568, __extension__ __PRETTY_FUNCTION__))
;
6569
6570 // Build the flags for the metaclass.
6571 bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF())
6572 ? !CI->hasAttr<DLLExportAttr>()
6573 : CI->getVisibility() == HiddenVisibility;
6574 if (classIsHidden)
6575 flags |= NonFragileABI_Class_Hidden;
6576
6577 // FIXME: why is this flag set on the metaclass?
6578 // ObjC metaclasses have no fields and don't really get constructed.
6579 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6580 flags |= NonFragileABI_Class_HasCXXStructors;
6581 if (!ID->hasNonZeroConstructors())
6582 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6583 }
6584
6585 if (!CI->getSuperClass()) {
6586 // class is root
6587 flags |= NonFragileABI_Class_Root;
6588
6589 SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition);
6590 IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition);
6591 } else {
6592 // Has a root. Current class is not a root.
6593 const ObjCInterfaceDecl *Root = ID->getClassInterface();
6594 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
6595 Root = Super;
6596
6597 const auto *Super = CI->getSuperClass();
6598 IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition);
6599 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition);
6600 }
6601
6602 llvm::GlobalVariable *CLASS_RO_GV =
6603 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6604
6605 llvm::GlobalVariable *MetaTClass =
6606 BuildClassObject(CI, /*metaclass*/ true,
6607 IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden);
6608 CGM.setGVProperties(MetaTClass, CI);
6609 DefinedMetaClasses.push_back(MetaTClass);
6610
6611 // Metadata for the class
6612 flags = 0;
6613 if (classIsHidden)
6614 flags |= NonFragileABI_Class_Hidden;
6615
6616 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6617 flags |= NonFragileABI_Class_HasCXXStructors;
6618
6619 // Set a flag to enable a runtime optimization when a class has
6620 // fields that require destruction but which don't require
6621 // anything except zero-initialization during construction. This
6622 // is most notably true of __strong and __weak types, but you can
6623 // also imagine there being C++ types with non-trivial default
6624 // constructors that merely set all fields to null.
6625 if (!ID->hasNonZeroConstructors())
6626 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6627 }
6628
6629 if (hasObjCExceptionAttribute(CGM.getContext(), CI))
6630 flags |= NonFragileABI_Class_Exception;
6631
6632 if (!CI->getSuperClass()) {
6633 flags |= NonFragileABI_Class_Root;
6634 SuperClassGV = nullptr;
6635 } else {
6636 // Has a root. Current class is not a root.
6637 const auto *Super = CI->getSuperClass();
6638 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition);
6639 }
6640
6641 GetClassSizeInfo(ID, InstanceStart, InstanceSize);
6642 CLASS_RO_GV =
6643 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6644
6645 llvm::GlobalVariable *ClassMD =
6646 BuildClassObject(CI, /*metaclass*/ false,
6647 MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden);
6648 CGM.setGVProperties(ClassMD, CI);
6649 DefinedClasses.push_back(ClassMD);
6650 ImplementedClasses.push_back(CI);
6651
6652 // Determine if this class is also "non-lazy".
6653 if (ImplementationIsNonLazy(ID))
6654 DefinedNonLazyClasses.push_back(ClassMD);
6655
6656 // Force the definition of the EHType if necessary.
6657 if (flags & NonFragileABI_Class_Exception)
6658 (void) GetInterfaceEHType(CI, ForDefinition);
6659 // Make sure method definition entries are all clear for next implementation.
6660 MethodDefinitions.clear();
6661}
6662
6663/// GenerateProtocolRef - This routine is called to generate code for
6664/// a protocol reference expression; as in:
6665/// @code
6666/// @protocol(Proto1);
6667/// @endcode
6668/// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
6669/// which will hold address of the protocol meta-data.
6670///
6671llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
6672 const ObjCProtocolDecl *PD) {
6673
6674 // This routine is called for @protocol only. So, we must build definition
6675 // of protocol's meta-data (not a reference to it!)
6676 assert(!PD->isNonRuntimeProtocol() &&(static_cast <bool> (!PD->isNonRuntimeProtocol() &&
"attempting to get a protocol ref to a static protocol.") ? void
(0) : __assert_fail ("!PD->isNonRuntimeProtocol() && \"attempting to get a protocol ref to a static protocol.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 6677, __extension__ __PRETTY_FUNCTION__))
6677 "attempting to get a protocol ref to a static protocol.")(static_cast <bool> (!PD->isNonRuntimeProtocol() &&
"attempting to get a protocol ref to a static protocol.") ? void
(0) : __assert_fail ("!PD->isNonRuntimeProtocol() && \"attempting to get a protocol ref to a static protocol.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 6677, __extension__ __PRETTY_FUNCTION__))
;
6678 llvm::Constant *Init =
6679 llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
6680 ObjCTypes.getExternalProtocolPtrTy());
6681
6682 std::string ProtocolName("_OBJC_PROTOCOL_REFERENCE_$_");
6683 ProtocolName += PD->getObjCRuntimeNameAsString();
6684
6685 CharUnits Align = CGF.getPointerAlign();
6686
6687 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
6688 if (PTGV)
6689 return CGF.Builder.CreateAlignedLoad(PTGV->getValueType(), PTGV, Align);
6690 PTGV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6691 llvm::GlobalValue::WeakAnyLinkage, Init,
6692 ProtocolName);
6693 PTGV->setSection(GetSectionName("__objc_protorefs",
6694 "coalesced,no_dead_strip"));
6695 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6696 PTGV->setAlignment(Align.getAsAlign());
6697 if (!CGM.getTriple().isOSBinFormatMachO())
6698 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolName));
6699 CGM.addUsedGlobal(PTGV);
6700 return CGF.Builder.CreateAlignedLoad(PTGV->getValueType(), PTGV, Align);
6701}
6702
6703/// GenerateCategory - Build metadata for a category implementation.
6704/// struct _category_t {
6705/// const char * const name;
6706/// struct _class_t *const cls;
6707/// const struct _method_list_t * const instance_methods;
6708/// const struct _method_list_t * const class_methods;
6709/// const struct _protocol_list_t * const protocols;
6710/// const struct _prop_list_t * const properties;
6711/// const struct _prop_list_t * const class_properties;
6712/// const uint32_t size;
6713/// }
6714///
6715void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
6716 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
6717 const char *Prefix = "_OBJC_$_CATEGORY_";
6718
6719 llvm::SmallString<64> ExtCatName(Prefix);
6720 ExtCatName += Interface->getObjCRuntimeNameAsString();
6721 ExtCatName += "_$_";
6722 ExtCatName += OCD->getNameAsString();
6723
6724 ConstantInitBuilder builder(CGM);
6725 auto values = builder.beginStruct(ObjCTypes.CategorynfABITy);
6726 values.add(GetClassName(OCD->getIdentifier()->getName()));
6727 // meta-class entry symbol
6728 values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition));
6729 std::string listName =
6730 (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str();
6731
6732 SmallVector<const ObjCMethodDecl *, 16> instanceMethods;
6733 SmallVector<const ObjCMethodDecl *, 8> classMethods;
6734 for (const auto *MD : OCD->methods()) {
6735 if (MD->isDirectMethod())
6736 continue;
6737 if (MD->isInstanceMethod()) {
6738 instanceMethods.push_back(MD);
6739 } else {
6740 classMethods.push_back(MD);
6741 }
6742 }
6743
6744 values.add(emitMethodList(listName, MethodListType::CategoryInstanceMethods,
6745 instanceMethods));
6746 values.add(emitMethodList(listName, MethodListType::CategoryClassMethods,
6747 classMethods));
6748
6749 const ObjCCategoryDecl *Category =
6750 Interface->FindCategoryDeclaration(OCD->getIdentifier());
6751 if (Category) {
6752 SmallString<256> ExtName;
6753 llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
6754 << OCD->getName();
6755 values.add(EmitProtocolList("_OBJC_CATEGORY_PROTOCOLS_$_"
6756 + Interface->getObjCRuntimeNameAsString() + "_$_"
6757 + Category->getName(),
6758 Category->protocol_begin(),
6759 Category->protocol_end()));
6760 values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
6761 OCD, Category, ObjCTypes, false));
6762 values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
6763 OCD, Category, ObjCTypes, true));
6764 } else {
6765 values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy);
6766 values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6767 values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6768 }
6769
6770 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy);
6771 values.addInt(ObjCTypes.IntTy, Size);
6772
6773 llvm::GlobalVariable *GCATV =
6774 finishAndCreateGlobal(values, ExtCatName.str(), CGM);
6775 CGM.addCompilerUsedGlobal(GCATV);
6776 if (Interface->hasAttr<ObjCClassStubAttr>())
6777 DefinedStubCategories.push_back(GCATV);
6778 else
6779 DefinedCategories.push_back(GCATV);
6780
6781 // Determine if this category is also "non-lazy".
6782 if (ImplementationIsNonLazy(OCD))
6783 DefinedNonLazyCategories.push_back(GCATV);
6784 // method definition entries must be clear for next implementation.
6785 MethodDefinitions.clear();
6786}
6787
6788/// emitMethodConstant - Return a struct objc_method constant. If
6789/// forProtocol is true, the implementation will be null; otherwise,
6790/// the method must have a definition registered with the runtime.
6791///
6792/// struct _objc_method {
6793/// SEL _cmd;
6794/// char *method_type;
6795/// char *_imp;
6796/// }
6797void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
6798 const ObjCMethodDecl *MD,
6799 bool forProtocol) {
6800 auto method = builder.beginStruct(ObjCTypes.MethodTy);
6801 method.addBitCast(GetMethodVarName(MD->getSelector()),
6802 ObjCTypes.SelectorPtrTy);
6803 method.add(GetMethodVarType(MD));
6804
6805 if (forProtocol) {
6806 // Protocol methods have no implementation. So, this entry is always NULL.
6807 method.addNullPointer(ObjCTypes.Int8PtrTy);
6808 } else {
6809 llvm::Function *fn = GetMethodDefinition(MD);
6810 assert(fn && "no definition for method?")(static_cast <bool> (fn && "no definition for method?"
) ? void (0) : __assert_fail ("fn && \"no definition for method?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 6810, __extension__ __PRETTY_FUNCTION__))
;
6811 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
6812 }
6813
6814 method.finishAndAddTo(builder);
6815}
6816
6817/// Build meta-data for method declarations.
6818///
6819/// struct _method_list_t {
6820/// uint32_t entsize; // sizeof(struct _objc_method)
6821/// uint32_t method_count;
6822/// struct _objc_method method_list[method_count];
6823/// }
6824///
6825llvm::Constant *
6826CGObjCNonFragileABIMac::emitMethodList(Twine name, MethodListType kind,
6827 ArrayRef<const ObjCMethodDecl *> methods) {
6828 // Return null for empty list.
6829 if (methods.empty())
6830 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
6831
6832 StringRef prefix;
6833 bool forProtocol;
6834 switch (kind) {
6835 case MethodListType::CategoryInstanceMethods:
6836 prefix = "_OBJC_$_CATEGORY_INSTANCE_METHODS_";
6837 forProtocol = false;
6838 break;
6839 case MethodListType::CategoryClassMethods:
6840 prefix = "_OBJC_$_CATEGORY_CLASS_METHODS_";
6841 forProtocol = false;
6842 break;
6843 case MethodListType::InstanceMethods:
6844 prefix = "_OBJC_$_INSTANCE_METHODS_";
6845 forProtocol = false;
6846 break;
6847 case MethodListType::ClassMethods:
6848 prefix = "_OBJC_$_CLASS_METHODS_";
6849 forProtocol = false;
6850 break;
6851
6852 case MethodListType::ProtocolInstanceMethods:
6853 prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_";
6854 forProtocol = true;
6855 break;
6856 case MethodListType::ProtocolClassMethods:
6857 prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_";
6858 forProtocol = true;
6859 break;
6860 case MethodListType::OptionalProtocolInstanceMethods:
6861 prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_";
6862 forProtocol = true;
6863 break;
6864 case MethodListType::OptionalProtocolClassMethods:
6865 prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_";
6866 forProtocol = true;
6867 break;
6868 }
6869
6870 ConstantInitBuilder builder(CGM);
6871 auto values = builder.beginStruct();
6872
6873 // sizeof(struct _objc_method)
6874 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
6875 values.addInt(ObjCTypes.IntTy, Size);
6876 // method_count
6877 values.addInt(ObjCTypes.IntTy, methods.size());
6878 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
6879 for (auto MD : methods)
6880 emitMethodConstant(methodArray, MD, forProtocol);
6881 methodArray.finishAndAddTo(values);
6882
6883 llvm::GlobalVariable *GV = finishAndCreateGlobal(values, prefix + name, CGM);
6884 CGM.addCompilerUsedGlobal(GV);
6885 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6886}
6887
6888/// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6889/// the given ivar.
6890llvm::GlobalVariable *
6891CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
6892 const ObjCIvarDecl *Ivar) {
6893 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
6894 llvm::SmallString<64> Name("OBJC_IVAR_$_");
6895 Name += Container->getObjCRuntimeNameAsString();
6896 Name += ".";
6897 Name += Ivar->getName();
6898 llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name);
6899 if (!IvarOffsetGV) {
6900 IvarOffsetGV =
6901 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.IvarOffsetVarTy,
6902 false, llvm::GlobalValue::ExternalLinkage,
6903 nullptr, Name.str());
6904 if (CGM.getTriple().isOSBinFormatCOFF()) {
6905 bool IsPrivateOrPackage =
6906 Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6907 Ivar->getAccessControl() == ObjCIvarDecl::Package;
6908
6909 const ObjCInterfaceDecl *ContainingID = Ivar->getContainingInterface();
6910
6911 if (ContainingID->hasAttr<DLLImportAttr>())
6912 IvarOffsetGV
6913 ->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6914 else if (ContainingID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage)
6915 IvarOffsetGV
6916 ->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6917 }
6918 }
6919 return IvarOffsetGV;
6920}
6921
6922llvm::Constant *
6923CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
6924 const ObjCIvarDecl *Ivar,
6925 unsigned long int Offset) {
6926 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
6927 IvarOffsetGV->setInitializer(
6928 llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
6929 IvarOffsetGV->setAlignment(llvm::Align(
6930 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy)));
6931
6932 if (!CGM.getTriple().isOSBinFormatCOFF()) {
6933 // FIXME: This matches gcc, but shouldn't the visibility be set on the use
6934 // as well (i.e., in ObjCIvarOffsetVariable).
6935 if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6936 Ivar->getAccessControl() == ObjCIvarDecl::Package ||
6937 ID->getVisibility() == HiddenVisibility)
6938 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6939 else
6940 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
6941 }
6942
6943 // If ID's layout is known, then make the global constant. This serves as a
6944 // useful assertion: we'll never use this variable to calculate ivar offsets,
6945 // so if the runtime tries to patch it then we should crash.
6946 if (isClassLayoutKnownStatically(ID))
6947 IvarOffsetGV->setConstant(true);
6948
6949 if (CGM.getTriple().isOSBinFormatMachO())
6950 IvarOffsetGV->setSection("__DATA, __objc_ivar");
6951 return IvarOffsetGV;
6952}
6953
6954/// EmitIvarList - Emit the ivar list for the given
6955/// implementation. The return value has type
6956/// IvarListnfABIPtrTy.
6957/// struct _ivar_t {
6958/// unsigned [long] int *offset; // pointer to ivar offset location
6959/// char *name;
6960/// char *type;
6961/// uint32_t alignment;
6962/// uint32_t size;
6963/// }
6964/// struct _ivar_list_t {
6965/// uint32 entsize; // sizeof(struct _ivar_t)
6966/// uint32 count;
6967/// struct _iver_t list[count];
6968/// }
6969///
6970
6971llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
6972 const ObjCImplementationDecl *ID) {
6973
6974 ConstantInitBuilder builder(CGM);
6975 auto ivarList = builder.beginStruct();
6976 ivarList.addInt(ObjCTypes.IntTy,
6977 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy));
6978 auto ivarCountSlot = ivarList.addPlaceholder();
6979 auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy);
6980
6981 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6982 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface")(static_cast <bool> (OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface"
) ? void (0) : __assert_fail ("OID && \"CGObjCNonFragileABIMac::EmitIvarList - null interface\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 6982, __extension__ __PRETTY_FUNCTION__))
;
6983
6984 // FIXME. Consolidate this with similar code in GenerateClass.
6985
6986 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
6987 IVD; IVD = IVD->getNextIvar()) {
6988 // Ignore unnamed bit-fields.
6989 if (!IVD->getDeclName())
6990 continue;
6991
6992 auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy);
6993 ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD,
6994 ComputeIvarBaseOffset(CGM, ID, IVD)));
6995 ivar.add(GetMethodVarName(IVD->getIdentifier()));
6996 ivar.add(GetMethodVarType(IVD));
6997 llvm::Type *FieldTy =
6998 CGM.getTypes().ConvertTypeForMem(IVD->getType());
6999 unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
7000 unsigned Align = CGM.getContext().getPreferredTypeAlign(
7001 IVD->getType().getTypePtr()) >> 3;
7002 Align = llvm::Log2_32(Align);
7003 ivar.addInt(ObjCTypes.IntTy, Align);
7004 // NOTE. Size of a bitfield does not match gcc's, because of the
7005 // way bitfields are treated special in each. But I am told that
7006 // 'size' for bitfield ivars is ignored by the runtime so it does
7007 // not matter. If it matters, there is enough info to get the
7008 // bitfield right!
7009 ivar.addInt(ObjCTypes.IntTy, Size);
7010 ivar.finishAndAddTo(ivars);
7011 }
7012 // Return null for empty list.
7013 if (ivars.empty()) {
7014 ivars.abandon();
7015 ivarList.abandon();
7016 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
7017 }
7018
7019 auto ivarCount = ivars.size();
7020 ivars.finishAndAddTo(ivarList);
7021 ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount);
7022
7023 const char *Prefix = "_OBJC_$_INSTANCE_VARIABLES_";
7024 llvm::GlobalVariable *GV = finishAndCreateGlobal(
7025 ivarList, Prefix + OID->getObjCRuntimeNameAsString(), CGM);
7026 CGM.addCompilerUsedGlobal(GV);
7027 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
7028}
7029
7030llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
7031 const ObjCProtocolDecl *PD) {
7032 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
7033
7034 assert(!PD->isNonRuntimeProtocol() &&(static_cast <bool> (!PD->isNonRuntimeProtocol() &&
"attempting to GetOrEmit a non-runtime protocol") ? void (0)
: __assert_fail ("!PD->isNonRuntimeProtocol() && \"attempting to GetOrEmit a non-runtime protocol\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7035, __extension__ __PRETTY_FUNCTION__))
7035 "attempting to GetOrEmit a non-runtime protocol")(static_cast <bool> (!PD->isNonRuntimeProtocol() &&
"attempting to GetOrEmit a non-runtime protocol") ? void (0)
: __assert_fail ("!PD->isNonRuntimeProtocol() && \"attempting to GetOrEmit a non-runtime protocol\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7035, __extension__ __PRETTY_FUNCTION__))
;
7036 if (!Entry) {
7037 // We use the initializer as a marker of whether this is a forward
7038 // reference or not. At module finalization we add the empty
7039 // contents for protocols which were referenced but never defined.
7040 llvm::SmallString<64> Protocol;
7041 llvm::raw_svector_ostream(Protocol) << "_OBJC_PROTOCOL_$_"
7042 << PD->getObjCRuntimeNameAsString();
7043
7044 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
7045 false, llvm::GlobalValue::ExternalLinkage,
7046 nullptr, Protocol);
7047 if (!CGM.getTriple().isOSBinFormatMachO())
7048 Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol));
7049 }
7050
7051 return Entry;
7052}
7053
7054/// GetOrEmitProtocol - Generate the protocol meta-data:
7055/// @code
7056/// struct _protocol_t {
7057/// id isa; // NULL
7058/// const char * const protocol_name;
7059/// const struct _protocol_list_t * protocol_list; // super protocols
7060/// const struct method_list_t * const instance_methods;
7061/// const struct method_list_t * const class_methods;
7062/// const struct method_list_t *optionalInstanceMethods;
7063/// const struct method_list_t *optionalClassMethods;
7064/// const struct _prop_list_t * properties;
7065/// const uint32_t size; // sizeof(struct _protocol_t)
7066/// const uint32_t flags; // = 0
7067/// const char ** extendedMethodTypes;
7068/// const char *demangledName;
7069/// const struct _prop_list_t * class_properties;
7070/// }
7071/// @endcode
7072///
7073
7074llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
7075 const ObjCProtocolDecl *PD) {
7076 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
7077
7078 // Early exit if a defining object has already been generated.
7079 if (Entry && Entry->hasInitializer())
7080 return Entry;
7081
7082 // Use the protocol definition, if there is one.
7083 assert(PD->hasDefinition() &&(static_cast <bool> (PD->hasDefinition() && "emitting protocol metadata without definition"
) ? void (0) : __assert_fail ("PD->hasDefinition() && \"emitting protocol metadata without definition\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7084, __extension__ __PRETTY_FUNCTION__))
7084 "emitting protocol metadata without definition")(static_cast <bool> (PD->hasDefinition() && "emitting protocol metadata without definition"
) ? void (0) : __assert_fail ("PD->hasDefinition() && \"emitting protocol metadata without definition\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7084, __extension__ __PRETTY_FUNCTION__))
;
7085 PD = PD->getDefinition();
7086
7087 auto methodLists = ProtocolMethodLists::get(PD);
7088
7089 ConstantInitBuilder builder(CGM);
7090 auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy);
7091
7092 // isa is NULL
7093 values.addNullPointer(ObjCTypes.ObjectPtrTy);
7094 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
7095 values.add(EmitProtocolList("_OBJC_$_PROTOCOL_REFS_"
7096 + PD->getObjCRuntimeNameAsString(),
7097 PD->protocol_begin(),
7098 PD->protocol_end()));
7099 values.add(methodLists.emitMethodList(this, PD,
7100 ProtocolMethodLists::RequiredInstanceMethods));
7101 values.add(methodLists.emitMethodList(this, PD,
7102 ProtocolMethodLists::RequiredClassMethods));
7103 values.add(methodLists.emitMethodList(this, PD,
7104 ProtocolMethodLists::OptionalInstanceMethods));
7105 values.add(methodLists.emitMethodList(this, PD,
7106 ProtocolMethodLists::OptionalClassMethods));
7107 values.add(EmitPropertyList(
7108 "_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
7109 nullptr, PD, ObjCTypes, false));
7110 uint32_t Size =
7111 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
7112 values.addInt(ObjCTypes.IntTy, Size);
7113 values.addInt(ObjCTypes.IntTy, 0);
7114 values.add(EmitProtocolMethodTypes("_OBJC_$_PROTOCOL_METHOD_TYPES_"
7115 + PD->getObjCRuntimeNameAsString(),
7116 methodLists.emitExtendedTypesArray(this),
7117 ObjCTypes));
7118
7119 // const char *demangledName;
7120 values.addNullPointer(ObjCTypes.Int8PtrTy);
7121
7122 values.add(EmitPropertyList(
7123 "_OBJC_$_CLASS_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
7124 nullptr, PD, ObjCTypes, true));
7125
7126 if (Entry) {
7127 // Already created, fix the linkage and update the initializer.
7128 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
7129 values.finishAndSetAsInitializer(Entry);
7130 } else {
7131 llvm::SmallString<64> symbolName;
7132 llvm::raw_svector_ostream(symbolName)
7133 << "_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString();
7134
7135 Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(),
7136 /*constant*/ false,
7137 llvm::GlobalValue::WeakAnyLinkage);
7138 if (!CGM.getTriple().isOSBinFormatMachO())
7139 Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName));
7140
7141 Protocols[PD->getIdentifier()] = Entry;
7142 }
7143 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7144 CGM.addUsedGlobal(Entry);
7145
7146 // Use this protocol meta-data to build protocol list table in section
7147 // __DATA, __objc_protolist
7148 llvm::SmallString<64> ProtocolRef;
7149 llvm::raw_svector_ostream(ProtocolRef) << "_OBJC_LABEL_PROTOCOL_$_"
7150 << PD->getObjCRuntimeNameAsString();
7151
7152 llvm::GlobalVariable *PTGV =
7153 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
7154 false, llvm::GlobalValue::WeakAnyLinkage, Entry,
7155 ProtocolRef);
7156 if (!CGM.getTriple().isOSBinFormatMachO())
7157 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef));
7158 PTGV->setAlignment(llvm::Align(
7159 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy)));
7160 PTGV->setSection(GetSectionName("__objc_protolist",
7161 "coalesced,no_dead_strip"));
7162 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
7163 CGM.addUsedGlobal(PTGV);
7164 return Entry;
7165}
7166
7167/// EmitProtocolList - Generate protocol list meta-data:
7168/// @code
7169/// struct _protocol_list_t {
7170/// long protocol_count; // Note, this is 32/64 bit
7171/// struct _protocol_t[protocol_count];
7172/// }
7173/// @endcode
7174///
7175llvm::Constant *
7176CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
7177 ObjCProtocolDecl::protocol_iterator begin,
7178 ObjCProtocolDecl::protocol_iterator end) {
7179 // Just return null for empty protocol lists
7180 auto Protocols = GetRuntimeProtocolList(begin, end);
7181 if (Protocols.empty())
7182 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
7183
7184 SmallVector<llvm::Constant *, 16> ProtocolRefs;
7185 ProtocolRefs.reserve(Protocols.size());
7186
7187 for (const auto *PD : Protocols)
7188 ProtocolRefs.push_back(GetProtocolRef(PD));
7189
7190 // If all of the protocols in the protocol list are objc_non_runtime_protocol
7191 // just return null
7192 if (ProtocolRefs.size() == 0)
7193 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
7194
7195 // FIXME: We shouldn't need to do this lookup here, should we?
7196 SmallString<256> TmpName;
7197 Name.toVector(TmpName);
7198 llvm::GlobalVariable *GV =
7199 CGM.getModule().getGlobalVariable(TmpName.str(), true);
7200 if (GV)
7201 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
7202
7203 ConstantInitBuilder builder(CGM);
7204 auto values = builder.beginStruct();
7205 auto countSlot = values.addPlaceholder();
7206
7207 // A null-terminated array of protocols.
7208 auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy);
7209 for (auto const &proto : ProtocolRefs)
7210 array.add(proto);
7211 auto count = array.size();
7212 array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy);
7213
7214 array.finishAndAddTo(values);
7215 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
7216
7217 GV = finishAndCreateGlobal(values, Name, CGM);
7218 CGM.addCompilerUsedGlobal(GV);
7219 return llvm::ConstantExpr::getBitCast(GV,
7220 ObjCTypes.ProtocolListnfABIPtrTy);
7221}
7222
7223/// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
7224/// This code gen. amounts to generating code for:
7225/// @code
7226/// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
7227/// @encode
7228///
7229LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
7230 CodeGen::CodeGenFunction &CGF,
7231 QualType ObjectTy,
7232 llvm::Value *BaseValue,
7233 const ObjCIvarDecl *Ivar,
7234 unsigned CVRQualifiers) {
7235 ObjCInterfaceDecl *ID = ObjectTy->castAs<ObjCObjectType>()->getInterface();
7236 llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
7237 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
7238 Offset);
7239}
7240
7241llvm::Value *
7242CGObjCNonFragileABIMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
7243 const ObjCInterfaceDecl *Interface,
7244 const ObjCIvarDecl *Ivar) {
7245 llvm::Value *IvarOffsetValue;
7246 if (isClassLayoutKnownStatically(Interface)) {
7247 IvarOffsetValue = llvm::ConstantInt::get(
7248 ObjCTypes.IvarOffsetVarTy,
7249 ComputeIvarBaseOffset(CGM, Interface->getImplementation(), Ivar));
7250 } else {
7251 llvm::GlobalVariable *GV = ObjCIvarOffsetVariable(Interface, Ivar);
7252 IvarOffsetValue =
7253 CGF.Builder.CreateAlignedLoad(GV->getValueType(), GV,
7254 CGF.getSizeAlign(), "ivar");
7255 if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
7256 cast<llvm::LoadInst>(IvarOffsetValue)
7257 ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7258 llvm::MDNode::get(VMContext, None));
7259 }
7260
7261 // This could be 32bit int or 64bit integer depending on the architecture.
7262 // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
7263 // as this is what caller always expects.
7264 if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
7265 IvarOffsetValue = CGF.Builder.CreateIntCast(
7266 IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
7267 return IvarOffsetValue;
7268}
7269
7270static void appendSelectorForMessageRefTable(std::string &buffer,
7271 Selector selector) {
7272 if (selector.isUnarySelector()) {
7273 buffer += selector.getNameForSlot(0);
7274 return;
7275 }
7276
7277 for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
7278 buffer += selector.getNameForSlot(i);
7279 buffer += '_';
7280 }
7281}
7282
7283/// Emit a "vtable" message send. We emit a weak hidden-visibility
7284/// struct, initially containing the selector pointer and a pointer to
7285/// a "fixup" variant of the appropriate objc_msgSend. To call, we
7286/// load and call the function pointer, passing the address of the
7287/// struct as the second parameter. The runtime determines whether
7288/// the selector is currently emitted using vtable dispatch; if so, it
7289/// substitutes a stub function which simply tail-calls through the
7290/// appropriate vtable slot, and if not, it substitues a stub function
7291/// which tail-calls objc_msgSend. Both stubs adjust the selector
7292/// argument to correctly point to the selector.
7293RValue
7294CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
7295 ReturnValueSlot returnSlot,
7296 QualType resultType,
7297 Selector selector,
7298 llvm::Value *arg0,
7299 QualType arg0Type,
7300 bool isSuper,
7301 const CallArgList &formalArgs,
7302 const ObjCMethodDecl *method) {
7303 // Compute the actual arguments.
7304 CallArgList args;
7305
7306 // First argument: the receiver / super-call structure.
7307 if (!isSuper)
7308 arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
7309 args.add(RValue::get(arg0), arg0Type);
7310
7311 // Second argument: a pointer to the message ref structure. Leave
7312 // the actual argument value blank for now.
7313 args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);
7314
7315 args.insert(args.end(), formalArgs.begin(), formalArgs.end());
7316
7317 MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);
7318
7319 NullReturnState nullReturn;
7320
7321 // Find the function to call and the mangled name for the message
7322 // ref structure. Using a different mangled name wouldn't actually
7323 // be a problem; it would just be a waste.
7324 //
7325 // The runtime currently never uses vtable dispatch for anything
7326 // except normal, non-super message-sends.
7327 // FIXME: don't use this for that.
7328 llvm::FunctionCallee fn = nullptr;
7329 std::string messageRefName("_");
7330 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
7331 if (isSuper) {
7332 fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
7333 messageRefName += "objc_msgSendSuper2_stret_fixup";
7334 } else {
7335 nullReturn.init(CGF, arg0);
7336 fn = ObjCTypes.getMessageSendStretFixupFn();
7337 messageRefName += "objc_msgSend_stret_fixup";
7338 }
7339 } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
7340 fn = ObjCTypes.getMessageSendFpretFixupFn();
7341 messageRefName += "objc_msgSend_fpret_fixup";
7342 } else {
7343 if (isSuper) {
7344 fn = ObjCTypes.getMessageSendSuper2FixupFn();
7345 messageRefName += "objc_msgSendSuper2_fixup";
7346 } else {
7347 fn = ObjCTypes.getMessageSendFixupFn();
7348 messageRefName += "objc_msgSend_fixup";
7349 }
7350 }
7351 assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend")(static_cast <bool> (fn && "CGObjCNonFragileABIMac::EmitMessageSend"
) ? void (0) : __assert_fail ("fn && \"CGObjCNonFragileABIMac::EmitMessageSend\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7351, __extension__ __PRETTY_FUNCTION__))
;
7352 messageRefName += '_';
7353
7354 // Append the selector name, except use underscores anywhere we
7355 // would have used colons.
7356 appendSelectorForMessageRefTable(messageRefName, selector);
7357
7358 llvm::GlobalVariable *messageRef
7359 = CGM.getModule().getGlobalVariable(messageRefName);
7360 if (!messageRef) {
7361 // Build the message ref structure.
7362 ConstantInitBuilder builder(CGM);
7363 auto values = builder.beginStruct();
7364 values.add(cast<llvm::Constant>(fn.getCallee()));
7365 values.add(GetMethodVarName(selector));
7366 messageRef = values.finishAndCreateGlobal(messageRefName,
7367 CharUnits::fromQuantity(16),
7368 /*constant*/ false,
7369 llvm::GlobalValue::WeakAnyLinkage);
7370 messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
7371 messageRef->setSection(GetSectionName("__objc_msgrefs", "coalesced"));
7372 }
7373
7374 bool requiresnullCheck = false;
7375 if (CGM.getLangOpts().ObjCAutoRefCount && method)
7376 for (const auto *ParamDecl : method->parameters()) {
7377 if (ParamDecl->isDestroyedInCallee()) {
7378 if (!nullReturn.NullBB)
7379 nullReturn.init(CGF, arg0);
7380 requiresnullCheck = true;
7381 break;
7382 }
7383 }
7384
7385 Address mref =
7386 Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
7387 CGF.getPointerAlign());
7388
7389 // Update the message ref argument.
7390 args[1].setRValue(RValue::get(mref.getPointer()));
7391
7392 // Load the function to call from the message ref table.
7393 Address calleeAddr = CGF.Builder.CreateStructGEP(mref, 0);
7394 llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn");
7395
7396 calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
7397 CGCallee callee(CGCalleeInfo(), calleePtr);
7398
7399 RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
7400 return nullReturn.complete(CGF, returnSlot, result, resultType, formalArgs,
7401 requiresnullCheck ? method : nullptr);
7402}
7403
7404/// Generate code for a message send expression in the nonfragile abi.
7405CodeGen::RValue
7406CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
7407 ReturnValueSlot Return,
7408 QualType ResultType,
7409 Selector Sel,
7410 llvm::Value *Receiver,
7411 const CallArgList &CallArgs,
7412 const ObjCInterfaceDecl *Class,
7413 const ObjCMethodDecl *Method) {
7414 return isVTableDispatchedSelector(Sel)
7415 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7416 Receiver, CGF.getContext().getObjCIdType(),
7417 false, CallArgs, Method)
7418 : EmitMessageSend(CGF, Return, ResultType, Sel,
7419 Receiver, CGF.getContext().getObjCIdType(),
7420 false, CallArgs, Method, Class, ObjCTypes);
7421}
7422
7423llvm::Constant *
7424CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID,
7425 bool metaclass,
7426 ForDefinition_t isForDefinition) {
7427 auto prefix =
7428 (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix());
7429 return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(),
7430 isForDefinition,
7431 ID->isWeakImported(),
7432 !isForDefinition
7433 && CGM.getTriple().isOSBinFormatCOFF()
7434 && ID->hasAttr<DLLImportAttr>());
7435}
7436
7437llvm::Constant *
7438CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
7439 ForDefinition_t IsForDefinition,
7440 bool Weak, bool DLLImport) {
7441 llvm::GlobalValue::LinkageTypes L =
7442 Weak ? llvm::GlobalValue::ExternalWeakLinkage
7443 : llvm::GlobalValue::ExternalLinkage;
7444
7445 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
7446 if (!GV || GV->getType() != ObjCTypes.ClassnfABITy->getPointerTo()) {
7447 auto *NewGV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, L,
7448 nullptr, Name);
7449
7450 if (DLLImport)
7451 NewGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
7452
7453 if (GV) {
7454 GV->replaceAllUsesWith(
7455 llvm::ConstantExpr::getBitCast(NewGV, GV->getType()));
7456 GV->eraseFromParent();
7457 }
7458 GV = NewGV;
7459 CGM.getModule().getGlobalList().push_back(GV);
7460 }
7461
7462 assert(GV->getLinkage() == L)(static_cast <bool> (GV->getLinkage() == L) ? void (
0) : __assert_fail ("GV->getLinkage() == L", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7462, __extension__ __PRETTY_FUNCTION__))
;
7463 return GV;
7464}
7465
7466llvm::Constant *
7467CGObjCNonFragileABIMac::GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID) {
7468 llvm::Constant *ClassGV = GetClassGlobal(ID, /*metaclass*/ false,
7469 NotForDefinition);
7470
7471 if (!ID->hasAttr<ObjCClassStubAttr>())
7472 return ClassGV;
7473
7474 ClassGV = llvm::ConstantExpr::getPointerCast(ClassGV, ObjCTypes.Int8PtrTy);
7475
7476 // Stub classes are pointer-aligned. Classrefs pointing at stub classes
7477 // must set the least significant bit set to 1.
7478 auto *Idx = llvm::ConstantInt::get(CGM.Int32Ty, 1);
7479 return llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, ClassGV, Idx);
7480}
7481
7482llvm::Value *
7483CGObjCNonFragileABIMac::EmitLoadOfClassRef(CodeGenFunction &CGF,
7484 const ObjCInterfaceDecl *ID,
7485 llvm::GlobalVariable *Entry) {
7486 if (ID && ID->hasAttr<ObjCClassStubAttr>()) {
7487 // Classrefs pointing at Objective-C stub classes must be loaded by calling
7488 // a special runtime function.
7489 return CGF.EmitRuntimeCall(
7490 ObjCTypes.getLoadClassrefFn(), Entry, "load_classref_result");
7491 }
7492
7493 CharUnits Align = CGF.getPointerAlign();
7494 return CGF.Builder.CreateAlignedLoad(Entry->getValueType(), Entry, Align);
7495}
7496
7497llvm::Value *
7498CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
7499 IdentifierInfo *II,
7500 const ObjCInterfaceDecl *ID) {
7501 llvm::GlobalVariable *&Entry = ClassReferences[II];
7502
7503 if (!Entry) {
7504 llvm::Constant *ClassGV;
7505 if (ID) {
7506 ClassGV = GetClassGlobalForClassRef(ID);
7507 } else {
7508 ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(),
7509 NotForDefinition);
7510 assert(ClassGV->getType() == ObjCTypes.ClassnfABIPtrTy &&(static_cast <bool> (ClassGV->getType() == ObjCTypes
.ClassnfABIPtrTy && "classref was emitted with the wrong type?"
) ? void (0) : __assert_fail ("ClassGV->getType() == ObjCTypes.ClassnfABIPtrTy && \"classref was emitted with the wrong type?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7511, __extension__ __PRETTY_FUNCTION__))
7511 "classref was emitted with the wrong type?")(static_cast <bool> (ClassGV->getType() == ObjCTypes
.ClassnfABIPtrTy && "classref was emitted with the wrong type?"
) ? void (0) : __assert_fail ("ClassGV->getType() == ObjCTypes.ClassnfABIPtrTy && \"classref was emitted with the wrong type?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7511, __extension__ __PRETTY_FUNCTION__))
;
7512 }
7513
7514 std::string SectionName =
7515 GetSectionName("__objc_classrefs", "regular,no_dead_strip");
7516 Entry = new llvm::GlobalVariable(
7517 CGM.getModule(), ClassGV->getType(), false,
7518 getLinkageTypeForObjCMetadata(CGM, SectionName), ClassGV,
7519 "OBJC_CLASSLIST_REFERENCES_$_");
7520 Entry->setAlignment(CGF.getPointerAlign().getAsAlign());
7521 if (!ID || !ID->hasAttr<ObjCClassStubAttr>())
7522 Entry->setSection(SectionName);
7523
7524 CGM.addCompilerUsedGlobal(Entry);
7525 }
7526
7527 return EmitLoadOfClassRef(CGF, ID, Entry);
7528}
7529
7530llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
7531 const ObjCInterfaceDecl *ID) {
7532 // If the class has the objc_runtime_visible attribute, we need to
7533 // use the Objective-C runtime to get the class.
7534 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
7535 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
7536
7537 return EmitClassRefFromId(CGF, ID->getIdentifier(), ID);
7538}
7539
7540llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
7541 CodeGenFunction &CGF) {
7542 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
7543 return EmitClassRefFromId(CGF, II, nullptr);
7544}
7545
7546llvm::Value *
7547CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
7548 const ObjCInterfaceDecl *ID) {
7549 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
7550
7551 if (!Entry) {
7552 llvm::Constant *ClassGV = GetClassGlobalForClassRef(ID);
7553 std::string SectionName =
7554 GetSectionName("__objc_superrefs", "regular,no_dead_strip");
7555 Entry = new llvm::GlobalVariable(CGM.getModule(), ClassGV->getType(), false,
7556 llvm::GlobalValue::PrivateLinkage, ClassGV,
7557 "OBJC_CLASSLIST_SUP_REFS_$_");
7558 Entry->setAlignment(CGF.getPointerAlign().getAsAlign());
7559 Entry->setSection(SectionName);
7560 CGM.addCompilerUsedGlobal(Entry);
7561 }
7562
7563 return EmitLoadOfClassRef(CGF, ID, Entry);
7564}
7565
7566/// EmitMetaClassRef - Return a Value * of the address of _class_t
7567/// meta-data
7568///
7569llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
7570 const ObjCInterfaceDecl *ID,
7571 bool Weak) {
7572 CharUnits Align = CGF.getPointerAlign();
7573 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
7574 if (!Entry) {
7575 auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition);
7576 std::string SectionName =
7577 GetSectionName("__objc_superrefs", "regular,no_dead_strip");
7578 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7579 false, llvm::GlobalValue::PrivateLinkage,
7580 MetaClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
7581 Entry->setAlignment(Align.getAsAlign());
7582 Entry->setSection(SectionName);
7583 CGM.addCompilerUsedGlobal(Entry);
7584 }
7585
7586 return CGF.Builder.CreateAlignedLoad(ObjCTypes.ClassnfABIPtrTy, Entry, Align);
7587}
7588
7589/// GetClass - Return a reference to the class for the given interface
7590/// decl.
7591llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
7592 const ObjCInterfaceDecl *ID) {
7593 if (ID->isWeakImported()) {
7594 auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7595 (void)ClassGV;
7596 assert(!isa<llvm::GlobalVariable>(ClassGV) ||(static_cast <bool> (!isa<llvm::GlobalVariable>(ClassGV
) || cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage
()) ? void (0) : __assert_fail ("!isa<llvm::GlobalVariable>(ClassGV) || cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7597, __extension__ __PRETTY_FUNCTION__))
7597 cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage())(static_cast <bool> (!isa<llvm::GlobalVariable>(ClassGV
) || cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage
()) ? void (0) : __assert_fail ("!isa<llvm::GlobalVariable>(ClassGV) || cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7597, __extension__ __PRETTY_FUNCTION__))
;
7598 }
7599
7600 return EmitClassRef(CGF, ID);
7601}
7602
7603/// Generates a message send where the super is the receiver. This is
7604/// a message send to self with special delivery semantics indicating
7605/// which class's method should be called.
7606CodeGen::RValue
7607CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
7608 ReturnValueSlot Return,
7609 QualType ResultType,
7610 Selector Sel,
7611 const ObjCInterfaceDecl *Class,
7612 bool isCategoryImpl,
7613 llvm::Value *Receiver,
7614 bool IsClassMessage,
7615 const CodeGen::CallArgList &CallArgs,
7616 const ObjCMethodDecl *Method) {
7617 // ...
7618 // Create and init a super structure; this is a (receiver, class)
7619 // pair we will pass to objc_msgSendSuper.
7620 Address ObjCSuper =
7621 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
7622 "objc_super");
7623
7624 llvm::Value *ReceiverAsObject =
7625 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
7626 CGF.Builder.CreateStore(ReceiverAsObject,
7627 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
7628
7629 // If this is a class message the metaclass is passed as the target.
7630 llvm::Value *Target;
7631 if (IsClassMessage)
7632 Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported());
7633 else
7634 Target = EmitSuperClassRef(CGF, Class);
7635
7636 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
7637 // ObjCTypes types.
7638 llvm::Type *ClassTy =
7639 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
7640 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
7641 CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
7642
7643 return (isVTableDispatchedSelector(Sel))
7644 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7645 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7646 true, CallArgs, Method)
7647 : EmitMessageSend(CGF, Return, ResultType, Sel,
7648 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7649 true, CallArgs, Method, Class, ObjCTypes);
7650}
7651
7652llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
7653 Selector Sel) {
7654 Address Addr = EmitSelectorAddr(Sel);
7655
7656 llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr);
7657 LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7658 llvm::MDNode::get(VMContext, None));
7659 return LI;
7660}
7661
7662Address CGObjCNonFragileABIMac::EmitSelectorAddr(Selector Sel) {
7663 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
7664 CharUnits Align = CGM.getPointerAlign();
7665 if (!Entry) {
7666 llvm::Constant *Casted =
7667 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
7668 ObjCTypes.SelectorPtrTy);
7669 std::string SectionName =
7670 GetSectionName("__objc_selrefs", "literal_pointers,no_dead_strip");
7671 Entry = new llvm::GlobalVariable(
7672 CGM.getModule(), ObjCTypes.SelectorPtrTy, false,
7673 getLinkageTypeForObjCMetadata(CGM, SectionName), Casted,
7674 "OBJC_SELECTOR_REFERENCES_");
7675 Entry->setExternallyInitialized(true);
7676 Entry->setSection(SectionName);
7677 Entry->setAlignment(Align.getAsAlign());
7678 CGM.addCompilerUsedGlobal(Entry);
7679 }
7680
7681 return Address(Entry, Align);
7682}
7683
7684/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
7685/// objc_assign_ivar (id src, id *dst, ptrdiff_t)
7686///
7687void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
7688 llvm::Value *src,
7689 Address dst,
7690 llvm::Value *ivarOffset) {
7691 llvm::Type * SrcTy = src->getType();
7692 if (!isa<llvm::PointerType>(SrcTy)) {
7693 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7694 assert(Size <= 8 && "does not support size > 8")(static_cast <bool> (Size <= 8 && "does not support size > 8"
) ? void (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7694, __extension__ __PRETTY_FUNCTION__))
;
7695 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7696 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7697 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7698 }
7699 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7700 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7701 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
7702 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
7703}
7704
7705/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
7706/// objc_assign_strongCast (id src, id *dst)
7707///
7708void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
7709 CodeGen::CodeGenFunction &CGF,
7710 llvm::Value *src, Address dst) {
7711 llvm::Type * SrcTy = src->getType();
7712 if (!isa<llvm::PointerType>(SrcTy)) {
7713 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7714 assert(Size <= 8 && "does not support size > 8")(static_cast <bool> (Size <= 8 && "does not support size > 8"
) ? void (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7714, __extension__ __PRETTY_FUNCTION__))
;
7715 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7716 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7717 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7718 }
7719 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7720 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7721 llvm::Value *args[] = { src, dst.getPointer() };
7722 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
7723 args, "weakassign");
7724}
7725
7726void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
7727 CodeGen::CodeGenFunction &CGF,
7728 Address DestPtr,
7729 Address SrcPtr,
7730 llvm::Value *Size) {
7731 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
7732 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
7733 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), Size };
7734 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
7735}
7736
7737/// EmitObjCWeakRead - Code gen for loading value of a __weak
7738/// object: objc_read_weak (id *src)
7739///
7740llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
7741 CodeGen::CodeGenFunction &CGF,
7742 Address AddrWeakObj) {
7743 llvm::Type *DestTy = AddrWeakObj.getElementType();
7744 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
7745 llvm::Value *read_weak =
7746 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
7747 AddrWeakObj.getPointer(), "weakread");
7748 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
7749 return read_weak;
7750}
7751
7752/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
7753/// objc_assign_weak (id src, id *dst)
7754///
7755void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
7756 llvm::Value *src, Address dst) {
7757 llvm::Type * SrcTy = src->getType();
7758 if (!isa<llvm::PointerType>(SrcTy)) {
7759 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7760 assert(Size <= 8 && "does not support size > 8")(static_cast <bool> (Size <= 8 && "does not support size > 8"
) ? void (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7760, __extension__ __PRETTY_FUNCTION__))
;
7761 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7762 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7763 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7764 }
7765 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7766 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7767 llvm::Value *args[] = { src, dst.getPointer() };
7768 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
7769 args, "weakassign");
7770}
7771
7772/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
7773/// objc_assign_global (id src, id *dst)
7774///
7775void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
7776 llvm::Value *src, Address dst,
7777 bool threadlocal) {
7778 llvm::Type * SrcTy = src->getType();
7779 if (!isa<llvm::PointerType>(SrcTy)) {
7780 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7781 assert(Size <= 8 && "does not support size > 8")(static_cast <bool> (Size <= 8 && "does not support size > 8"
) ? void (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7781, __extension__ __PRETTY_FUNCTION__))
;
7782 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7783 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7784 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7785 }
7786 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7787 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7788 llvm::Value *args[] = { src, dst.getPointer() };
7789 if (!threadlocal)
7790 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
7791 args, "globalassign");
7792 else
7793 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
7794 args, "threadlocalassign");
7795}
7796
7797void
7798CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
7799 const ObjCAtSynchronizedStmt &S) {
7800 EmitAtSynchronizedStmt(CGF, S, ObjCTypes.getSyncEnterFn(),
7801 ObjCTypes.getSyncExitFn());
7802}
7803
7804llvm::Constant *
7805CGObjCNonFragileABIMac::GetEHType(QualType T) {
7806 // There's a particular fixed type info for 'id'.
7807 if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
7808 auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
7809 if (!IDEHType) {
7810 IDEHType =
7811 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7812 llvm::GlobalValue::ExternalLinkage, nullptr,
7813 "OBJC_EHTYPE_id");
7814 if (CGM.getTriple().isOSBinFormatCOFF())
7815 IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id"));
7816 }
7817 return IDEHType;
7818 }
7819
7820 // All other types should be Objective-C interface pointer types.
7821 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
7822 assert(PT && "Invalid @catch type.")(static_cast <bool> (PT && "Invalid @catch type."
) ? void (0) : __assert_fail ("PT && \"Invalid @catch type.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7822, __extension__ __PRETTY_FUNCTION__))
;
7823
7824 const ObjCInterfaceType *IT = PT->getInterfaceType();
7825 assert(IT && "Invalid @catch type.")(static_cast <bool> (IT && "Invalid @catch type."
) ? void (0) : __assert_fail ("IT && \"Invalid @catch type.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7825, __extension__ __PRETTY_FUNCTION__))
;
7826
7827 return GetInterfaceEHType(IT->getDecl(), NotForDefinition);
7828}
7829
7830void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
7831 const ObjCAtTryStmt &S) {
7832 EmitTryCatchStmt(CGF, S, ObjCTypes.getObjCBeginCatchFn(),
7833 ObjCTypes.getObjCEndCatchFn(),
7834 ObjCTypes.getExceptionRethrowFn());
7835}
7836
7837/// EmitThrowStmt - Generate code for a throw statement.
7838void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
7839 const ObjCAtThrowStmt &S,
7840 bool ClearInsertionPoint) {
7841 if (const Expr *ThrowExpr = S.getThrowExpr()) {
7842 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
7843 Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7844 llvm::CallBase *Call =
7845 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception);
7846 Call->setDoesNotReturn();
7847 } else {
7848 llvm::CallBase *Call =
7849 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn());
7850 Call->setDoesNotReturn();
7851 }
7852
7853 CGF.Builder.CreateUnreachable();
7854 if (ClearInsertionPoint)
7855 CGF.Builder.ClearInsertionPoint();
7856}
7857
7858llvm::Constant *
7859CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
7860 ForDefinition_t IsForDefinition) {
7861 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
7862 StringRef ClassName = ID->getObjCRuntimeNameAsString();
7863
7864 // If we don't need a definition, return the entry if found or check
7865 // if we use an external reference.
7866 if (!IsForDefinition) {
7867 if (Entry)
7868 return Entry;
7869
7870 // If this type (or a super class) has the __objc_exception__
7871 // attribute, emit an external reference.
7872 if (hasObjCExceptionAttribute(CGM.getContext(), ID)) {
7873 std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str();
7874 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
7875 false, llvm::GlobalValue::ExternalLinkage,
7876 nullptr, EHTypeName);
7877 CGM.setGVProperties(Entry, ID);
7878 return Entry;
7879 }
7880 }
7881
7882 // Otherwise we need to either make a new entry or fill in the initializer.
7883 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition")(static_cast <bool> ((!Entry || !Entry->hasInitializer
()) && "Duplicate EHType definition") ? void (0) : __assert_fail
("(!Entry || !Entry->hasInitializer()) && \"Duplicate EHType definition\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7883, __extension__ __PRETTY_FUNCTION__))
;
7884
7885 std::string VTableName = "objc_ehtype_vtable";
7886 auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName);
7887 if (!VTableGV) {
7888 VTableGV =
7889 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false,
7890 llvm::GlobalValue::ExternalLinkage, nullptr,
7891 VTableName);
7892 if (CGM.getTriple().isOSBinFormatCOFF())
7893 VTableGV->setDLLStorageClass(getStorage(CGM, VTableName));
7894 }
7895
7896 llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
7897 ConstantInitBuilder builder(CGM);
7898 auto values = builder.beginStruct(ObjCTypes.EHTypeTy);
7899 values.add(
7900 llvm::ConstantExpr::getInBoundsGetElementPtr(VTableGV->getValueType(),
7901 VTableGV, VTableIdx));
7902 values.add(GetClassName(ClassName));
7903 values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition));
7904
7905 llvm::GlobalValue::LinkageTypes L = IsForDefinition
7906 ? llvm::GlobalValue::ExternalLinkage
7907 : llvm::GlobalValue::WeakAnyLinkage;
7908 if (Entry) {
7909 values.finishAndSetAsInitializer(Entry);
7910 Entry->setAlignment(CGM.getPointerAlign().getAsAlign());
7911 } else {
7912 Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName,
7913 CGM.getPointerAlign(),
7914 /*constant*/ false,
7915 L);
7916 if (hasObjCExceptionAttribute(CGM.getContext(), ID))
7917 CGM.setGVProperties(Entry, ID);
7918 }
7919 assert(Entry->getLinkage() == L)(static_cast <bool> (Entry->getLinkage() == L) ? void
(0) : __assert_fail ("Entry->getLinkage() == L", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7919, __extension__ __PRETTY_FUNCTION__))
;
7920
7921 if (!CGM.getTriple().isOSBinFormatCOFF())
7922 if (ID->getVisibility() == HiddenVisibility)
7923 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7924
7925 if (IsForDefinition)
7926 if (CGM.getTriple().isOSBinFormatMachO())
7927 Entry->setSection("__DATA,__objc_const");
7928
7929 return Entry;
7930}
7931
7932/* *** */
7933
7934CodeGen::CGObjCRuntime *
7935CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
7936 switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
7937 case ObjCRuntime::FragileMacOSX:
7938 return new CGObjCMac(CGM);
7939
7940 case ObjCRuntime::MacOSX:
7941 case ObjCRuntime::iOS:
7942 case ObjCRuntime::WatchOS:
7943 return new CGObjCNonFragileABIMac(CGM);
7944
7945 case ObjCRuntime::GNUstep:
7946 case ObjCRuntime::GCC:
7947 case ObjCRuntime::ObjFW:
7948 llvm_unreachable("these runtimes are not Mac runtimes")::llvm::llvm_unreachable_internal("these runtimes are not Mac runtimes"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7948)
;
7949 }
7950 llvm_unreachable("bad runtime")::llvm::llvm_unreachable_internal("bad runtime", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/lib/CodeGen/CGObjCMac.cpp"
, 7950)
;
7951}

/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h

1//===- Type.h - C Language Family Type Representation -----------*- 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/// \file
10/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H
19
20#include "clang/AST/DependenceFlags.h"
21#include "clang/AST/NestedNameSpecifier.h"
22#include "clang/AST/TemplateName.h"
23#include "clang/Basic/AddressSpaces.h"
24#include "clang/Basic/AttrKinds.h"
25#include "clang/Basic/Diagnostic.h"
26#include "clang/Basic/ExceptionSpecificationType.h"
27#include "clang/Basic/LLVM.h"
28#include "clang/Basic/Linkage.h"
29#include "clang/Basic/PartialDiagnostic.h"
30#include "clang/Basic/SourceLocation.h"
31#include "clang/Basic/Specifiers.h"
32#include "clang/Basic/Visibility.h"
33#include "llvm/ADT/APInt.h"
34#include "llvm/ADT/APSInt.h"
35#include "llvm/ADT/ArrayRef.h"
36#include "llvm/ADT/FoldingSet.h"
37#include "llvm/ADT/None.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/Twine.h"
43#include "llvm/ADT/iterator_range.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/Compiler.h"
46#include "llvm/Support/ErrorHandling.h"
47#include "llvm/Support/PointerLikeTypeTraits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include "llvm/Support/type_traits.h"
50#include <cassert>
51#include <cstddef>
52#include <cstdint>
53#include <cstring>
54#include <string>
55#include <type_traits>
56#include <utility>
57
58namespace clang {
59
60class ExtQuals;
61class QualType;
62class ConceptDecl;
63class TagDecl;
64class TemplateParameterList;
65class Type;
66
67enum {
68 TypeAlignmentInBits = 4,
69 TypeAlignment = 1 << TypeAlignmentInBits
70};
71
72namespace serialization {
73 template <class T> class AbstractTypeReader;
74 template <class T> class AbstractTypeWriter;
75}
76
77} // namespace clang
78
79namespace llvm {
80
81 template <typename T>
82 struct PointerLikeTypeTraits;
83 template<>
84 struct PointerLikeTypeTraits< ::clang::Type*> {
85 static inline void *getAsVoidPointer(::clang::Type *P) { return P; }
86
87 static inline ::clang::Type *getFromVoidPointer(void *P) {
88 return static_cast< ::clang::Type*>(P);
89 }
90
91 static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
92 };
93
94 template<>
95 struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
96 static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }
97
98 static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
99 return static_cast< ::clang::ExtQuals*>(P);
100 }
101
102 static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
103 };
104
105} // namespace llvm
106
107namespace clang {
108
109class ASTContext;
110template <typename> class CanQual;
111class CXXRecordDecl;
112class DeclContext;
113class EnumDecl;
114class Expr;
115class ExtQualsTypeCommonBase;
116class FunctionDecl;
117class IdentifierInfo;
118class NamedDecl;
119class ObjCInterfaceDecl;
120class ObjCProtocolDecl;
121class ObjCTypeParamDecl;
122struct PrintingPolicy;
123class RecordDecl;
124class Stmt;
125class TagDecl;
126class TemplateArgument;
127class TemplateArgumentListInfo;
128class TemplateArgumentLoc;
129class TemplateTypeParmDecl;
130class TypedefNameDecl;
131class UnresolvedUsingTypenameDecl;
132
133using CanQualType = CanQual<Type>;
134
135// Provide forward declarations for all of the *Type classes.
136#define TYPE(Class, Base) class Class##Type;
137#include "clang/AST/TypeNodes.inc"
138
139/// The collection of all-type qualifiers we support.
140/// Clang supports five independent qualifiers:
141/// * C99: const, volatile, and restrict
142/// * MS: __unaligned
143/// * Embedded C (TR18037): address spaces
144/// * Objective C: the GC attributes (none, weak, or strong)
145class Qualifiers {
146public:
147 enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
148 Const = 0x1,
149 Restrict = 0x2,
150 Volatile = 0x4,
151 CVRMask = Const | Volatile | Restrict
152 };
153
154 enum GC {
155 GCNone = 0,
156 Weak,
157 Strong
158 };
159
160 enum ObjCLifetime {
161 /// There is no lifetime qualification on this type.
162 OCL_None,
163
164 /// This object can be modified without requiring retains or
165 /// releases.
166 OCL_ExplicitNone,
167
168 /// Assigning into this object requires the old value to be
169 /// released and the new value to be retained. The timing of the
170 /// release of the old value is inexact: it may be moved to
171 /// immediately after the last known point where the value is
172 /// live.
173 OCL_Strong,
174
175 /// Reading or writing from this object requires a barrier call.
176 OCL_Weak,
177
178 /// Assigning into this object requires a lifetime extension.
179 OCL_Autoreleasing
180 };
181
182 enum {
183 /// The maximum supported address space number.
184 /// 23 bits should be enough for anyone.
185 MaxAddressSpace = 0x7fffffu,
186
187 /// The width of the "fast" qualifier mask.
188 FastWidth = 3,
189
190 /// The fast qualifier mask.
191 FastMask = (1 << FastWidth) - 1
192 };
193
194 /// Returns the common set of qualifiers while removing them from
195 /// the given sets.
196 static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
197 // If both are only CVR-qualified, bit operations are sufficient.
198 if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
199 Qualifiers Q;
200 Q.Mask = L.Mask & R.Mask;
201 L.Mask &= ~Q.Mask;
202 R.Mask &= ~Q.Mask;
203 return Q;
204 }
205
206 Qualifiers Q;
207 unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
208 Q.addCVRQualifiers(CommonCRV);
209 L.removeCVRQualifiers(CommonCRV);
210 R.removeCVRQualifiers(CommonCRV);
211
212 if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
213 Q.setObjCGCAttr(L.getObjCGCAttr());
214 L.removeObjCGCAttr();
215 R.removeObjCGCAttr();
216 }
217
218 if (L.getObjCLifetime() == R.getObjCLifetime()) {
219 Q.setObjCLifetime(L.getObjCLifetime());
220 L.removeObjCLifetime();
221 R.removeObjCLifetime();
222 }
223
224 if (L.getAddressSpace() == R.getAddressSpace()) {
225 Q.setAddressSpace(L.getAddressSpace());
226 L.removeAddressSpace();
227 R.removeAddressSpace();
228 }
229 return Q;
230 }
231
232 static Qualifiers fromFastMask(unsigned Mask) {
233 Qualifiers Qs;
234 Qs.addFastQualifiers(Mask);
235 return Qs;
236 }
237
238 static Qualifiers fromCVRMask(unsigned CVR) {
239 Qualifiers Qs;
240 Qs.addCVRQualifiers(CVR);
241 return Qs;
242 }
243
244 static Qualifiers fromCVRUMask(unsigned CVRU) {
245 Qualifiers Qs;
246 Qs.addCVRUQualifiers(CVRU);
247 return Qs;
248 }
249
250 // Deserialize qualifiers from an opaque representation.
251 static Qualifiers fromOpaqueValue(unsigned opaque) {
252 Qualifiers Qs;
253 Qs.Mask = opaque;
254 return Qs;
255 }
256
257 // Serialize these qualifiers into an opaque representation.
258 unsigned getAsOpaqueValue() const {
259 return Mask;
260 }
261
262 bool hasConst() const { return Mask & Const; }
263 bool hasOnlyConst() const { return Mask == Const; }
264 void removeConst() { Mask &= ~Const; }
265 void addConst() { Mask |= Const; }
266
267 bool hasVolatile() const { return Mask & Volatile; }
268 bool hasOnlyVolatile() const { return Mask == Volatile; }
269 void removeVolatile() { Mask &= ~Volatile; }
270 void addVolatile() { Mask |= Volatile; }
271
272 bool hasRestrict() const { return Mask & Restrict; }
273 bool hasOnlyRestrict() const { return Mask == Restrict; }
274 void removeRestrict() { Mask &= ~Restrict; }
275 void addRestrict() { Mask |= Restrict; }
276
277 bool hasCVRQualifiers() const { return getCVRQualifiers(); }
278 unsigned getCVRQualifiers() const { return Mask & CVRMask; }
279 unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }
280
281 void setCVRQualifiers(unsigned mask) {
282 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast <bool> (!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? void (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 282, __extension__ __PRETTY_FUNCTION__))
;
283 Mask = (Mask & ~CVRMask) | mask;
284 }
285 void removeCVRQualifiers(unsigned mask) {
286 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast <bool> (!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? void (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 286, __extension__ __PRETTY_FUNCTION__))
;
287 Mask &= ~mask;
288 }
289 void removeCVRQualifiers() {
290 removeCVRQualifiers(CVRMask);
291 }
292 void addCVRQualifiers(unsigned mask) {
293 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast <bool> (!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? void (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 293, __extension__ __PRETTY_FUNCTION__))
;
294 Mask |= mask;
295 }
296 void addCVRUQualifiers(unsigned mask) {
297 assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")(static_cast <bool> (!(mask & ~CVRMask & ~UMask
) && "bitmask contains non-CVRU bits") ? void (0) : __assert_fail
("!(mask & ~CVRMask & ~UMask) && \"bitmask contains non-CVRU bits\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 297, __extension__ __PRETTY_FUNCTION__))
;
298 Mask |= mask;
299 }
300
301 bool hasUnaligned() const { return Mask & UMask; }
302 void setUnaligned(bool flag) {
303 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
304 }
305 void removeUnaligned() { Mask &= ~UMask; }
306 void addUnaligned() { Mask |= UMask; }
307
308 bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
309 GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
310 void setObjCGCAttr(GC type) {
311 Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
312 }
313 void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
314 void addObjCGCAttr(GC type) {
315 assert(type)(static_cast <bool> (type) ? void (0) : __assert_fail (
"type", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 315, __extension__ __PRETTY_FUNCTION__))
;
316 setObjCGCAttr(type);
317 }
318 Qualifiers withoutObjCGCAttr() const {
319 Qualifiers qs = *this;
320 qs.removeObjCGCAttr();
321 return qs;
322 }
323 Qualifiers withoutObjCLifetime() const {
324 Qualifiers qs = *this;
325 qs.removeObjCLifetime();
326 return qs;
327 }
328 Qualifiers withoutAddressSpace() const {
329 Qualifiers qs = *this;
330 qs.removeAddressSpace();
331 return qs;
332 }
333
334 bool hasObjCLifetime() const { return Mask & LifetimeMask; }
335 ObjCLifetime getObjCLifetime() const {
336 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
337 }
338 void setObjCLifetime(ObjCLifetime type) {
339 Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
340 }
341 void removeObjCLifetime() { setObjCLifetime(OCL_None); }
342 void addObjCLifetime(ObjCLifetime type) {
343 assert(type)(static_cast <bool> (type) ? void (0) : __assert_fail (
"type", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 343, __extension__ __PRETTY_FUNCTION__))
;
344 assert(!hasObjCLifetime())(static_cast <bool> (!hasObjCLifetime()) ? void (0) : __assert_fail
("!hasObjCLifetime()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 344, __extension__ __PRETTY_FUNCTION__))
;
345 Mask |= (type << LifetimeShift);
346 }
347
348 /// True if the lifetime is neither None or ExplicitNone.
349 bool hasNonTrivialObjCLifetime() const {
350 ObjCLifetime lifetime = getObjCLifetime();
351 return (lifetime > OCL_ExplicitNone);
352 }
353
354 /// True if the lifetime is either strong or weak.
355 bool hasStrongOrWeakObjCLifetime() const {
356 ObjCLifetime lifetime = getObjCLifetime();
357 return (lifetime == OCL_Strong || lifetime == OCL_Weak);
358 }
359
360 bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
361 LangAS getAddressSpace() const {
362 return static_cast<LangAS>(Mask >> AddressSpaceShift);
363 }
364 bool hasTargetSpecificAddressSpace() const {
365 return isTargetAddressSpace(getAddressSpace());
366 }
367 /// Get the address space attribute value to be printed by diagnostics.
368 unsigned getAddressSpaceAttributePrintValue() const {
369 auto Addr = getAddressSpace();
370 // This function is not supposed to be used with language specific
371 // address spaces. If that happens, the diagnostic message should consider
372 // printing the QualType instead of the address space value.
373 assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())(static_cast <bool> (Addr == LangAS::Default || hasTargetSpecificAddressSpace
()) ? void (0) : __assert_fail ("Addr == LangAS::Default || hasTargetSpecificAddressSpace()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 373, __extension__ __PRETTY_FUNCTION__))
;
374 if (Addr != LangAS::Default)
375 return toTargetAddressSpace(Addr);
376 // TODO: The diagnostic messages where Addr may be 0 should be fixed
377 // since it cannot differentiate the situation where 0 denotes the default
378 // address space or user specified __attribute__((address_space(0))).
379 return 0;
380 }
381 void setAddressSpace(LangAS space) {
382 assert((unsigned)space <= MaxAddressSpace)(static_cast <bool> ((unsigned)space <= MaxAddressSpace
) ? void (0) : __assert_fail ("(unsigned)space <= MaxAddressSpace"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 382, __extension__ __PRETTY_FUNCTION__))
;
383 Mask = (Mask & ~AddressSpaceMask)
384 | (((uint32_t) space) << AddressSpaceShift);
385 }
386 void removeAddressSpace() { setAddressSpace(LangAS::Default); }
387 void addAddressSpace(LangAS space) {
388 assert(space != LangAS::Default)(static_cast <bool> (space != LangAS::Default) ? void (
0) : __assert_fail ("space != LangAS::Default", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 388, __extension__ __PRETTY_FUNCTION__))
;
389 setAddressSpace(space);
390 }
391
392 // Fast qualifiers are those that can be allocated directly
393 // on a QualType object.
394 bool hasFastQualifiers() const { return getFastQualifiers(); }
395 unsigned getFastQualifiers() const { return Mask & FastMask; }
396 void setFastQualifiers(unsigned mask) {
397 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast <bool> (!(mask & ~FastMask) &&
"bitmask contains non-fast qualifier bits") ? void (0) : __assert_fail
("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 397, __extension__ __PRETTY_FUNCTION__))
;
398 Mask = (Mask & ~FastMask) | mask;
399 }
400 void removeFastQualifiers(unsigned mask) {
401 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast <bool> (!(mask & ~FastMask) &&
"bitmask contains non-fast qualifier bits") ? void (0) : __assert_fail
("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 401, __extension__ __PRETTY_FUNCTION__))
;
402 Mask &= ~mask;
403 }
404 void removeFastQualifiers() {
405 removeFastQualifiers(FastMask);
406 }
407 void addFastQualifiers(unsigned mask) {
408 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast <bool> (!(mask & ~FastMask) &&
"bitmask contains non-fast qualifier bits") ? void (0) : __assert_fail
("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 408, __extension__ __PRETTY_FUNCTION__))
;
409 Mask |= mask;
410 }
411
412 /// Return true if the set contains any qualifiers which require an ExtQuals
413 /// node to be allocated.
414 bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
415 Qualifiers getNonFastQualifiers() const {
416 Qualifiers Quals = *this;
417 Quals.setFastQualifiers(0);
418 return Quals;
419 }
420
421 /// Return true if the set contains any qualifiers.
422 bool hasQualifiers() const { return Mask; }
423 bool empty() const { return !Mask; }
424
425 /// Add the qualifiers from the given set to this set.
426 void addQualifiers(Qualifiers Q) {
427 // If the other set doesn't have any non-boolean qualifiers, just
428 // bit-or it in.
429 if (!(Q.Mask & ~CVRMask))
430 Mask |= Q.Mask;
431 else {
432 Mask |= (Q.Mask & CVRMask);
433 if (Q.hasAddressSpace())
434 addAddressSpace(Q.getAddressSpace());
435 if (Q.hasObjCGCAttr())
436 addObjCGCAttr(Q.getObjCGCAttr());
437 if (Q.hasObjCLifetime())
438 addObjCLifetime(Q.getObjCLifetime());
439 }
440 }
441
442 /// Remove the qualifiers from the given set from this set.
443 void removeQualifiers(Qualifiers Q) {
444 // If the other set doesn't have any non-boolean qualifiers, just
445 // bit-and the inverse in.
446 if (!(Q.Mask & ~CVRMask))
447 Mask &= ~Q.Mask;
448 else {
449 Mask &= ~(Q.Mask & CVRMask);
450 if (getObjCGCAttr() == Q.getObjCGCAttr())
451 removeObjCGCAttr();
452 if (getObjCLifetime() == Q.getObjCLifetime())
453 removeObjCLifetime();
454 if (getAddressSpace() == Q.getAddressSpace())
455 removeAddressSpace();
456 }
457 }
458
459 /// Add the qualifiers from the given set to this set, given that
460 /// they don't conflict.
461 void addConsistentQualifiers(Qualifiers qs) {
462 assert(getAddressSpace() == qs.getAddressSpace() ||(static_cast <bool> (getAddressSpace() == qs.getAddressSpace
() || !hasAddressSpace() || !qs.hasAddressSpace()) ? void (0)
: __assert_fail ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 463, __extension__ __PRETTY_FUNCTION__))
463 !hasAddressSpace() || !qs.hasAddressSpace())(static_cast <bool> (getAddressSpace() == qs.getAddressSpace
() || !hasAddressSpace() || !qs.hasAddressSpace()) ? void (0)
: __assert_fail ("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 463, __extension__ __PRETTY_FUNCTION__))
;
464 assert(getObjCGCAttr() == qs.getObjCGCAttr() ||(static_cast <bool> (getObjCGCAttr() == qs.getObjCGCAttr
() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()) ? void (0) : __assert_fail
("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 465, __extension__ __PRETTY_FUNCTION__))
465 !hasObjCGCAttr() || !qs.hasObjCGCAttr())(static_cast <bool> (getObjCGCAttr() == qs.getObjCGCAttr
() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()) ? void (0) : __assert_fail
("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 465, __extension__ __PRETTY_FUNCTION__))
;
466 assert(getObjCLifetime() == qs.getObjCLifetime() ||(static_cast <bool> (getObjCLifetime() == qs.getObjCLifetime
() || !hasObjCLifetime() || !qs.hasObjCLifetime()) ? void (0)
: __assert_fail ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 467, __extension__ __PRETTY_FUNCTION__))
467 !hasObjCLifetime() || !qs.hasObjCLifetime())(static_cast <bool> (getObjCLifetime() == qs.getObjCLifetime
() || !hasObjCLifetime() || !qs.hasObjCLifetime()) ? void (0)
: __assert_fail ("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 467, __extension__ __PRETTY_FUNCTION__))
;
468 Mask |= qs.Mask;
469 }
470
471 /// Returns true if address space A is equal to or a superset of B.
472 /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
473 /// overlapping address spaces.
474 /// CL1.1 or CL1.2:
475 /// every address space is a superset of itself.
476 /// CL2.0 adds:
477 /// __generic is a superset of any address space except for __constant.
478 static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
479 // Address spaces must match exactly.
480 return A == B ||
481 // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
482 // for __constant can be used as __generic.
483 (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
484 // We also define global_device and global_host address spaces,
485 // to distinguish global pointers allocated on host from pointers
486 // allocated on device, which are a subset of __global.
487 (A == LangAS::opencl_global && (B == LangAS::opencl_global_device ||
488 B == LangAS::opencl_global_host)) ||
489 (A == LangAS::sycl_global && (B == LangAS::sycl_global_device ||
490 B == LangAS::sycl_global_host)) ||
491 // Consider pointer size address spaces to be equivalent to default.
492 ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
493 (isPtrSizeAddressSpace(B) || B == LangAS::Default)) ||
494 // Default is a superset of SYCL address spaces.
495 (A == LangAS::Default &&
496 (B == LangAS::sycl_private || B == LangAS::sycl_local ||
497 B == LangAS::sycl_global || B == LangAS::sycl_global_device ||
498 B == LangAS::sycl_global_host)) ||
499 // In HIP device compilation, any cuda address space is allowed
500 // to implicitly cast into the default address space.
501 (A == LangAS::Default &&
502 (B == LangAS::cuda_constant || B == LangAS::cuda_device ||
503 B == LangAS::cuda_shared));
504 }
505
506 /// Returns true if the address space in these qualifiers is equal to or
507 /// a superset of the address space in the argument qualifiers.
508 bool isAddressSpaceSupersetOf(Qualifiers other) const {
509 return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
510 }
511
512 /// Determines if these qualifiers compatibly include another set.
513 /// Generally this answers the question of whether an object with the other
514 /// qualifiers can be safely used as an object with these qualifiers.
515 bool compatiblyIncludes(Qualifiers other) const {
516 return isAddressSpaceSupersetOf(other) &&
517 // ObjC GC qualifiers can match, be added, or be removed, but can't
518 // be changed.
519 (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
520 !other.hasObjCGCAttr()) &&
521 // ObjC lifetime qualifiers must match exactly.
522 getObjCLifetime() == other.getObjCLifetime() &&
523 // CVR qualifiers may subset.
524 (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
525 // U qualifier may superset.
526 (!other.hasUnaligned() || hasUnaligned());
527 }
528
529 /// Determines if these qualifiers compatibly include another set of
530 /// qualifiers from the narrow perspective of Objective-C ARC lifetime.
531 ///
532 /// One set of Objective-C lifetime qualifiers compatibly includes the other
533 /// if the lifetime qualifiers match, or if both are non-__weak and the
534 /// including set also contains the 'const' qualifier, or both are non-__weak
535 /// and one is None (which can only happen in non-ARC modes).
536 bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
537 if (getObjCLifetime() == other.getObjCLifetime())
538 return true;
539
540 if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
541 return false;
542
543 if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
544 return true;
545
546 return hasConst();
547 }
548
549 /// Determine whether this set of qualifiers is a strict superset of
550 /// another set of qualifiers, not considering qualifier compatibility.
551 bool isStrictSupersetOf(Qualifiers Other) const;
552
553 bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
554 bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }
555
556 explicit operator bool() const { return hasQualifiers(); }
557
558 Qualifiers &operator+=(Qualifiers R) {
559 addQualifiers(R);
560 return *this;
561 }
562
563 // Union two qualifier sets. If an enumerated qualifier appears
564 // in both sets, use the one from the right.
565 friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
566 L += R;
567 return L;
568 }
569
570 Qualifiers &operator-=(Qualifiers R) {
571 removeQualifiers(R);
572 return *this;
573 }
574
575 /// Compute the difference between two qualifier sets.
576 friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
577 L -= R;
578 return L;
579 }
580
581 std::string getAsString() const;
582 std::string getAsString(const PrintingPolicy &Policy) const;
583
584 static std::string getAddrSpaceAsString(LangAS AS);
585
586 bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
587 void print(raw_ostream &OS, const PrintingPolicy &Policy,
588 bool appendSpaceIfNonEmpty = false) const;
589
590 void Profile(llvm::FoldingSetNodeID &ID) const {
591 ID.AddInteger(Mask);
592 }
593
594private:
595 // bits: |0 1 2|3|4 .. 5|6 .. 8|9 ... 31|
596 // |C R V|U|GCAttr|Lifetime|AddressSpace|
597 uint32_t Mask = 0;
598
599 static const uint32_t UMask = 0x8;
600 static const uint32_t UShift = 3;
601 static const uint32_t GCAttrMask = 0x30;
602 static const uint32_t GCAttrShift = 4;
603 static const uint32_t LifetimeMask = 0x1C0;
604 static const uint32_t LifetimeShift = 6;
605 static const uint32_t AddressSpaceMask =
606 ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
607 static const uint32_t AddressSpaceShift = 9;
608};
609
610/// A std::pair-like structure for storing a qualified type split
611/// into its local qualifiers and its locally-unqualified type.
612struct SplitQualType {
613 /// The locally-unqualified type.
614 const Type *Ty = nullptr;
615
616 /// The local qualifiers.
617 Qualifiers Quals;
618
619 SplitQualType() = default;
620 SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}
621
622 SplitQualType getSingleStepDesugaredType() const; // end of this file
623
624 // Make std::tie work.
625 std::pair<const Type *,Qualifiers> asPair() const {
626 return std::pair<const Type *, Qualifiers>(Ty, Quals);
627 }
628
629 friend bool operator==(SplitQualType a, SplitQualType b) {
630 return a.Ty == b.Ty && a.Quals == b.Quals;
631 }
632 friend bool operator!=(SplitQualType a, SplitQualType b) {
633 return a.Ty != b.Ty || a.Quals != b.Quals;
634 }
635};
636
637/// The kind of type we are substituting Objective-C type arguments into.
638///
639/// The kind of substitution affects the replacement of type parameters when
640/// no concrete type information is provided, e.g., when dealing with an
641/// unspecialized type.
642enum class ObjCSubstitutionContext {
643 /// An ordinary type.
644 Ordinary,
645
646 /// The result type of a method or function.
647 Result,
648
649 /// The parameter type of a method or function.
650 Parameter,
651
652 /// The type of a property.
653 Property,
654
655 /// The superclass of a type.
656 Superclass,
657};
658
659/// A (possibly-)qualified type.
660///
661/// For efficiency, we don't store CV-qualified types as nodes on their
662/// own: instead each reference to a type stores the qualifiers. This
663/// greatly reduces the number of nodes we need to allocate for types (for
664/// example we only need one for 'int', 'const int', 'volatile int',
665/// 'const volatile int', etc).
666///
667/// As an added efficiency bonus, instead of making this a pair, we
668/// just store the two bits we care about in the low bits of the
669/// pointer. To handle the packing/unpacking, we make QualType be a
670/// simple wrapper class that acts like a smart pointer. A third bit
671/// indicates whether there are extended qualifiers present, in which
672/// case the pointer points to a special structure.
673class QualType {
674 friend class QualifierCollector;
675
676 // Thankfully, these are efficiently composable.
677 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
678 Qualifiers::FastWidth> Value;
679
680 const ExtQuals *getExtQualsUnsafe() const {
681 return Value.getPointer().get<const ExtQuals*>();
682 }
683
684 const Type *getTypePtrUnsafe() const {
685 return Value.getPointer().get<const Type*>();
686 }
687
688 const ExtQualsTypeCommonBase *getCommonPtr() const {
689 assert(!isNull() && "Cannot retrieve a NULL type pointer")(static_cast <bool> (!isNull() && "Cannot retrieve a NULL type pointer"
) ? void (0) : __assert_fail ("!isNull() && \"Cannot retrieve a NULL type pointer\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 689, __extension__ __PRETTY_FUNCTION__))
;
690 auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
691 CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
692 return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
693 }
694
695public:
696 QualType() = default;
697 QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
698 QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
699
700 unsigned getLocalFastQualifiers() const { return Value.getInt(); }
701 void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }
702
703 /// Retrieves a pointer to the underlying (unqualified) type.
704 ///
705 /// This function requires that the type not be NULL. If the type might be
706 /// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
707 const Type *getTypePtr() const;
708
709 const Type *getTypePtrOrNull() const;
710
711 /// Retrieves a pointer to the name of the base type.
712 const IdentifierInfo *getBaseTypeIdentifier() const;
713
714 /// Divides a QualType into its unqualified type and a set of local
715 /// qualifiers.
716 SplitQualType split() const;
717
718 void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
719
720 static QualType getFromOpaquePtr(const void *Ptr) {
721 QualType T;
722 T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
723 return T;
724 }
725
726 const Type &operator*() const {
727 return *getTypePtr();
728 }
729
730 const Type *operator->() const {
731 return getTypePtr();
732 }
733
734 bool isCanonical() const;
735 bool isCanonicalAsParam() const;
736
737 /// Return true if this QualType doesn't point to a type yet.
738 bool isNull() const {
739 return Value.getPointer().isNull();
740 }
741
742 /// Determine whether this particular QualType instance has the
743 /// "const" qualifier set, without looking through typedefs that may have
744 /// added "const" at a different level.
745 bool isLocalConstQualified() const {
746 return (getLocalFastQualifiers() & Qualifiers::Const);
747 }
748
749 /// Determine whether this type is const-qualified.
750 bool isConstQualified() const;
751
752 /// Determine whether this particular QualType instance has the
753 /// "restrict" qualifier set, without looking through typedefs that may have
754 /// added "restrict" at a different level.
755 bool isLocalRestrictQualified() const {
756 return (getLocalFastQualifiers() & Qualifiers::Restrict);
757 }
758
759 /// Determine whether this type is restrict-qualified.
760 bool isRestrictQualified() const;
761
762 /// Determine whether this particular QualType instance has the
763 /// "volatile" qualifier set, without looking through typedefs that may have
764 /// added "volatile" at a different level.
765 bool isLocalVolatileQualified() const {
766 return (getLocalFastQualifiers() & Qualifiers::Volatile);
767 }
768
769 /// Determine whether this type is volatile-qualified.
770 bool isVolatileQualified() const;
771
772 /// Determine whether this particular QualType instance has any
773 /// qualifiers, without looking through any typedefs that might add
774 /// qualifiers at a different level.
775 bool hasLocalQualifiers() const {
776 return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
777 }
778
779 /// Determine whether this type has any qualifiers.
780 bool hasQualifiers() const;
781
782 /// Determine whether this particular QualType instance has any
783 /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
784 /// instance.
785 bool hasLocalNonFastQualifiers() const {
786 return Value.getPointer().is<const ExtQuals*>();
787 }
788
789 /// Retrieve the set of qualifiers local to this particular QualType
790 /// instance, not including any qualifiers acquired through typedefs or
791 /// other sugar.
792 Qualifiers getLocalQualifiers() const;
793
794 /// Retrieve the set of qualifiers applied to this type.
795 Qualifiers getQualifiers() const;
796
797 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
798 /// local to this particular QualType instance, not including any qualifiers
799 /// acquired through typedefs or other sugar.
800 unsigned getLocalCVRQualifiers() const {
801 return getLocalFastQualifiers();
802 }
803
804 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
805 /// applied to this type.
806 unsigned getCVRQualifiers() const;
807
808 bool isConstant(const ASTContext& Ctx) const {
809 return QualType::isConstant(*this, Ctx);
810 }
811
812 /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
813 bool isPODType(const ASTContext &Context) const;
814
815 /// Return true if this is a POD type according to the rules of the C++98
816 /// standard, regardless of the current compilation's language.
817 bool isCXX98PODType(const ASTContext &Context) const;
818
819 /// Return true if this is a POD type according to the more relaxed rules
820 /// of the C++11 standard, regardless of the current compilation's language.
821 /// (C++0x [basic.types]p9). Note that, unlike
822 /// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
823 bool isCXX11PODType(const ASTContext &Context) const;
824
825 /// Return true if this is a trivial type per (C++0x [basic.types]p9)
826 bool isTrivialType(const ASTContext &Context) const;
827
828 /// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
829 bool isTriviallyCopyableType(const ASTContext &Context) const;
830
831
832 /// Returns true if it is a class and it might be dynamic.
833 bool mayBeDynamicClass() const;
834
835 /// Returns true if it is not a class or if the class might not be dynamic.
836 bool mayBeNotDynamicClass() const;
837
838 // Don't promise in the API that anything besides 'const' can be
839 // easily added.
840
841 /// Add the `const` type qualifier to this QualType.
842 void addConst() {
843 addFastQualifiers(Qualifiers::Const);
844 }
845 QualType withConst() const {
846 return withFastQualifiers(Qualifiers::Const);
847 }
848
849 /// Add the `volatile` type qualifier to this QualType.
850 void addVolatile() {
851 addFastQualifiers(Qualifiers::Volatile);
852 }
853 QualType withVolatile() const {
854 return withFastQualifiers(Qualifiers::Volatile);
855 }
856
857 /// Add the `restrict` qualifier to this QualType.
858 void addRestrict() {
859 addFastQualifiers(Qualifiers::Restrict);
860 }
861 QualType withRestrict() const {
862 return withFastQualifiers(Qualifiers::Restrict);
863 }
864
865 QualType withCVRQualifiers(unsigned CVR) const {
866 return withFastQualifiers(CVR);
867 }
868
869 void addFastQualifiers(unsigned TQs) {
870 assert(!(TQs & ~Qualifiers::FastMask)(static_cast <bool> (!(TQs & ~Qualifiers::FastMask)
&& "non-fast qualifier bits set in mask!") ? void (0
) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 871, __extension__ __PRETTY_FUNCTION__))
871 && "non-fast qualifier bits set in mask!")(static_cast <bool> (!(TQs & ~Qualifiers::FastMask)
&& "non-fast qualifier bits set in mask!") ? void (0
) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 871, __extension__ __PRETTY_FUNCTION__))
;
872 Value.setInt(Value.getInt() | TQs);
873 }
874
875 void removeLocalConst();
876 void removeLocalVolatile();
877 void removeLocalRestrict();
878 void removeLocalCVRQualifiers(unsigned Mask);
879
880 void removeLocalFastQualifiers() { Value.setInt(0); }
881 void removeLocalFastQualifiers(unsigned Mask) {
882 assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")(static_cast <bool> (!(Mask & ~Qualifiers::FastMask
) && "mask has non-fast qualifiers") ? void (0) : __assert_fail
("!(Mask & ~Qualifiers::FastMask) && \"mask has non-fast qualifiers\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 882, __extension__ __PRETTY_FUNCTION__))
;
883 Value.setInt(Value.getInt() & ~Mask);
884 }
885
886 // Creates a type with the given qualifiers in addition to any
887 // qualifiers already on this type.
888 QualType withFastQualifiers(unsigned TQs) const {
889 QualType T = *this;
890 T.addFastQualifiers(TQs);
891 return T;
892 }
893
894 // Creates a type with exactly the given fast qualifiers, removing
895 // any existing fast qualifiers.
896 QualType withExactLocalFastQualifiers(unsigned TQs) const {
897 return withoutLocalFastQualifiers().withFastQualifiers(TQs);
898 }
899
900 // Removes fast qualifiers, but leaves any extended qualifiers in place.
901 QualType withoutLocalFastQualifiers() const {
902 QualType T = *this;
903 T.removeLocalFastQualifiers();
904 return T;
905 }
906
907 QualType getCanonicalType() const;
908
909 /// Return this type with all of the instance-specific qualifiers
910 /// removed, but without removing any qualifiers that may have been applied
911 /// through typedefs.
912 QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }
913
914 /// Retrieve the unqualified variant of the given type,
915 /// removing as little sugar as possible.
916 ///
917 /// This routine looks through various kinds of sugar to find the
918 /// least-desugared type that is unqualified. For example, given:
919 ///
920 /// \code
921 /// typedef int Integer;
922 /// typedef const Integer CInteger;
923 /// typedef CInteger DifferenceType;
924 /// \endcode
925 ///
926 /// Executing \c getUnqualifiedType() on the type \c DifferenceType will
927 /// desugar until we hit the type \c Integer, which has no qualifiers on it.
928 ///
929 /// The resulting type might still be qualified if it's sugar for an array
930 /// type. To strip qualifiers even from within a sugared array type, use
931 /// ASTContext::getUnqualifiedArrayType.
932 inline QualType getUnqualifiedType() const;
933
934 /// Retrieve the unqualified variant of the given type, removing as little
935 /// sugar as possible.
936 ///
937 /// Like getUnqualifiedType(), but also returns the set of
938 /// qualifiers that were built up.
939 ///
940 /// The resulting type might still be qualified if it's sugar for an array
941 /// type. To strip qualifiers even from within a sugared array type, use
942 /// ASTContext::getUnqualifiedArrayType.
943 inline SplitQualType getSplitUnqualifiedType() const;
944
945 /// Determine whether this type is more qualified than the other
946 /// given type, requiring exact equality for non-CVR qualifiers.
947 bool isMoreQualifiedThan(QualType Other) const;
948
949 /// Determine whether this type is at least as qualified as the other
950 /// given type, requiring exact equality for non-CVR qualifiers.
951 bool isAtLeastAsQualifiedAs(QualType Other) const;
952
953 QualType getNonReferenceType() const;
954
955 /// Determine the type of a (typically non-lvalue) expression with the
956 /// specified result type.
957 ///
958 /// This routine should be used for expressions for which the return type is
959 /// explicitly specified (e.g., in a cast or call) and isn't necessarily
960 /// an lvalue. It removes a top-level reference (since there are no
961 /// expressions of reference type) and deletes top-level cvr-qualifiers
962 /// from non-class types (in C++) or all types (in C).
963 QualType getNonLValueExprType(const ASTContext &Context) const;
964
965 /// Remove an outer pack expansion type (if any) from this type. Used as part
966 /// of converting the type of a declaration to the type of an expression that
967 /// references that expression. It's meaningless for an expression to have a
968 /// pack expansion type.
969 QualType getNonPackExpansionType() const;
970
971 /// Return the specified type with any "sugar" removed from
972 /// the type. This takes off typedefs, typeof's etc. If the outer level of
973 /// the type is already concrete, it returns it unmodified. This is similar
974 /// to getting the canonical type, but it doesn't remove *all* typedefs. For
975 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
976 /// concrete.
977 ///
978 /// Qualifiers are left in place.
979 QualType getDesugaredType(const ASTContext &Context) const {
980 return getDesugaredType(*this, Context);
981 }
982
983 SplitQualType getSplitDesugaredType() const {
984 return getSplitDesugaredType(*this);
985 }
986
987 /// Return the specified type with one level of "sugar" removed from
988 /// the type.
989 ///
990 /// This routine takes off the first typedef, typeof, etc. If the outer level
991 /// of the type is already concrete, it returns it unmodified.
992 QualType getSingleStepDesugaredType(const ASTContext &Context) const {
993 return getSingleStepDesugaredTypeImpl(*this, Context);
994 }
995
996 /// Returns the specified type after dropping any
997 /// outer-level parentheses.
998 QualType IgnoreParens() const {
999 if (isa<ParenType>(*this))
1000 return QualType::IgnoreParens(*this);
1001 return *this;
1002 }
1003
1004 /// Indicate whether the specified types and qualifiers are identical.
1005 friend bool operator==(const QualType &LHS, const QualType &RHS) {
1006 return LHS.Value == RHS.Value;
1007 }
1008 friend bool operator!=(const QualType &LHS, const QualType &RHS) {
1009 return LHS.Value != RHS.Value;
1010 }
1011 friend bool operator<(const QualType &LHS, const QualType &RHS) {
1012 return LHS.Value < RHS.Value;
1013 }
1014
1015 static std::string getAsString(SplitQualType split,
1016 const PrintingPolicy &Policy) {
1017 return getAsString(split.Ty, split.Quals, Policy);
1018 }
1019 static std::string getAsString(const Type *ty, Qualifiers qs,
1020 const PrintingPolicy &Policy);
1021
1022 std::string getAsString() const;
1023 std::string getAsString(const PrintingPolicy &Policy) const;
1024
1025 void print(raw_ostream &OS, const PrintingPolicy &Policy,
1026 const Twine &PlaceHolder = Twine(),
1027 unsigned Indentation = 0) const;
1028
1029 static void print(SplitQualType split, raw_ostream &OS,
1030 const PrintingPolicy &policy, const Twine &PlaceHolder,
1031 unsigned Indentation = 0) {
1032 return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
1033 }
1034
1035 static void print(const Type *ty, Qualifiers qs,
1036 raw_ostream &OS, const PrintingPolicy &policy,
1037 const Twine &PlaceHolder,
1038 unsigned Indentation = 0);
1039
1040 void getAsStringInternal(std::string &Str,
1041 const PrintingPolicy &Policy) const;
1042
1043 static void getAsStringInternal(SplitQualType split, std::string &out,
1044 const PrintingPolicy &policy) {
1045 return getAsStringInternal(split.Ty, split.Quals, out, policy);
1046 }
1047
1048 static void getAsStringInternal(const Type *ty, Qualifiers qs,
1049 std::string &out,
1050 const PrintingPolicy &policy);
1051
1052 class StreamedQualTypeHelper {
1053 const QualType &T;
1054 const PrintingPolicy &Policy;
1055 const Twine &PlaceHolder;
1056 unsigned Indentation;
1057
1058 public:
1059 StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
1060 const Twine &PlaceHolder, unsigned Indentation)
1061 : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
1062 Indentation(Indentation) {}
1063
1064 friend raw_ostream &operator<<(raw_ostream &OS,
1065 const StreamedQualTypeHelper &SQT) {
1066 SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1067 return OS;
1068 }
1069 };
1070
1071 StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
1072 const Twine &PlaceHolder = Twine(),
1073 unsigned Indentation = 0) const {
1074 return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
1075 }
1076
1077 void dump(const char *s) const;
1078 void dump() const;
1079 void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
1080
1081 void Profile(llvm::FoldingSetNodeID &ID) const {
1082 ID.AddPointer(getAsOpaquePtr());
1083 }
1084
1085 /// Check if this type has any address space qualifier.
1086 inline bool hasAddressSpace() const;
1087
1088 /// Return the address space of this type.
1089 inline LangAS getAddressSpace() const;
1090
1091 /// Returns true if address space qualifiers overlap with T address space
1092 /// qualifiers.
1093 /// OpenCL C defines conversion rules for pointers to different address spaces
1094 /// and notion of overlapping address spaces.
1095 /// CL1.1 or CL1.2:
1096 /// address spaces overlap iff they are they same.
1097 /// OpenCL C v2.0 s6.5.5 adds:
1098 /// __generic overlaps with any address space except for __constant.
1099 bool isAddressSpaceOverlapping(QualType T) const {
1100 Qualifiers Q = getQualifiers();
1101 Qualifiers TQ = T.getQualifiers();
1102 // Address spaces overlap if at least one of them is a superset of another
1103 return Q.isAddressSpaceSupersetOf(TQ) || TQ.isAddressSpaceSupersetOf(Q);
1104 }
1105
1106 /// Returns gc attribute of this type.
1107 inline Qualifiers::GC getObjCGCAttr() const;
1108
1109 /// true when Type is objc's weak.
1110 bool isObjCGCWeak() const {
1111 return getObjCGCAttr() == Qualifiers::Weak;
1112 }
1113
1114 /// true when Type is objc's strong.
1115 bool isObjCGCStrong() const {
1116 return getObjCGCAttr() == Qualifiers::Strong;
1117 }
1118
1119 /// Returns lifetime attribute of this type.
1120 Qualifiers::ObjCLifetime getObjCLifetime() const {
1121 return getQualifiers().getObjCLifetime();
1122 }
1123
1124 bool hasNonTrivialObjCLifetime() const {
1125 return getQualifiers().hasNonTrivialObjCLifetime();
1126 }
1127
1128 bool hasStrongOrWeakObjCLifetime() const {
1129 return getQualifiers().hasStrongOrWeakObjCLifetime();
1130 }
1131
1132 // true when Type is objc's weak and weak is enabled but ARC isn't.
1133 bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;
1134
1135 enum PrimitiveDefaultInitializeKind {
1136 /// The type does not fall into any of the following categories. Note that
1137 /// this case is zero-valued so that values of this enum can be used as a
1138 /// boolean condition for non-triviality.
1139 PDIK_Trivial,
1140
1141 /// The type is an Objective-C retainable pointer type that is qualified
1142 /// with the ARC __strong qualifier.
1143 PDIK_ARCStrong,
1144
1145 /// The type is an Objective-C retainable pointer type that is qualified
1146 /// with the ARC __weak qualifier.
1147 PDIK_ARCWeak,
1148
1149 /// The type is a struct containing a field whose type is not PCK_Trivial.
1150 PDIK_Struct
1151 };
1152
1153 /// Functions to query basic properties of non-trivial C struct types.
1154
1155 /// Check if this is a non-trivial type that would cause a C struct
1156 /// transitively containing this type to be non-trivial to default initialize
1157 /// and return the kind.
1158 PrimitiveDefaultInitializeKind
1159 isNonTrivialToPrimitiveDefaultInitialize() const;
1160
1161 enum PrimitiveCopyKind {
1162 /// The type does not fall into any of the following categories. Note that
1163 /// this case is zero-valued so that values of this enum can be used as a
1164 /// boolean condition for non-triviality.
1165 PCK_Trivial,
1166
1167 /// The type would be trivial except that it is volatile-qualified. Types
1168 /// that fall into one of the other non-trivial cases may additionally be
1169 /// volatile-qualified.
1170 PCK_VolatileTrivial,
1171
1172 /// The type is an Objective-C retainable pointer type that is qualified
1173 /// with the ARC __strong qualifier.
1174 PCK_ARCStrong,
1175
1176 /// The type is an Objective-C retainable pointer type that is qualified
1177 /// with the ARC __weak qualifier.
1178 PCK_ARCWeak,
1179
1180 /// The type is a struct containing a field whose type is neither
1181 /// PCK_Trivial nor PCK_VolatileTrivial.
1182 /// Note that a C++ struct type does not necessarily match this; C++ copying
1183 /// semantics are too complex to express here, in part because they depend
1184 /// on the exact constructor or assignment operator that is chosen by
1185 /// overload resolution to do the copy.
1186 PCK_Struct
1187 };
1188
1189 /// Check if this is a non-trivial type that would cause a C struct
1190 /// transitively containing this type to be non-trivial to copy and return the
1191 /// kind.
1192 PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;
1193
1194 /// Check if this is a non-trivial type that would cause a C struct
1195 /// transitively containing this type to be non-trivial to destructively
1196 /// move and return the kind. Destructive move in this context is a C++-style
1197 /// move in which the source object is placed in a valid but unspecified state
1198 /// after it is moved, as opposed to a truly destructive move in which the
1199 /// source object is placed in an uninitialized state.
1200 PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;
1201
1202 enum DestructionKind {
1203 DK_none,
1204 DK_cxx_destructor,
1205 DK_objc_strong_lifetime,
1206 DK_objc_weak_lifetime,
1207 DK_nontrivial_c_struct
1208 };
1209
1210 /// Returns a nonzero value if objects of this type require
1211 /// non-trivial work to clean up after. Non-zero because it's
1212 /// conceivable that qualifiers (objc_gc(weak)?) could make
1213 /// something require destruction.
1214 DestructionKind isDestructedType() const {
1215 return isDestructedTypeImpl(*this);
1216 }
1217
1218 /// Check if this is or contains a C union that is non-trivial to
1219 /// default-initialize, which is a union that has a member that is non-trivial
1220 /// to default-initialize. If this returns true,
1221 /// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
1222 bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;
1223
1224 /// Check if this is or contains a C union that is non-trivial to destruct,
1225 /// which is a union that has a member that is non-trivial to destruct. If
1226 /// this returns true, isDestructedType returns DK_nontrivial_c_struct.
1227 bool hasNonTrivialToPrimitiveDestructCUnion() const;
1228
1229 /// Check if this is or contains a C union that is non-trivial to copy, which
1230 /// is a union that has a member that is non-trivial to copy. If this returns
1231 /// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
1232 bool hasNonTrivialToPrimitiveCopyCUnion() const;
1233
1234 /// Determine whether expressions of the given type are forbidden
1235 /// from being lvalues in C.
1236 ///
1237 /// The expression types that are forbidden to be lvalues are:
1238 /// - 'void', but not qualified void
1239 /// - function types
1240 ///
1241 /// The exact rule here is C99 6.3.2.1:
1242 /// An lvalue is an expression with an object type or an incomplete
1243 /// type other than void.
1244 bool isCForbiddenLValueType() const;
1245
1246 /// Substitute type arguments for the Objective-C type parameters used in the
1247 /// subject type.
1248 ///
1249 /// \param ctx ASTContext in which the type exists.
1250 ///
1251 /// \param typeArgs The type arguments that will be substituted for the
1252 /// Objective-C type parameters in the subject type, which are generally
1253 /// computed via \c Type::getObjCSubstitutions. If empty, the type
1254 /// parameters will be replaced with their bounds or id/Class, as appropriate
1255 /// for the context.
1256 ///
1257 /// \param context The context in which the subject type was written.
1258 ///
1259 /// \returns the resulting type.
1260 QualType substObjCTypeArgs(ASTContext &ctx,
1261 ArrayRef<QualType> typeArgs,
1262 ObjCSubstitutionContext context) const;
1263
1264 /// Substitute type arguments from an object type for the Objective-C type
1265 /// parameters used in the subject type.
1266 ///
1267 /// This operation combines the computation of type arguments for
1268 /// substitution (\c Type::getObjCSubstitutions) with the actual process of
1269 /// substitution (\c QualType::substObjCTypeArgs) for the convenience of
1270 /// callers that need to perform a single substitution in isolation.
1271 ///
1272 /// \param objectType The type of the object whose member type we're
1273 /// substituting into. For example, this might be the receiver of a message
1274 /// or the base of a property access.
1275 ///
1276 /// \param dc The declaration context from which the subject type was
1277 /// retrieved, which indicates (for example) which type parameters should
1278 /// be substituted.
1279 ///
1280 /// \param context The context in which the subject type was written.
1281 ///
1282 /// \returns the subject type after replacing all of the Objective-C type
1283 /// parameters with their corresponding arguments.
1284 QualType substObjCMemberType(QualType objectType,
1285 const DeclContext *dc,
1286 ObjCSubstitutionContext context) const;
1287
1288 /// Strip Objective-C "__kindof" types from the given type.
1289 QualType stripObjCKindOfType(const ASTContext &ctx) const;
1290
1291 /// Remove all qualifiers including _Atomic.
1292 QualType getAtomicUnqualifiedType() const;
1293
1294private:
1295 // These methods are implemented in a separate translation unit;
1296 // "static"-ize them to avoid creating temporary QualTypes in the
1297 // caller.
1298 static bool isConstant(QualType T, const ASTContext& Ctx);
1299 static QualType getDesugaredType(QualType T, const ASTContext &Context);
1300 static SplitQualType getSplitDesugaredType(QualType T);
1301 static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
1302 static QualType getSingleStepDesugaredTypeImpl(QualType type,
1303 const ASTContext &C);
1304 static QualType IgnoreParens(QualType T);
1305 static DestructionKind isDestructedTypeImpl(QualType type);
1306
1307 /// Check if \param RD is or contains a non-trivial C union.
1308 static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
1309 static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
1310 static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1311};
1312
1313} // namespace clang
1314
1315namespace llvm {
1316
1317/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1318/// to a specific Type class.
1319template<> struct simplify_type< ::clang::QualType> {
1320 using SimpleType = const ::clang::Type *;
1321
1322 static SimpleType getSimplifiedValue(::clang::QualType Val) {
1323 return Val.getTypePtr();
1324 }
1325};
1326
1327// Teach SmallPtrSet that QualType is "basically a pointer".
1328template<>
1329struct PointerLikeTypeTraits<clang::QualType> {
1330 static inline void *getAsVoidPointer(clang::QualType P) {
1331 return P.getAsOpaquePtr();
1332 }
1333
1334 static inline clang::QualType getFromVoidPointer(void *P) {
1335 return clang::QualType::getFromOpaquePtr(P);
1336 }
1337
1338 // Various qualifiers go in low bits.
1339 static constexpr int NumLowBitsAvailable = 0;
1340};
1341
1342} // namespace llvm
1343
1344namespace clang {
1345
1346/// Base class that is common to both the \c ExtQuals and \c Type
1347/// classes, which allows \c QualType to access the common fields between the
1348/// two.
1349class ExtQualsTypeCommonBase {
1350 friend class ExtQuals;
1351 friend class QualType;
1352 friend class Type;
1353
1354 /// The "base" type of an extended qualifiers type (\c ExtQuals) or
1355 /// a self-referential pointer (for \c Type).
1356 ///
1357 /// This pointer allows an efficient mapping from a QualType to its
1358 /// underlying type pointer.
1359 const Type *const BaseType;
1360
1361 /// The canonical type of this type. A QualType.
1362 QualType CanonicalType;
1363
1364 ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
1365 : BaseType(baseType), CanonicalType(canon) {}
1366};
1367
1368/// We can encode up to four bits in the low bits of a
1369/// type pointer, but there are many more type qualifiers that we want
1370/// to be able to apply to an arbitrary type. Therefore we have this
1371/// struct, intended to be heap-allocated and used by QualType to
1372/// store qualifiers.
1373///
1374/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1375/// in three low bits on the QualType pointer; a fourth bit records whether
1376/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1377/// Objective-C GC attributes) are much more rare.
1378class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
1379 // NOTE: changing the fast qualifiers should be straightforward as
1380 // long as you don't make 'const' non-fast.
1381 // 1. Qualifiers:
1382 // a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
1383 // Fast qualifiers must occupy the low-order bits.
1384 // b) Update Qualifiers::FastWidth and FastMask.
1385 // 2. QualType:
1386 // a) Update is{Volatile,Restrict}Qualified(), defined inline.
1387 // b) Update remove{Volatile,Restrict}, defined near the end of
1388 // this header.
1389 // 3. ASTContext:
1390 // a) Update get{Volatile,Restrict}Type.
1391
1392 /// The immutable set of qualifiers applied by this node. Always contains
1393 /// extended qualifiers.
1394 Qualifiers Quals;
1395
1396 ExtQuals *this_() { return this; }
1397
1398public:
1399 ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
1400 : ExtQualsTypeCommonBase(baseType,
1401 canon.isNull() ? QualType(this_(), 0) : canon),
1402 Quals(quals) {
1403 assert(Quals.hasNonFastQualifiers()(static_cast <bool> (Quals.hasNonFastQualifiers() &&
"ExtQuals created with no fast qualifiers") ? void (0) : __assert_fail
("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 1404, __extension__ __PRETTY_FUNCTION__))
1404 && "ExtQuals created with no fast qualifiers")(static_cast <bool> (Quals.hasNonFastQualifiers() &&
"ExtQuals created with no fast qualifiers") ? void (0) : __assert_fail
("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 1404, __extension__ __PRETTY_FUNCTION__))
;
1405 assert(!Quals.hasFastQualifiers()(static_cast <bool> (!Quals.hasFastQualifiers() &&
"ExtQuals created with fast qualifiers") ? void (0) : __assert_fail
("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 1406, __extension__ __PRETTY_FUNCTION__))
1406 && "ExtQuals created with fast qualifiers")(static_cast <bool> (!Quals.hasFastQualifiers() &&
"ExtQuals created with fast qualifiers") ? void (0) : __assert_fail
("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 1406, __extension__ __PRETTY_FUNCTION__))
;
1407 }
1408
1409 Qualifiers getQualifiers() const { return Quals; }
1410
1411 bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
1412 Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }
1413
1414 bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
1415 Qualifiers::ObjCLifetime getObjCLifetime() const {
1416 return Quals.getObjCLifetime();
1417 }
1418
1419 bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
1420 LangAS getAddressSpace() const { return Quals.getAddressSpace(); }
1421
1422 const Type *getBaseType() const { return BaseType; }
1423
1424public:
1425 void Profile(llvm::FoldingSetNodeID &ID) const {
1426 Profile(ID, getBaseType(), Quals);
1427 }
1428
1429 static void Profile(llvm::FoldingSetNodeID &ID,
1430 const Type *BaseType,
1431 Qualifiers Quals) {
1432 assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")(static_cast <bool> (!Quals.hasFastQualifiers() &&
"fast qualifiers in ExtQuals hash!") ? void (0) : __assert_fail
("!Quals.hasFastQualifiers() && \"fast qualifiers in ExtQuals hash!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 1432, __extension__ __PRETTY_FUNCTION__))
;
1433 ID.AddPointer(BaseType);
1434 Quals.Profile(ID);
1435 }
1436};
1437
1438/// The kind of C++11 ref-qualifier associated with a function type.
1439/// This determines whether a member function's "this" object can be an
1440/// lvalue, rvalue, or neither.
1441enum RefQualifierKind {
1442 /// No ref-qualifier was provided.
1443 RQ_None = 0,
1444
1445 /// An lvalue ref-qualifier was provided (\c &).
1446 RQ_LValue,
1447
1448 /// An rvalue ref-qualifier was provided (\c &&).
1449 RQ_RValue
1450};
1451
1452/// Which keyword(s) were used to create an AutoType.
1453enum class AutoTypeKeyword {
1454 /// auto
1455 Auto,
1456
1457 /// decltype(auto)
1458 DecltypeAuto,
1459
1460 /// __auto_type (GNU extension)
1461 GNUAutoType
1462};
1463
1464/// The base class of the type hierarchy.
1465///
1466/// A central concept with types is that each type always has a canonical
1467/// type. A canonical type is the type with any typedef names stripped out
1468/// of it or the types it references. For example, consider:
1469///
1470/// typedef int foo;
1471/// typedef foo* bar;
1472/// 'int *' 'foo *' 'bar'
1473///
1474/// There will be a Type object created for 'int'. Since int is canonical, its
1475/// CanonicalType pointer points to itself. There is also a Type for 'foo' (a
1476/// TypedefType). Its CanonicalType pointer points to the 'int' Type. Next
1477/// there is a PointerType that represents 'int*', which, like 'int', is
1478/// canonical. Finally, there is a PointerType type for 'foo*' whose canonical
1479/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1480/// is also 'int*'.
1481///
1482/// Non-canonical types are useful for emitting diagnostics, without losing
1483/// information about typedefs being used. Canonical types are useful for type
1484/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1485/// about whether something has a particular form (e.g. is a function type),
1486/// because they implicitly, recursively, strip all typedefs out of a type.
1487///
1488/// Types, once created, are immutable.
1489///
1490class alignas(8) Type : public ExtQualsTypeCommonBase {
1491public:
1492 enum TypeClass {
1493#define TYPE(Class, Base) Class,
1494#define LAST_TYPE(Class) TypeLast = Class
1495#define ABSTRACT_TYPE(Class, Base)
1496#include "clang/AST/TypeNodes.inc"
1497 };
1498
1499private:
1500 /// Bitfields required by the Type class.
1501 class TypeBitfields {
1502 friend class Type;
1503 template <class T> friend class TypePropertyCache;
1504
1505 /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
1506 unsigned TC : 8;
1507
1508 /// Store information on the type dependency.
1509 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1510
1511 /// True if the cache (i.e. the bitfields here starting with
1512 /// 'Cache') is valid.
1513 mutable unsigned CacheValid : 1;
1514
1515 /// Linkage of this type.
1516 mutable unsigned CachedLinkage : 3;
1517
1518 /// Whether this type involves and local or unnamed types.
1519 mutable unsigned CachedLocalOrUnnamed : 1;
1520
1521 /// Whether this type comes from an AST file.
1522 mutable unsigned FromAST : 1;
1523
1524 bool isCacheValid() const {
1525 return CacheValid;
1526 }
1527
1528 Linkage getLinkage() const {
1529 assert(isCacheValid() && "getting linkage from invalid cache")(static_cast <bool> (isCacheValid() && "getting linkage from invalid cache"
) ? void (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 1529, __extension__ __PRETTY_FUNCTION__))
;
1530 return static_cast<Linkage>(CachedLinkage);
1531 }
1532
1533 bool hasLocalOrUnnamedType() const {
1534 assert(isCacheValid() && "getting linkage from invalid cache")(static_cast <bool> (isCacheValid() && "getting linkage from invalid cache"
) ? void (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 1534, __extension__ __PRETTY_FUNCTION__))
;
1535 return CachedLocalOrUnnamed;
1536 }
1537 };
1538 enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1539
1540protected:
1541 // These classes allow subclasses to somewhat cleanly pack bitfields
1542 // into Type.
1543
1544 class ArrayTypeBitfields {
1545 friend class ArrayType;
1546
1547 unsigned : NumTypeBits;
1548
1549 /// CVR qualifiers from declarations like
1550 /// 'int X[static restrict 4]'. For function parameters only.
1551 unsigned IndexTypeQuals : 3;
1552
1553 /// Storage class qualifiers from declarations like
1554 /// 'int X[static restrict 4]'. For function parameters only.
1555 /// Actually an ArrayType::ArraySizeModifier.
1556 unsigned SizeModifier : 3;
1557 };
1558
1559 class ConstantArrayTypeBitfields {
1560 friend class ConstantArrayType;
1561
1562 unsigned : NumTypeBits + 3 + 3;
1563
1564 /// Whether we have a stored size expression.
1565 unsigned HasStoredSizeExpr : 1;
1566 };
1567
1568 class BuiltinTypeBitfields {
1569 friend class BuiltinType;
1570
1571 unsigned : NumTypeBits;
1572
1573 /// The kind (BuiltinType::Kind) of builtin type this is.
1574 unsigned Kind : 8;
1575 };
1576
1577 /// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
1578 /// Only common bits are stored here. Additional uncommon bits are stored
1579 /// in a trailing object after FunctionProtoType.
1580 class FunctionTypeBitfields {
1581 friend class FunctionProtoType;
1582 friend class FunctionType;
1583
1584 unsigned : NumTypeBits;
1585
1586 /// Extra information which affects how the function is called, like
1587 /// regparm and the calling convention.
1588 unsigned ExtInfo : 13;
1589
1590 /// The ref-qualifier associated with a \c FunctionProtoType.
1591 ///
1592 /// This is a value of type \c RefQualifierKind.
1593 unsigned RefQualifier : 2;
1594
1595 /// Used only by FunctionProtoType, put here to pack with the
1596 /// other bitfields.
1597 /// The qualifiers are part of FunctionProtoType because...
1598 ///
1599 /// C++ 8.3.5p4: The return type, the parameter type list and the
1600 /// cv-qualifier-seq, [...], are part of the function type.
1601 unsigned FastTypeQuals : Qualifiers::FastWidth;
1602 /// Whether this function has extended Qualifiers.
1603 unsigned HasExtQuals : 1;
1604
1605 /// The number of parameters this function has, not counting '...'.
1606 /// According to [implimits] 8 bits should be enough here but this is
1607 /// somewhat easy to exceed with metaprogramming and so we would like to
1608 /// keep NumParams as wide as reasonably possible.
1609 unsigned NumParams : 16;
1610
1611 /// The type of exception specification this function has.
1612 unsigned ExceptionSpecType : 4;
1613
1614 /// Whether this function has extended parameter information.
1615 unsigned HasExtParameterInfos : 1;
1616
1617 /// Whether the function is variadic.
1618 unsigned Variadic : 1;
1619
1620 /// Whether this function has a trailing return type.
1621 unsigned HasTrailingReturn : 1;
1622 };
1623
1624 class ObjCObjectTypeBitfields {
1625 friend class ObjCObjectType;
1626
1627 unsigned : NumTypeBits;
1628
1629 /// The number of type arguments stored directly on this object type.
1630 unsigned NumTypeArgs : 7;
1631
1632 /// The number of protocols stored directly on this object type.
1633 unsigned NumProtocols : 6;
1634
1635 /// Whether this is a "kindof" type.
1636 unsigned IsKindOf : 1;
1637 };
1638
1639 class ReferenceTypeBitfields {
1640 friend class ReferenceType;
1641
1642 unsigned : NumTypeBits;
1643
1644 /// True if the type was originally spelled with an lvalue sigil.
1645 /// This is never true of rvalue references but can also be false
1646 /// on lvalue references because of C++0x [dcl.typedef]p9,
1647 /// as follows:
1648 ///
1649 /// typedef int &ref; // lvalue, spelled lvalue
1650 /// typedef int &&rvref; // rvalue
1651 /// ref &a; // lvalue, inner ref, spelled lvalue
1652 /// ref &&a; // lvalue, inner ref
1653 /// rvref &a; // lvalue, inner ref, spelled lvalue
1654 /// rvref &&a; // rvalue, inner ref
1655 unsigned SpelledAsLValue : 1;
1656
1657 /// True if the inner type is a reference type. This only happens
1658 /// in non-canonical forms.
1659 unsigned InnerRef : 1;
1660 };
1661
1662 class TypeWithKeywordBitfields {
1663 friend class TypeWithKeyword;
1664
1665 unsigned : NumTypeBits;
1666
1667 /// An ElaboratedTypeKeyword. 8 bits for efficient access.
1668 unsigned Keyword : 8;
1669 };
1670
1671 enum { NumTypeWithKeywordBits = 8 };
1672
1673 class ElaboratedTypeBitfields {
1674 friend class ElaboratedType;
1675
1676 unsigned : NumTypeBits;
1677 unsigned : NumTypeWithKeywordBits;
1678
1679 /// Whether the ElaboratedType has a trailing OwnedTagDecl.
1680 unsigned HasOwnedTagDecl : 1;
1681 };
1682
1683 class VectorTypeBitfields {
1684 friend class VectorType;
1685 friend class DependentVectorType;
1686
1687 unsigned : NumTypeBits;
1688
1689 /// The kind of vector, either a generic vector type or some
1690 /// target-specific vector type such as for AltiVec or Neon.
1691 unsigned VecKind : 3;
1692 /// The number of elements in the vector.
1693 uint32_t NumElements;
1694 };
1695
1696 class AttributedTypeBitfields {
1697 friend class AttributedType;
1698
1699 unsigned : NumTypeBits;
1700
1701 /// An AttributedType::Kind
1702 unsigned AttrKind : 32 - NumTypeBits;
1703 };
1704
1705 class AutoTypeBitfields {
1706 friend class AutoType;
1707
1708 unsigned : NumTypeBits;
1709
1710 /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
1711 /// or '__auto_type'? AutoTypeKeyword value.
1712 unsigned Keyword : 2;
1713
1714 /// The number of template arguments in the type-constraints, which is
1715 /// expected to be able to hold at least 1024 according to [implimits].
1716 /// However as this limit is somewhat easy to hit with template
1717 /// metaprogramming we'd prefer to keep it as large as possible.
1718 /// At the moment it has been left as a non-bitfield since this type
1719 /// safely fits in 64 bits as an unsigned, so there is no reason to
1720 /// introduce the performance impact of a bitfield.
1721 unsigned NumArgs;
1722 };
1723
1724 class SubstTemplateTypeParmPackTypeBitfields {
1725 friend class SubstTemplateTypeParmPackType;
1726
1727 unsigned : NumTypeBits;
1728
1729 /// The number of template arguments in \c Arguments, which is
1730 /// expected to be able to hold at least 1024 according to [implimits].
1731 /// However as this limit is somewhat easy to hit with template
1732 /// metaprogramming we'd prefer to keep it as large as possible.
1733 /// At the moment it has been left as a non-bitfield since this type
1734 /// safely fits in 64 bits as an unsigned, so there is no reason to
1735 /// introduce the performance impact of a bitfield.
1736 unsigned NumArgs;
1737 };
1738
1739 class TemplateSpecializationTypeBitfields {
1740 friend class TemplateSpecializationType;
1741
1742 unsigned : NumTypeBits;
1743
1744 /// Whether this template specialization type is a substituted type alias.
1745 unsigned TypeAlias : 1;
1746
1747 /// The number of template arguments named in this class template
1748 /// specialization, which is expected to be able to hold at least 1024
1749 /// according to [implimits]. However, as this limit is somewhat easy to
1750 /// hit with template metaprogramming we'd prefer to keep it as large
1751 /// as possible. At the moment it has been left as a non-bitfield since
1752 /// this type safely fits in 64 bits as an unsigned, so there is no reason
1753 /// to introduce the performance impact of a bitfield.
1754 unsigned NumArgs;
1755 };
1756
1757 class DependentTemplateSpecializationTypeBitfields {
1758 friend class DependentTemplateSpecializationType;
1759
1760 unsigned : NumTypeBits;
1761 unsigned : NumTypeWithKeywordBits;
1762
1763 /// The number of template arguments named in this class template
1764 /// specialization, which is expected to be able to hold at least 1024
1765 /// according to [implimits]. However, as this limit is somewhat easy to
1766 /// hit with template metaprogramming we'd prefer to keep it as large
1767 /// as possible. At the moment it has been left as a non-bitfield since
1768 /// this type safely fits in 64 bits as an unsigned, so there is no reason
1769 /// to introduce the performance impact of a bitfield.
1770 unsigned NumArgs;
1771 };
1772
1773 class PackExpansionTypeBitfields {
1774 friend class PackExpansionType;
1775
1776 unsigned : NumTypeBits;
1777
1778 /// The number of expansions that this pack expansion will
1779 /// generate when substituted (+1), which is expected to be able to
1780 /// hold at least 1024 according to [implimits]. However, as this limit
1781 /// is somewhat easy to hit with template metaprogramming we'd prefer to
1782 /// keep it as large as possible. At the moment it has been left as a
1783 /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
1784 /// there is no reason to introduce the performance impact of a bitfield.
1785 ///
1786 /// This field will only have a non-zero value when some of the parameter
1787 /// packs that occur within the pattern have been substituted but others
1788 /// have not.
1789 unsigned NumExpansions;
1790 };
1791
1792 union {
1793 TypeBitfields TypeBits;
1794 ArrayTypeBitfields ArrayTypeBits;
1795 ConstantArrayTypeBitfields ConstantArrayTypeBits;
1796 AttributedTypeBitfields AttributedTypeBits;
1797 AutoTypeBitfields AutoTypeBits;
1798 BuiltinTypeBitfields BuiltinTypeBits;
1799 FunctionTypeBitfields FunctionTypeBits;
1800 ObjCObjectTypeBitfields ObjCObjectTypeBits;
1801 ReferenceTypeBitfields ReferenceTypeBits;
1802 TypeWithKeywordBitfields TypeWithKeywordBits;
1803 ElaboratedTypeBitfields ElaboratedTypeBits;
1804 VectorTypeBitfields VectorTypeBits;
1805 SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
1806 TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
1807 DependentTemplateSpecializationTypeBitfields
1808 DependentTemplateSpecializationTypeBits;
1809 PackExpansionTypeBitfields PackExpansionTypeBits;
1810 };
1811
1812private:
1813 template <class T> friend class TypePropertyCache;
1814
1815 /// Set whether this type comes from an AST file.
1816 void setFromAST(bool V = true) const {
1817 TypeBits.FromAST = V;
1818 }
1819
1820protected:
1821 friend class ASTContext;
1822
1823 Type(TypeClass tc, QualType canon, TypeDependence Dependence)
1824 : ExtQualsTypeCommonBase(this,
1825 canon.isNull() ? QualType(this_(), 0) : canon) {
1826 static_assert(sizeof(*this) <= 8 + sizeof(ExtQualsTypeCommonBase),
1827 "changing bitfields changed sizeof(Type)!");
1828 static_assert(alignof(decltype(*this)) % sizeof(void *) == 0,
1829 "Insufficient alignment!");
1830 TypeBits.TC = tc;
1831 TypeBits.Dependence = static_cast<unsigned>(Dependence);
1832 TypeBits.CacheValid = false;
1833 TypeBits.CachedLocalOrUnnamed = false;
1834 TypeBits.CachedLinkage = NoLinkage;
1835 TypeBits.FromAST = false;
1836 }
1837
1838 // silence VC++ warning C4355: 'this' : used in base member initializer list
1839 Type *this_() { return this; }
1840
1841 void setDependence(TypeDependence D) {
1842 TypeBits.Dependence = static_cast<unsigned>(D);
1843 }
1844
1845 void addDependence(TypeDependence D) { setDependence(getDependence() | D); }
1846
1847public:
1848 friend class ASTReader;
1849 friend class ASTWriter;
1850 template <class T> friend class serialization::AbstractTypeReader;
1851 template <class T> friend class serialization::AbstractTypeWriter;
1852
1853 Type(const Type &) = delete;
1854 Type(Type &&) = delete;
1855 Type &operator=(const Type &) = delete;
1856 Type &operator=(Type &&) = delete;
1857
1858 TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
1859
1860 /// Whether this type comes from an AST file.
1861 bool isFromAST() const { return TypeBits.FromAST; }
1862
1863 /// Whether this type is or contains an unexpanded parameter
1864 /// pack, used to support C++0x variadic templates.
1865 ///
1866 /// A type that contains a parameter pack shall be expanded by the
1867 /// ellipsis operator at some point. For example, the typedef in the
1868 /// following example contains an unexpanded parameter pack 'T':
1869 ///
1870 /// \code
1871 /// template<typename ...T>
1872 /// struct X {
1873 /// typedef T* pointer_types; // ill-formed; T is a parameter pack.
1874 /// };
1875 /// \endcode
1876 ///
1877 /// Note that this routine does not specify which
1878 bool containsUnexpandedParameterPack() const {
1879 return getDependence() & TypeDependence::UnexpandedPack;
1880 }
1881
1882 /// Determines if this type would be canonical if it had no further
1883 /// qualification.
1884 bool isCanonicalUnqualified() const {
1885 return CanonicalType == QualType(this, 0);
1886 }
1887
1888 /// Pull a single level of sugar off of this locally-unqualified type.
1889 /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
1890 /// or QualType::getSingleStepDesugaredType(const ASTContext&).
1891 QualType getLocallyUnqualifiedSingleStepDesugaredType() const;
1892
1893 /// As an extension, we classify types as one of "sized" or "sizeless";
1894 /// every type is one or the other. Standard types are all sized;
1895 /// sizeless types are purely an extension.
1896 ///
1897 /// Sizeless types contain data with no specified size, alignment,
1898 /// or layout.
1899 bool isSizelessType() const;
1900 bool isSizelessBuiltinType() const;
1901
1902 /// Determines if this is a sizeless type supported by the
1903 /// 'arm_sve_vector_bits' type attribute, which can be applied to a single
1904 /// SVE vector or predicate, excluding tuple types such as svint32x4_t.
1905 bool isVLSTBuiltinType() const;
1906
1907 /// Returns the representative type for the element of an SVE builtin type.
1908 /// This is used to represent fixed-length SVE vectors created with the
1909 /// 'arm_sve_vector_bits' type attribute as VectorType.
1910 QualType getSveEltType(const ASTContext &Ctx) const;
1911
1912 /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
1913 /// object types, function types, and incomplete types.
1914
1915 /// Return true if this is an incomplete type.
1916 /// A type that can describe objects, but which lacks information needed to
1917 /// determine its size (e.g. void, or a fwd declared struct). Clients of this
1918 /// routine will need to determine if the size is actually required.
1919 ///
1920 /// Def If non-null, and the type refers to some kind of declaration
1921 /// that can be completed (such as a C struct, C++ class, or Objective-C
1922 /// class), will be set to the declaration.
1923 bool isIncompleteType(NamedDecl **Def = nullptr) const;
1924
1925 /// Return true if this is an incomplete or object
1926 /// type, in other words, not a function type.
1927 bool isIncompleteOrObjectType() const {
1928 return !isFunctionType();
1929 }
1930
1931 /// Determine whether this type is an object type.
1932 bool isObjectType() const {
1933 // C++ [basic.types]p8:
1934 // An object type is a (possibly cv-qualified) type that is not a
1935 // function type, not a reference type, and not a void type.
1936 return !isReferenceType() && !isFunctionType() && !isVoidType();
1937 }
1938
1939 /// Return true if this is a literal type
1940 /// (C++11 [basic.types]p10)
1941 bool isLiteralType(const ASTContext &Ctx) const;
1942
1943 /// Determine if this type is a structural type, per C++20 [temp.param]p7.
1944 bool isStructuralType() const;
1945
1946 /// Test if this type is a standard-layout type.
1947 /// (C++0x [basic.type]p9)
1948 bool isStandardLayoutType() const;
1949
1950 /// Helper methods to distinguish type categories. All type predicates
1951 /// operate on the canonical type, ignoring typedefs and qualifiers.
1952
1953 /// Returns true if the type is a builtin type.
1954 bool isBuiltinType() const;
1955
1956 /// Test for a particular builtin type.
1957 bool isSpecificBuiltinType(unsigned K) const;
1958
1959 /// Test for a type which does not represent an actual type-system type but
1960 /// is instead used as a placeholder for various convenient purposes within
1961 /// Clang. All such types are BuiltinTypes.
1962 bool isPlaceholderType() const;
1963 const BuiltinType *getAsPlaceholderType() const;
1964
1965 /// Test for a specific placeholder type.
1966 bool isSpecificPlaceholderType(unsigned K) const;
1967
1968 /// Test for a placeholder type other than Overload; see
1969 /// BuiltinType::isNonOverloadPlaceholderType.
1970 bool isNonOverloadPlaceholderType() const;
1971
1972 /// isIntegerType() does *not* include complex integers (a GCC extension).
1973 /// isComplexIntegerType() can be used to test for complex integers.
1974 bool isIntegerType() const; // C99 6.2.5p17 (int, char, bool, enum)
1975 bool isEnumeralType() const;
1976
1977 /// Determine whether this type is a scoped enumeration type.
1978 bool isScopedEnumeralType() const;
1979 bool isBooleanType() const;
1980 bool isCharType() const;
1981 bool isWideCharType() const;
1982 bool isChar8Type() const;
1983 bool isChar16Type() const;
1984 bool isChar32Type() const;
1985 bool isAnyCharacterType() const;
1986 bool isIntegralType(const ASTContext &Ctx) const;
1987
1988 /// Determine whether this type is an integral or enumeration type.
1989 bool isIntegralOrEnumerationType() const;
1990
1991 /// Determine whether this type is an integral or unscoped enumeration type.
1992 bool isIntegralOrUnscopedEnumerationType() const;
1993 bool isUnscopedEnumerationType() const;
1994
1995 /// Floating point categories.
1996 bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
1997 /// isComplexType() does *not* include complex integers (a GCC extension).
1998 /// isComplexIntegerType() can be used to test for complex integers.
1999 bool isComplexType() const; // C99 6.2.5p11 (complex)
2000 bool isAnyComplexType() const; // C99 6.2.5p11 (complex) + Complex Int.
2001 bool isFloatingType() const; // C99 6.2.5p11 (real floating + complex)
2002 bool isHalfType() const; // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
2003 bool isFloat16Type() const; // C11 extension ISO/IEC TS 18661
2004 bool isBFloat16Type() const;
2005 bool isFloat128Type() const;
2006 bool isRealType() const; // C99 6.2.5p17 (real floating + integer)
2007 bool isArithmeticType() const; // C99 6.2.5p18 (integer + floating)
2008 bool isVoidType() const; // C99 6.2.5p19
2009 bool isScalarType() const; // C99 6.2.5p21 (arithmetic + pointers)
2010 bool isAggregateType() const;
2011 bool isFundamentalType() const;
2012 bool isCompoundType() const;
2013
2014 // Type Predicates: Check to see if this type is structurally the specified
2015 // type, ignoring typedefs and qualifiers.
2016 bool isFunctionType() const;
2017 bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
2018 bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
2019 bool isPointerType() const;
2020 bool isAnyPointerType() const; // Any C pointer or ObjC object pointer
2021 bool isBlockPointerType() const;
2022 bool isVoidPointerType() const;
2023 bool isReferenceType() const;
2024 bool isLValueReferenceType() const;
2025 bool isRValueReferenceType() const;
2026 bool isObjectPointerType() const;
2027 bool isFunctionPointerType() const;
2028 bool isFunctionReferenceType() const;
2029 bool isMemberPointerType() const;
2030 bool isMemberFunctionPointerType() const;
2031 bool isMemberDataPointerType() const;
2032 bool isArrayType() const;
2033 bool isConstantArrayType() const;
2034 bool isIncompleteArrayType() const;
2035 bool isVariableArrayType() const;
2036 bool isDependentSizedArrayType() const;
2037 bool isRecordType() const;
2038 bool isClassType() const;
2039 bool isStructureType() const;
2040 bool isObjCBoxableRecordType() const;
2041 bool isInterfaceType() const;
2042 bool isStructureOrClassType() const;
2043 bool isUnionType() const;
2044 bool isComplexIntegerType() const; // GCC _Complex integer type.
2045 bool isVectorType() const; // GCC vector type.
2046 bool isExtVectorType() const; // Extended vector type.
2047 bool isMatrixType() const; // Matrix type.
2048 bool isConstantMatrixType() const; // Constant matrix type.
2049 bool isDependentAddressSpaceType() const; // value-dependent address space qualifier
2050 bool isObjCObjectPointerType() const; // pointer to ObjC object
2051 bool isObjCRetainableType() const; // ObjC object or block pointer
2052 bool isObjCLifetimeType() const; // (array of)* retainable type
2053 bool isObjCIndirectLifetimeType() const; // (pointer to)* lifetime type
2054 bool isObjCNSObjectType() const; // __attribute__((NSObject))
2055 bool isObjCIndependentClassType() const; // __attribute__((objc_independent_class))
2056 // FIXME: change this to 'raw' interface type, so we can used 'interface' type
2057 // for the common case.
2058 bool isObjCObjectType() const; // NSString or typeof(*(id)0)
2059 bool isObjCQualifiedInterfaceType() const; // NSString<foo>
2060 bool isObjCQualifiedIdType() const; // id<foo>
2061 bool isObjCQualifiedClassType() const; // Class<foo>
2062 bool isObjCObjectOrInterfaceType() const;
2063 bool isObjCIdType() const; // id
2064 bool isDecltypeType() const;
2065 /// Was this type written with the special inert-in-ARC __unsafe_unretained
2066 /// qualifier?
2067 ///
2068 /// This approximates the answer to the following question: if this
2069 /// translation unit were compiled in ARC, would this type be qualified
2070 /// with __unsafe_unretained?
2071 bool isObjCInertUnsafeUnretainedType() const {
2072 return hasAttr(attr::ObjCInertUnsafeUnretained);
2073 }
2074
2075 /// Whether the type is Objective-C 'id' or a __kindof type of an
2076 /// object type, e.g., __kindof NSView * or __kindof id
2077 /// <NSCopying>.
2078 ///
2079 /// \param bound Will be set to the bound on non-id subtype types,
2080 /// which will be (possibly specialized) Objective-C class type, or
2081 /// null for 'id.
2082 bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
2083 const ObjCObjectType *&bound) const;
2084
2085 bool isObjCClassType() const; // Class
2086
2087 /// Whether the type is Objective-C 'Class' or a __kindof type of an
2088 /// Class type, e.g., __kindof Class <NSCopying>.
2089 ///
2090 /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
2091 /// here because Objective-C's type system cannot express "a class
2092 /// object for a subclass of NSFoo".
2093 bool isObjCClassOrClassKindOfType() const;
2094
2095 bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
2096 bool isObjCSelType() const; // Class
2097 bool isObjCBuiltinType() const; // 'id' or 'Class'
2098 bool isObjCARCBridgableType() const;
2099 bool isCARCBridgableType() const;
2100 bool isTemplateTypeParmType() const; // C++ template type parameter
2101 bool isNullPtrType() const; // C++11 std::nullptr_t
2102 bool isNothrowT() const; // C++ std::nothrow_t
2103 bool isAlignValT() const; // C++17 std::align_val_t
2104 bool isStdByteType() const; // C++17 std::byte
2105 bool isAtomicType() const; // C11 _Atomic()
2106 bool isUndeducedAutoType() const; // C++11 auto or
2107 // C++14 decltype(auto)
2108 bool isTypedefNameType() const; // typedef or alias template
2109
2110#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2111 bool is##Id##Type() const;
2112#include "clang/Basic/OpenCLImageTypes.def"
2113
2114 bool isImageType() const; // Any OpenCL image type
2115
2116 bool isSamplerT() const; // OpenCL sampler_t
2117 bool isEventT() const; // OpenCL event_t
2118 bool isClkEventT() const; // OpenCL clk_event_t
2119 bool isQueueT() const; // OpenCL queue_t
2120 bool isReserveIDT() const; // OpenCL reserve_id_t
2121
2122#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2123 bool is##Id##Type() const;
2124#include "clang/Basic/OpenCLExtensionTypes.def"
2125 // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
2126 bool isOCLIntelSubgroupAVCType() const;
2127 bool isOCLExtOpaqueType() const; // Any OpenCL extension type
2128
2129 bool isPipeType() const; // OpenCL pipe type
2130 bool isExtIntType() const; // Extended Int Type
2131 bool isOpenCLSpecificType() const; // Any OpenCL specific type
2132
2133 /// Determines if this type, which must satisfy
2134 /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
2135 /// than implicitly __strong.
2136 bool isObjCARCImplicitlyUnretainedType() const;
2137
2138 /// Check if the type is the CUDA device builtin surface type.
2139 bool isCUDADeviceBuiltinSurfaceType() const;
2140 /// Check if the type is the CUDA device builtin texture type.
2141 bool isCUDADeviceBuiltinTextureType() const;
2142
2143 /// Return the implicit lifetime for this type, which must not be dependent.
2144 Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;
2145
2146 enum ScalarTypeKind {
2147 STK_CPointer,
2148 STK_BlockPointer,
2149 STK_ObjCObjectPointer,
2150 STK_MemberPointer,
2151 STK_Bool,
2152 STK_Integral,
2153 STK_Floating,
2154 STK_IntegralComplex,
2155 STK_FloatingComplex,
2156 STK_FixedPoint
2157 };
2158
2159 /// Given that this is a scalar type, classify it.
2160 ScalarTypeKind getScalarTypeKind() const;
2161
2162 TypeDependence getDependence() const {
2163 return static_cast<TypeDependence>(TypeBits.Dependence);
2164 }
2165
2166 /// Whether this type is an error type.
2167 bool containsErrors() const {
2168 return getDependence() & TypeDependence::Error;
2169 }
2170
2171 /// Whether this type is a dependent type, meaning that its definition
2172 /// somehow depends on a template parameter (C++ [temp.dep.type]).
2173 bool isDependentType() const {
2174 return getDependence() & TypeDependence::Dependent;
2175 }
2176
2177 /// Determine whether this type is an instantiation-dependent type,
2178 /// meaning that the type involves a template parameter (even if the
2179 /// definition does not actually depend on the type substituted for that
2180 /// template parameter).
2181 bool isInstantiationDependentType() const {
2182 return getDependence() & TypeDependence::Instantiation;
2183 }
2184
2185 /// Determine whether this type is an undeduced type, meaning that
2186 /// it somehow involves a C++11 'auto' type or similar which has not yet been
2187 /// deduced.
2188 bool isUndeducedType() const;
2189
2190 /// Whether this type is a variably-modified type (C99 6.7.5).
2191 bool isVariablyModifiedType() const {
2192 return getDependence() & TypeDependence::VariablyModified;
2193 }
2194
2195 /// Whether this type involves a variable-length array type
2196 /// with a definite size.
2197 bool hasSizedVLAType() const;
2198
2199 /// Whether this type is or contains a local or unnamed type.
2200 bool hasUnnamedOrLocalType() const;
2201
2202 bool isOverloadableType() const;
2203
2204 /// Determine wither this type is a C++ elaborated-type-specifier.
2205 bool isElaboratedTypeSpecifier() const;
2206
2207 bool canDecayToPointerType() const;
2208
2209 /// Whether this type is represented natively as a pointer. This includes
2210 /// pointers, references, block pointers, and Objective-C interface,
2211 /// qualified id, and qualified interface types, as well as nullptr_t.
2212 bool hasPointerRepresentation() const;
2213
2214 /// Whether this type can represent an objective pointer type for the
2215 /// purpose of GC'ability
2216 bool hasObjCPointerRepresentation() const;
2217
2218 /// Determine whether this type has an integer representation
2219 /// of some sort, e.g., it is an integer type or a vector.
2220 bool hasIntegerRepresentation() const;
2221
2222 /// Determine whether this type has an signed integer representation
2223 /// of some sort, e.g., it is an signed integer type or a vector.
2224 bool hasSignedIntegerRepresentation() const;
2225
2226 /// Determine whether this type has an unsigned integer representation
2227 /// of some sort, e.g., it is an unsigned integer type or a vector.
2228 bool hasUnsignedIntegerRepresentation() const;
2229
2230 /// Determine whether this type has a floating-point representation
2231 /// of some sort, e.g., it is a floating-point type or a vector thereof.
2232 bool hasFloatingRepresentation() const;
2233
2234 // Type Checking Functions: Check to see if this type is structurally the
2235 // specified type, ignoring typedefs and qualifiers, and return a pointer to
2236 // the best type we can.
2237 const RecordType *getAsStructureType() const;
2238 /// NOTE: getAs*ArrayType are methods on ASTContext.
2239 const RecordType *getAsUnionType() const;
2240 const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
2241 const ObjCObjectType *getAsObjCInterfaceType() const;
2242
2243 // The following is a convenience method that returns an ObjCObjectPointerType
2244 // for object declared using an interface.
2245 const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
2246 const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
2247 const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
2248 const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;
2249
2250 /// Retrieves the CXXRecordDecl that this type refers to, either
2251 /// because the type is a RecordType or because it is the injected-class-name
2252 /// type of a class template or class template partial specialization.
2253 CXXRecordDecl *getAsCXXRecordDecl() const;
2254
2255 /// Retrieves the RecordDecl this type refers to.
2256 RecordDecl *getAsRecordDecl() const;
2257
2258 /// Retrieves the TagDecl that this type refers to, either
2259 /// because the type is a TagType or because it is the injected-class-name
2260 /// type of a class template or class template partial specialization.
2261 TagDecl *getAsTagDecl() const;
2262
2263 /// If this is a pointer or reference to a RecordType, return the
2264 /// CXXRecordDecl that the type refers to.
2265 ///
2266 /// If this is not a pointer or reference, or the type being pointed to does
2267 /// not refer to a CXXRecordDecl, returns NULL.
2268 const CXXRecordDecl *getPointeeCXXRecordDecl() const;
2269
2270 /// Get the DeducedType whose type will be deduced for a variable with
2271 /// an initializer of this type. This looks through declarators like pointer
2272 /// types, but not through decltype or typedefs.
2273 DeducedType *getContainedDeducedType() const;
2274
2275 /// Get the AutoType whose type will be deduced for a variable with
2276 /// an initializer of this type. This looks through declarators like pointer
2277 /// types, but not through decltype or typedefs.
2278 AutoType *getContainedAutoType() const {
2279 return dyn_cast_or_null<AutoType>(getContainedDeducedType());
2280 }
2281
2282 /// Determine whether this type was written with a leading 'auto'
2283 /// corresponding to a trailing return type (possibly for a nested
2284 /// function type within a pointer to function type or similar).
2285 bool hasAutoForTrailingReturnType() const;
2286
2287 /// Member-template getAs<specific type>'. Look through sugar for
2288 /// an instance of \<specific type>. This scheme will eventually
2289 /// replace the specific getAsXXXX methods above.
2290 ///
2291 /// There are some specializations of this member template listed
2292 /// immediately following this class.
2293 template <typename T> const T *getAs() const;
2294
2295 /// Member-template getAsAdjusted<specific type>. Look through specific kinds
2296 /// of sugar (parens, attributes, etc) for an instance of \<specific type>.
2297 /// This is used when you need to walk over sugar nodes that represent some
2298 /// kind of type adjustment from a type that was written as a \<specific type>
2299 /// to another type that is still canonically a \<specific type>.
2300 template <typename T> const T *getAsAdjusted() const;
2301
2302 /// A variant of getAs<> for array types which silently discards
2303 /// qualifiers from the outermost type.
2304 const ArrayType *getAsArrayTypeUnsafe() const;
2305
2306 /// Member-template castAs<specific type>. Look through sugar for
2307 /// the underlying instance of \<specific type>.
2308 ///
2309 /// This method has the same relationship to getAs<T> as cast<T> has
2310 /// to dyn_cast<T>; which is to say, the underlying type *must*
2311 /// have the intended type, and this method will never return null.
2312 template <typename T> const T *castAs() const;
2313
2314 /// A variant of castAs<> for array type which silently discards
2315 /// qualifiers from the outermost type.
2316 const ArrayType *castAsArrayTypeUnsafe() const;
2317
2318 /// Determine whether this type had the specified attribute applied to it
2319 /// (looking through top-level type sugar).
2320 bool hasAttr(attr::Kind AK) const;
2321
2322 /// Get the base element type of this type, potentially discarding type
2323 /// qualifiers. This should never be used when type qualifiers
2324 /// are meaningful.
2325 const Type *getBaseElementTypeUnsafe() const;
2326
2327 /// If this is an array type, return the element type of the array,
2328 /// potentially with type qualifiers missing.
2329 /// This should never be used when type qualifiers are meaningful.
2330 const Type *getArrayElementTypeNoTypeQual() const;
2331
2332 /// If this is a pointer type, return the pointee type.
2333 /// If this is an array type, return the array element type.
2334 /// This should never be used when type qualifiers are meaningful.
2335 const Type *getPointeeOrArrayElementType() const;
2336
2337 /// If this is a pointer, ObjC object pointer, or block
2338 /// pointer, this returns the respective pointee.
2339 QualType getPointeeType() const;
2340
2341 /// Return the specified type with any "sugar" removed from the type,
2342 /// removing any typedefs, typeofs, etc., as well as any qualifiers.
2343 const Type *getUnqualifiedDesugaredType() const;
2344
2345 /// More type predicates useful for type checking/promotion
2346 bool isPromotableIntegerType() const; // C99 6.3.1.1p2
2347
2348 /// Return true if this is an integer type that is
2349 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
2350 /// or an enum decl which has a signed representation.
2351 bool isSignedIntegerType() const;
2352
2353 /// Return true if this is an integer type that is
2354 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
2355 /// or an enum decl which has an unsigned representation.
2356 bool isUnsignedIntegerType() const;
2357
2358 /// Determines whether this is an integer type that is signed or an
2359 /// enumeration types whose underlying type is a signed integer type.
2360 bool isSignedIntegerOrEnumerationType() const;
2361
2362 /// Determines whether this is an integer type that is unsigned or an
2363 /// enumeration types whose underlying type is a unsigned integer type.
2364 bool isUnsignedIntegerOrEnumerationType() const;
2365
2366 /// Return true if this is a fixed point type according to
2367 /// ISO/IEC JTC1 SC22 WG14 N1169.
2368 bool isFixedPointType() const;
2369
2370 /// Return true if this is a fixed point or integer type.
2371 bool isFixedPointOrIntegerType() const;
2372
2373 /// Return true if this is a saturated fixed point type according to
2374 /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2375 bool isSaturatedFixedPointType() const;
2376
2377 /// Return true if this is a saturated fixed point type according to
2378 /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2379 bool isUnsaturatedFixedPointType() const;
2380
2381 /// Return true if this is a fixed point type that is signed according
2382 /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2383 bool isSignedFixedPointType() const;
2384
2385 /// Return true if this is a fixed point type that is unsigned according
2386 /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2387 bool isUnsignedFixedPointType() const;
2388
2389 /// Return true if this is not a variable sized type,
2390 /// according to the rules of C99 6.7.5p3. It is not legal to call this on
2391 /// incomplete types.
2392 bool isConstantSizeType() const;
2393
2394 /// Returns true if this type can be represented by some
2395 /// set of type specifiers.
2396 bool isSpecifierType() const;
2397
2398 /// Determine the linkage of this type.
2399 Linkage getLinkage() const;
2400
2401 /// Determine the visibility of this type.
2402 Visibility getVisibility() const {
2403 return getLinkageAndVisibility().getVisibility();
2404 }
2405
2406 /// Return true if the visibility was explicitly set is the code.
2407 bool isVisibilityExplicit() const {
2408 return getLinkageAndVisibility().isVisibilityExplicit();
2409 }
2410
2411 /// Determine the linkage and visibility of this type.
2412 LinkageInfo getLinkageAndVisibility() const;
2413
2414 /// True if the computed linkage is valid. Used for consistency
2415 /// checking. Should always return true.
2416 bool isLinkageValid() const;
2417
2418 /// Determine the nullability of the given type.
2419 ///
2420 /// Note that nullability is only captured as sugar within the type
2421 /// system, not as part of the canonical type, so nullability will
2422 /// be lost by canonicalization and desugaring.
2423 Optional<NullabilityKind> getNullability(const ASTContext &context) const;
2424
2425 /// Determine whether the given type can have a nullability
2426 /// specifier applied to it, i.e., if it is any kind of pointer type.
2427 ///
2428 /// \param ResultIfUnknown The value to return if we don't yet know whether
2429 /// this type can have nullability because it is dependent.
2430 bool canHaveNullability(bool ResultIfUnknown = true) const;
2431
2432 /// Retrieve the set of substitutions required when accessing a member
2433 /// of the Objective-C receiver type that is declared in the given context.
2434 ///
2435 /// \c *this is the type of the object we're operating on, e.g., the
2436 /// receiver for a message send or the base of a property access, and is
2437 /// expected to be of some object or object pointer type.
2438 ///
2439 /// \param dc The declaration context for which we are building up a
2440 /// substitution mapping, which should be an Objective-C class, extension,
2441 /// category, or method within.
2442 ///
2443 /// \returns an array of type arguments that can be substituted for
2444 /// the type parameters of the given declaration context in any type described
2445 /// within that context, or an empty optional to indicate that no
2446 /// substitution is required.
2447 Optional<ArrayRef<QualType>>
2448 getObjCSubstitutions(const DeclContext *dc) const;
2449
2450 /// Determines if this is an ObjC interface type that may accept type
2451 /// parameters.
2452 bool acceptsObjCTypeParams() const;
2453
2454 const char *getTypeClassName() const;
2455
2456 QualType getCanonicalTypeInternal() const {
2457 return CanonicalType;
2458 }
2459
2460 CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
2461 void dump() const;
2462 void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
2463};
2464
2465/// This will check for a TypedefType by removing any existing sugar
2466/// until it reaches a TypedefType or a non-sugared type.
2467template <> const TypedefType *Type::getAs() const;
2468
2469/// This will check for a TemplateSpecializationType by removing any
2470/// existing sugar until it reaches a TemplateSpecializationType or a
2471/// non-sugared type.
2472template <> const TemplateSpecializationType *Type::getAs() const;
2473
2474/// This will check for an AttributedType by removing any existing sugar
2475/// until it reaches an AttributedType or a non-sugared type.
2476template <> const AttributedType *Type::getAs() const;
2477
2478// We can do canonical leaf types faster, because we don't have to
2479// worry about preserving child type decoration.
2480#define TYPE(Class, Base)
2481#define LEAF_TYPE(Class) \
2482template <> inline const Class##Type *Type::getAs() const { \
2483 return dyn_cast<Class##Type>(CanonicalType); \
2484} \
2485template <> inline const Class##Type *Type::castAs() const { \
2486 return cast<Class##Type>(CanonicalType); \
2487}
2488#include "clang/AST/TypeNodes.inc"
2489
2490/// This class is used for builtin types like 'int'. Builtin
2491/// types are always canonical and have a literal name field.
2492class BuiltinType : public Type {
2493public:
2494 enum Kind {
2495// OpenCL image types
2496#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2497#include "clang/Basic/OpenCLImageTypes.def"
2498// OpenCL extension types
2499#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2500#include "clang/Basic/OpenCLExtensionTypes.def"
2501// SVE Types
2502#define SVE_TYPE(Name, Id, SingletonId) Id,
2503#include "clang/Basic/AArch64SVEACLETypes.def"
2504// PPC MMA Types
2505#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2506#include "clang/Basic/PPCTypes.def"
2507// RVV Types
2508#define RVV_TYPE(Name, Id, SingletonId) Id,
2509#include "clang/Basic/RISCVVTypes.def"
2510// All other builtin types
2511#define BUILTIN_TYPE(Id, SingletonId) Id,
2512#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2513#include "clang/AST/BuiltinTypes.def"
2514 };
2515
2516private:
2517 friend class ASTContext; // ASTContext creates these.
2518
2519 BuiltinType(Kind K)
2520 : Type(Builtin, QualType(),
2521 K == Dependent ? TypeDependence::DependentInstantiation
2522 : TypeDependence::None) {
2523 BuiltinTypeBits.Kind = K;
2524 }
2525
2526public:
2527 Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
2528 StringRef getName(const PrintingPolicy &Policy) const;
2529
2530 const char *getNameAsCString(const PrintingPolicy &Policy) const {
2531 // The StringRef is null-terminated.
2532 StringRef str = getName(Policy);
2533 assert(!str.empty() && str.data()[str.size()] == '\0')(static_cast <bool> (!str.empty() && str.data()
[str.size()] == '\0') ? void (0) : __assert_fail ("!str.empty() && str.data()[str.size()] == '\\0'"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 2533, __extension__ __PRETTY_FUNCTION__))
;
2534 return str.data();
2535 }
2536
2537 bool isSugared() const { return false; }
2538 QualType desugar() const { return QualType(this, 0); }
2539
2540 bool isInteger() const {
2541 return getKind() >= Bool && getKind() <= Int128;
2542 }
2543
2544 bool isSignedInteger() const {
2545 return getKind() >= Char_S && getKind() <= Int128;
2546 }
2547
2548 bool isUnsignedInteger() const {
2549 return getKind() >= Bool && getKind() <= UInt128;
2550 }
2551
2552 bool isFloatingPoint() const {
2553 return getKind() >= Half && getKind() <= Float128;
2554 }
2555
2556 /// Determines whether the given kind corresponds to a placeholder type.
2557 static bool isPlaceholderTypeKind(Kind K) {
2558 return K >= Overload;
2559 }
2560
2561 /// Determines whether this type is a placeholder type, i.e. a type
2562 /// which cannot appear in arbitrary positions in a fully-formed
2563 /// expression.
2564 bool isPlaceholderType() const {
2565 return isPlaceholderTypeKind(getKind());
2566 }
2567
2568 /// Determines whether this type is a placeholder type other than
2569 /// Overload. Most placeholder types require only syntactic
2570 /// information about their context in order to be resolved (e.g.
2571 /// whether it is a call expression), which means they can (and
2572 /// should) be resolved in an earlier "phase" of analysis.
2573 /// Overload expressions sometimes pick up further information
2574 /// from their context, like whether the context expects a
2575 /// specific function-pointer type, and so frequently need
2576 /// special treatment.
2577 bool isNonOverloadPlaceholderType() const {
2578 return getKind() > Overload;
2579 }
2580
2581 static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2582};
2583
2584/// Complex values, per C99 6.2.5p11. This supports the C99 complex
2585/// types (_Complex float etc) as well as the GCC integer complex extensions.
2586class ComplexType : public Type, public llvm::FoldingSetNode {
2587 friend class ASTContext; // ASTContext creates these.
2588
2589 QualType ElementType;
2590
2591 ComplexType(QualType Element, QualType CanonicalPtr)
2592 : Type(Complex, CanonicalPtr, Element->getDependence()),
2593 ElementType(Element) {}
2594
2595public:
2596 QualType getElementType() const { return ElementType; }
2597
2598 bool isSugared() const { return false; }
2599 QualType desugar() const { return QualType(this, 0); }
2600
2601 void Profile(llvm::FoldingSetNodeID &ID) {
2602 Profile(ID, getElementType());
2603 }
2604
2605 static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
2606 ID.AddPointer(Element.getAsOpaquePtr());
2607 }
2608
2609 static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2610};
2611
2612/// Sugar for parentheses used when specifying types.
2613class ParenType : public Type, public llvm::FoldingSetNode {
2614 friend class ASTContext; // ASTContext creates these.
2615
2616 QualType Inner;
2617
2618 ParenType(QualType InnerType, QualType CanonType)
2619 : Type(Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}
2620
2621public:
2622 QualType getInnerType() const { return Inner; }
2623
2624 bool isSugared() const { return true; }
2625 QualType desugar() const { return getInnerType(); }
2626
2627 void Profile(llvm::FoldingSetNodeID &ID) {
2628 Profile(ID, getInnerType());
2629 }
2630
2631 static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
2632 Inner.Profile(ID);
2633 }
2634
2635 static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2636};
2637
2638/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2639class PointerType : public Type, public llvm::FoldingSetNode {
2640 friend class ASTContext; // ASTContext creates these.
2641
2642 QualType PointeeType;
2643
2644 PointerType(QualType Pointee, QualType CanonicalPtr)
2645 : Type(Pointer, CanonicalPtr, Pointee->getDependence()),
2646 PointeeType(Pointee) {}
2647
2648public:
2649 QualType getPointeeType() const { return PointeeType; }
2650
2651 bool isSugared() const { return false; }
2652 QualType desugar() const { return QualType(this, 0); }
2653
2654 void Profile(llvm::FoldingSetNodeID &ID) {
2655 Profile(ID, getPointeeType());
2656 }
2657
2658 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2659 ID.AddPointer(Pointee.getAsOpaquePtr());
2660 }
2661
2662 static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2663};
2664
2665/// Represents a type which was implicitly adjusted by the semantic
2666/// engine for arbitrary reasons. For example, array and function types can
2667/// decay, and function types can have their calling conventions adjusted.
2668class AdjustedType : public Type, public llvm::FoldingSetNode {
2669 QualType OriginalTy;
2670 QualType AdjustedTy;
2671
2672protected:
2673 friend class ASTContext; // ASTContext creates these.
2674
2675 AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
2676 QualType CanonicalPtr)
2677 : Type(TC, CanonicalPtr, OriginalTy->getDependence()),
2678 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
2679
2680public:
2681 QualType getOriginalType() const { return OriginalTy; }
2682 QualType getAdjustedType() const { return AdjustedTy; }
2683
2684 bool isSugared() const { return true; }
2685 QualType desugar() const { return AdjustedTy; }
2686
2687 void Profile(llvm::FoldingSetNodeID &ID) {
2688 Profile(ID, OriginalTy, AdjustedTy);
2689 }
2690
2691 static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
2692 ID.AddPointer(Orig.getAsOpaquePtr());
2693 ID.AddPointer(New.getAsOpaquePtr());
2694 }
2695
2696 static bool classof(const Type *T) {
2697 return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
2698 }
2699};
2700
2701/// Represents a pointer type decayed from an array or function type.
2702class DecayedType : public AdjustedType {
2703 friend class ASTContext; // ASTContext creates these.
2704
2705 inline
2706 DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);
2707
2708public:
2709 QualType getDecayedType() const { return getAdjustedType(); }
2710
2711 inline QualType getPointeeType() const;
2712
2713 static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2714};
2715
2716/// Pointer to a block type.
2717/// This type is to represent types syntactically represented as
2718/// "void (^)(int)", etc. Pointee is required to always be a function type.
2719class BlockPointerType : public Type, public llvm::FoldingSetNode {
2720 friend class ASTContext; // ASTContext creates these.
2721
2722 // Block is some kind of pointer type
2723 QualType PointeeType;
2724
2725 BlockPointerType(QualType Pointee, QualType CanonicalCls)
2726 : Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
2727 PointeeType(Pointee) {}
2728
2729public:
2730 // Get the pointee type. Pointee is required to always be a function type.
2731 QualType getPointeeType() const { return PointeeType; }
2732
2733 bool isSugared() const { return false; }
2734 QualType desugar() const { return QualType(this, 0); }
2735
2736 void Profile(llvm::FoldingSetNodeID &ID) {
2737 Profile(ID, getPointeeType());
2738 }
2739
2740 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2741 ID.AddPointer(Pointee.getAsOpaquePtr());
2742 }
2743
2744 static bool classof(const Type *T) {
2745 return T->getTypeClass() == BlockPointer;
2746 }
2747};
2748
2749/// Base for LValueReferenceType and RValueReferenceType
2750class ReferenceType : public Type, public llvm::FoldingSetNode {
2751 QualType PointeeType;
2752
2753protected:
2754 ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
2755 bool SpelledAsLValue)
2756 : Type(tc, CanonicalRef, Referencee->getDependence()),
2757 PointeeType(Referencee) {
2758 ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
2759 ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
2760 }
2761
2762public:
2763 bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
2764 bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }
2765
2766 QualType getPointeeTypeAsWritten() const { return PointeeType; }
2767
2768 QualType getPointeeType() const {
2769 // FIXME: this might strip inner qualifiers; okay?
2770 const ReferenceType *T = this;
2771 while (T->isInnerRef())
2772 T = T->PointeeType->castAs<ReferenceType>();
2773 return T->PointeeType;
2774 }
2775
2776 void Profile(llvm::FoldingSetNodeID &ID) {
2777 Profile(ID, PointeeType, isSpelledAsLValue());
2778 }
2779
2780 static void Profile(llvm::FoldingSetNodeID &ID,
2781 QualType Referencee,
2782 bool SpelledAsLValue) {
2783 ID.AddPointer(Referencee.getAsOpaquePtr());
2784 ID.AddBoolean(SpelledAsLValue);
2785 }
2786
2787 static bool classof(const Type *T) {
2788 return T->getTypeClass() == LValueReference ||
2789 T->getTypeClass() == RValueReference;
2790 }
2791};
2792
2793/// An lvalue reference type, per C++11 [dcl.ref].
2794class LValueReferenceType : public ReferenceType {
2795 friend class ASTContext; // ASTContext creates these
2796
2797 LValueReferenceType(QualType Referencee, QualType CanonicalRef,
2798 bool SpelledAsLValue)
2799 : ReferenceType(LValueReference, Referencee, CanonicalRef,
2800 SpelledAsLValue) {}
2801
2802public:
2803 bool isSugared() const { return false; }
2804 QualType desugar() const { return QualType(this, 0); }
2805
2806 static bool classof(const Type *T) {
2807 return T->getTypeClass() == LValueReference;
2808 }
2809};
2810
2811/// An rvalue reference type, per C++11 [dcl.ref].
2812class RValueReferenceType : public ReferenceType {
2813 friend class ASTContext; // ASTContext creates these
2814
2815 RValueReferenceType(QualType Referencee, QualType CanonicalRef)
2816 : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}
2817
2818public:
2819 bool isSugared() const { return false; }
2820 QualType desugar() const { return QualType(this, 0); }
2821
2822 static bool classof(const Type *T) {
2823 return T->getTypeClass() == RValueReference;
2824 }
2825};
2826
2827/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2828///
2829/// This includes both pointers to data members and pointer to member functions.
2830class MemberPointerType : public Type, public llvm::FoldingSetNode {
2831 friend class ASTContext; // ASTContext creates these.
2832
2833 QualType PointeeType;
2834
2835 /// The class of which the pointee is a member. Must ultimately be a
2836 /// RecordType, but could be a typedef or a template parameter too.
2837 const Type *Class;
2838
2839 MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
2840 : Type(MemberPointer, CanonicalPtr,
2841 (Cls->getDependence() & ~TypeDependence::VariablyModified) |
2842 Pointee->getDependence()),
2843 PointeeType(Pointee), Class(Cls) {}
2844
2845public:
2846 QualType getPointeeType() const { return PointeeType; }
2847
2848 /// Returns true if the member type (i.e. the pointee type) is a
2849 /// function type rather than a data-member type.
2850 bool isMemberFunctionPointer() const {
2851 return PointeeType->isFunctionProtoType();
2852 }
2853
2854 /// Returns true if the member type (i.e. the pointee type) is a
2855 /// data type rather than a function type.
2856 bool isMemberDataPointer() const {
2857 return !PointeeType->isFunctionProtoType();
2858 }
2859
2860 const Type *getClass() const { return Class; }
2861 CXXRecordDecl *getMostRecentCXXRecordDecl() const;
2862
2863 bool isSugared() const { return false; }
2864 QualType desugar() const { return QualType(this, 0); }
2865
2866 void Profile(llvm::FoldingSetNodeID &ID) {
2867 Profile(ID, getPointeeType(), getClass());
2868 }
2869
2870 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
2871 const Type *Class) {
2872 ID.AddPointer(Pointee.getAsOpaquePtr());
2873 ID.AddPointer(Class);
2874 }
2875
2876 static bool classof(const Type *T) {
2877 return T->getTypeClass() == MemberPointer;
2878 }
2879};
2880
2881/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2882class ArrayType : public Type, public llvm::FoldingSetNode {
2883public:
2884 /// Capture whether this is a normal array (e.g. int X[4])
2885 /// an array with a static size (e.g. int X[static 4]), or an array
2886 /// with a star size (e.g. int X[*]).
2887 /// 'static' is only allowed on function parameters.
2888 enum ArraySizeModifier {
2889 Normal, Static, Star
2890 };
2891
2892private:
2893 /// The element type of the array.
2894 QualType ElementType;
2895
2896protected:
2897 friend class ASTContext; // ASTContext creates these.
2898
2899 ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
2900 unsigned tq, const Expr *sz = nullptr);
2901
2902public:
2903 QualType getElementType() const { return ElementType; }
2904
2905 ArraySizeModifier getSizeModifier() const {
2906 return ArraySizeModifier(ArrayTypeBits.SizeModifier);
2907 }
2908
2909 Qualifiers getIndexTypeQualifiers() const {
2910 return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
2911 }
2912
2913 unsigned getIndexTypeCVRQualifiers() const {
2914 return ArrayTypeBits.IndexTypeQuals;
2915 }
2916
2917 static bool classof(const Type *T) {
2918 return T->getTypeClass() == ConstantArray ||
2919 T->getTypeClass() == VariableArray ||
2920 T->getTypeClass() == IncompleteArray ||
2921 T->getTypeClass() == DependentSizedArray;
2922 }
2923};
2924
2925/// Represents the canonical version of C arrays with a specified constant size.
2926/// For example, the canonical type for 'int A[4 + 4*100]' is a
2927/// ConstantArrayType where the element type is 'int' and the size is 404.
2928class ConstantArrayType final
2929 : public ArrayType,
2930 private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
2931 friend class ASTContext; // ASTContext creates these.
2932 friend TrailingObjects;
2933
2934 llvm::APInt Size; // Allows us to unique the type.
2935
2936 ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
2937 const Expr *sz, ArraySizeModifier sm, unsigned tq)
2938 : ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
2939 ConstantArrayTypeBits.HasStoredSizeExpr = sz != nullptr;
2940 if (ConstantArrayTypeBits.HasStoredSizeExpr) {
2941 assert(!can.isNull() && "canonical constant array should not have size")(static_cast <bool> (!can.isNull() && "canonical constant array should not have size"
) ? void (0) : __assert_fail ("!can.isNull() && \"canonical constant array should not have size\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 2941, __extension__ __PRETTY_FUNCTION__))
;
2942 *getTrailingObjects<const Expr*>() = sz;
2943 }
2944 }
2945
2946 unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
2947 return ConstantArrayTypeBits.HasStoredSizeExpr;
2948 }
2949
2950public:
2951 const llvm::APInt &getSize() const { return Size; }
2952 const Expr *getSizeExpr() const {
2953 return ConstantArrayTypeBits.HasStoredSizeExpr
2954 ? *getTrailingObjects<const Expr *>()
2955 : nullptr;
2956 }
2957 bool isSugared() const { return false; }
2958 QualType desugar() const { return QualType(this, 0); }
2959
2960 /// Determine the number of bits required to address a member of
2961 // an array with the given element type and number of elements.
2962 static unsigned getNumAddressingBits(const ASTContext &Context,
2963 QualType ElementType,
2964 const llvm::APInt &NumElements);
2965
2966 /// Determine the maximum number of active bits that an array's size
2967 /// can require, which limits the maximum size of the array.
2968 static unsigned getMaxSizeBits(const ASTContext &Context);
2969
2970 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
2971 Profile(ID, Ctx, getElementType(), getSize(), getSizeExpr(),
2972 getSizeModifier(), getIndexTypeCVRQualifiers());
2973 }
2974
2975 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
2976 QualType ET, const llvm::APInt &ArraySize,
2977 const Expr *SizeExpr, ArraySizeModifier SizeMod,
2978 unsigned TypeQuals);
2979
2980 static bool classof(const Type *T) {
2981 return T->getTypeClass() == ConstantArray;
2982 }
2983};
2984
2985/// Represents a C array with an unspecified size. For example 'int A[]' has
2986/// an IncompleteArrayType where the element type is 'int' and the size is
2987/// unspecified.
2988class IncompleteArrayType : public ArrayType {
2989 friend class ASTContext; // ASTContext creates these.
2990
2991 IncompleteArrayType(QualType et, QualType can,
2992 ArraySizeModifier sm, unsigned tq)
2993 : ArrayType(IncompleteArray, et, can, sm, tq) {}
2994
2995public:
2996 friend class StmtIteratorBase;
2997
2998 bool isSugared() const { return false; }
2999 QualType desugar() const { return QualType(this, 0); }
3000
3001 static bool classof(const Type *T) {
3002 return T->getTypeClass() == IncompleteArray;
3003 }
3004
3005 void Profile(llvm::FoldingSetNodeID &ID) {
3006 Profile(ID, getElementType(), getSizeModifier(),
3007 getIndexTypeCVRQualifiers());
3008 }
3009
3010 static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
3011 ArraySizeModifier SizeMod, unsigned TypeQuals) {
3012 ID.AddPointer(ET.getAsOpaquePtr());
3013 ID.AddInteger(SizeMod);
3014 ID.AddInteger(TypeQuals);
3015 }
3016};
3017
3018/// Represents a C array with a specified size that is not an
3019/// integer-constant-expression. For example, 'int s[x+foo()]'.
3020/// Since the size expression is an arbitrary expression, we store it as such.
3021///
3022/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3023/// should not be: two lexically equivalent variable array types could mean
3024/// different things, for example, these variables do not have the same type
3025/// dynamically:
3026///
3027/// void foo(int x) {
3028/// int Y[x];
3029/// ++x;
3030/// int Z[x];
3031/// }
3032class VariableArrayType : public ArrayType {
3033 friend class ASTContext; // ASTContext creates these.
3034
3035 /// An assignment-expression. VLA's are only permitted within
3036 /// a function block.
3037 Stmt *SizeExpr;
3038
3039 /// The range spanned by the left and right array brackets.
3040 SourceRange Brackets;
3041
3042 VariableArrayType(QualType et, QualType can, Expr *e,
3043 ArraySizeModifier sm, unsigned tq,
3044 SourceRange brackets)
3045 : ArrayType(VariableArray, et, can, sm, tq, e),
3046 SizeExpr((Stmt*) e), Brackets(brackets) {}
3047
3048public:
3049 friend class StmtIteratorBase;
3050
3051 Expr *getSizeExpr() const {
3052 // We use C-style casts instead of cast<> here because we do not wish
3053 // to have a dependency of Type.h on Stmt.h/Expr.h.
3054 return (Expr*) SizeExpr;
3055 }
3056
3057 SourceRange getBracketsRange() const { return Brackets; }
3058 SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
3059 SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
3060
3061 bool isSugared() const { return false; }
3062 QualType desugar() const { return QualType(this, 0); }
3063
3064 static bool classof(const Type *T) {
3065 return T->getTypeClass() == VariableArray;
3066 }
3067
3068 void Profile(llvm::FoldingSetNodeID &ID) {
3069 llvm_unreachable("Cannot unique VariableArrayTypes.")::llvm::llvm_unreachable_internal("Cannot unique VariableArrayTypes."
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 3069)
;
3070 }
3071};
3072
3073/// Represents an array type in C++ whose size is a value-dependent expression.
3074///
3075/// For example:
3076/// \code
3077/// template<typename T, int Size>
3078/// class array {
3079/// T data[Size];
3080/// };
3081/// \endcode
3082///
3083/// For these types, we won't actually know what the array bound is
3084/// until template instantiation occurs, at which point this will
3085/// become either a ConstantArrayType or a VariableArrayType.
3086class DependentSizedArrayType : public ArrayType {
3087 friend class ASTContext; // ASTContext creates these.
3088
3089 const ASTContext &Context;
3090
3091 /// An assignment expression that will instantiate to the
3092 /// size of the array.
3093 ///
3094 /// The expression itself might be null, in which case the array
3095 /// type will have its size deduced from an initializer.
3096 Stmt *SizeExpr;
3097
3098 /// The range spanned by the left and right array brackets.
3099 SourceRange Brackets;
3100
3101 DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
3102 Expr *e, ArraySizeModifier sm, unsigned tq,
3103 SourceRange brackets);
3104
3105public:
3106 friend class StmtIteratorBase;
3107
3108 Expr *getSizeExpr() const {
3109 // We use C-style casts instead of cast<> here because we do not wish
3110 // to have a dependency of Type.h on Stmt.h/Expr.h.
3111 return (Expr*) SizeExpr;
3112 }
3113
3114 SourceRange getBracketsRange() const { return Brackets; }
3115 SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
3116 SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
3117
3118 bool isSugared() const { return false; }
3119 QualType desugar() const { return QualType(this, 0); }
3120
3121 static bool classof(const Type *T) {
3122 return T->getTypeClass() == DependentSizedArray;
3123 }
3124
3125 void Profile(llvm::FoldingSetNodeID &ID) {
3126 Profile(ID, Context, getElementType(),
3127 getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
3128 }
3129
3130 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3131 QualType ET, ArraySizeModifier SizeMod,
3132 unsigned TypeQuals, Expr *E);
3133};
3134
3135/// Represents an extended address space qualifier where the input address space
3136/// value is dependent. Non-dependent address spaces are not represented with a
3137/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3138///
3139/// For example:
3140/// \code
3141/// template<typename T, int AddrSpace>
3142/// class AddressSpace {
3143/// typedef T __attribute__((address_space(AddrSpace))) type;
3144/// }
3145/// \endcode
3146class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
3147 friend class ASTContext;
3148
3149 const ASTContext &Context;
3150 Expr *AddrSpaceExpr;
3151 QualType PointeeType;
3152 SourceLocation loc;
3153
3154 DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
3155 QualType can, Expr *AddrSpaceExpr,
3156 SourceLocation loc);
3157
3158public:
3159 Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
3160 QualType getPointeeType() const { return PointeeType; }
3161 SourceLocation getAttributeLoc() const { return loc; }
3162
3163 bool isSugared() const { return false; }
3164 QualType desugar() const { return QualType(this, 0); }
3165
3166 static bool classof(const Type *T) {
3167 return T->getTypeClass() == DependentAddressSpace;
3168 }
3169
3170 void Profile(llvm::FoldingSetNodeID &ID) {
3171 Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
3172 }
3173
3174 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3175 QualType PointeeType, Expr *AddrSpaceExpr);
3176};
3177
3178/// Represents an extended vector type where either the type or size is
3179/// dependent.
3180///
3181/// For example:
3182/// \code
3183/// template<typename T, int Size>
3184/// class vector {
3185/// typedef T __attribute__((ext_vector_type(Size))) type;
3186/// }
3187/// \endcode
3188class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
3189 friend class ASTContext;
3190
3191 const ASTContext &Context;
3192 Expr *SizeExpr;
3193
3194 /// The element type of the array.
3195 QualType ElementType;
3196
3197 SourceLocation loc;
3198
3199 DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
3200 QualType can, Expr *SizeExpr, SourceLocation loc);
3201
3202public:
3203 Expr *getSizeExpr() const { return SizeExpr; }
3204 QualType getElementType() const { return ElementType; }
3205 SourceLocation getAttributeLoc() const { return loc; }
3206
3207 bool isSugared() const { return false; }
3208 QualType desugar() const { return QualType(this, 0); }
3209
3210 static bool classof(const Type *T) {
3211 return T->getTypeClass() == DependentSizedExtVector;
3212 }
3213
3214 void Profile(llvm::FoldingSetNodeID &ID) {
3215 Profile(ID, Context, getElementType(), getSizeExpr());
3216 }
3217
3218 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3219 QualType ElementType, Expr *SizeExpr);
3220};
3221
3222
3223/// Represents a GCC generic vector type. This type is created using
3224/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3225/// bytes; or from an Altivec __vector or vector declaration.
3226/// Since the constructor takes the number of vector elements, the
3227/// client is responsible for converting the size into the number of elements.
3228class VectorType : public Type, public llvm::FoldingSetNode {
3229public:
3230 enum VectorKind {
3231 /// not a target-specific vector type
3232 GenericVector,
3233
3234 /// is AltiVec vector
3235 AltiVecVector,
3236
3237 /// is AltiVec 'vector Pixel'
3238 AltiVecPixel,
3239
3240 /// is AltiVec 'vector bool ...'
3241 AltiVecBool,
3242
3243 /// is ARM Neon vector
3244 NeonVector,
3245
3246 /// is ARM Neon polynomial vector
3247 NeonPolyVector,
3248
3249 /// is AArch64 SVE fixed-length data vector
3250 SveFixedLengthDataVector,
3251
3252 /// is AArch64 SVE fixed-length predicate vector
3253 SveFixedLengthPredicateVector
3254 };
3255
3256protected:
3257 friend class ASTContext; // ASTContext creates these.
3258
3259 /// The element type of the vector.
3260 QualType ElementType;
3261
3262 VectorType(QualType vecType, unsigned nElements, QualType canonType,
3263 VectorKind vecKind);
3264
3265 VectorType(TypeClass tc, QualType vecType, unsigned nElements,
3266 QualType canonType, VectorKind vecKind);
3267
3268public:
3269 QualType getElementType() const { return ElementType; }
3270 unsigned getNumElements() const { return VectorTypeBits.NumElements; }
3271
3272 bool isSugared() const { return false; }
3273 QualType desugar() const { return QualType(this, 0); }
3274
3275 VectorKind getVectorKind() const {
3276 return VectorKind(VectorTypeBits.VecKind);
3277 }
3278
3279 void Profile(llvm::FoldingSetNodeID &ID) {
3280 Profile(ID, getElementType(), getNumElements(),
3281 getTypeClass(), getVectorKind());
3282 }
3283
3284 static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
3285 unsigned NumElements, TypeClass TypeClass,
3286 VectorKind VecKind) {
3287 ID.AddPointer(ElementType.getAsOpaquePtr());
3288 ID.AddInteger(NumElements);
3289 ID.AddInteger(TypeClass);
3290 ID.AddInteger(VecKind);
3291 }
3292
3293 static bool classof(const Type *T) {
3294 return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
3295 }
3296};
3297
3298/// Represents a vector type where either the type or size is dependent.
3299////
3300/// For example:
3301/// \code
3302/// template<typename T, int Size>
3303/// class vector {
3304/// typedef T __attribute__((vector_size(Size))) type;
3305/// }
3306/// \endcode
3307class DependentVectorType : public Type, public llvm::FoldingSetNode {
3308 friend class ASTContext;
3309
3310 const ASTContext &Context;
3311 QualType ElementType;
3312 Expr *SizeExpr;
3313 SourceLocation Loc;
3314
3315 DependentVectorType(const ASTContext &Context, QualType ElementType,
3316 QualType CanonType, Expr *SizeExpr,
3317 SourceLocation Loc, VectorType::VectorKind vecKind);
3318
3319public:
3320 Expr *getSizeExpr() const { return SizeExpr; }
3321 QualType getElementType() const { return ElementType; }
3322 SourceLocation getAttributeLoc() const { return Loc; }
3323 VectorType::VectorKind getVectorKind() const {
3324 return VectorType::VectorKind(VectorTypeBits.VecKind);
3325 }
3326
3327 bool isSugared() const { return false; }
3328 QualType desugar() const { return QualType(this, 0); }
3329
3330 static bool classof(const Type *T) {
3331 return T->getTypeClass() == DependentVector;
3332 }
3333
3334 void Profile(llvm::FoldingSetNodeID &ID) {
3335 Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
3336 }
3337
3338 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3339 QualType ElementType, const Expr *SizeExpr,
3340 VectorType::VectorKind VecKind);
3341};
3342
3343/// ExtVectorType - Extended vector type. This type is created using
3344/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3345/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3346/// class enables syntactic extensions, like Vector Components for accessing
3347/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3348/// Shading Language).
3349class ExtVectorType : public VectorType {
3350 friend class ASTContext; // ASTContext creates these.
3351
3352 ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
3353 : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}
3354
3355public:
3356 static int getPointAccessorIdx(char c) {
3357 switch (c) {
3358 default: return -1;
3359 case 'x': case 'r': return 0;
3360 case 'y': case 'g': return 1;
3361 case 'z': case 'b': return 2;
3362 case 'w': case 'a': return 3;
3363 }
3364 }
3365
3366 static int getNumericAccessorIdx(char c) {
3367 switch (c) {
3368 default: return -1;
3369 case '0': return 0;
3370 case '1': return 1;
3371 case '2': return 2;
3372 case '3': return 3;
3373 case '4': return 4;
3374 case '5': return 5;
3375 case '6': return 6;
3376 case '7': return 7;
3377 case '8': return 8;
3378 case '9': return 9;
3379 case 'A':
3380 case 'a': return 10;
3381 case 'B':
3382 case 'b': return 11;
3383 case 'C':
3384 case 'c': return 12;
3385 case 'D':
3386 case 'd': return 13;
3387 case 'E':
3388 case 'e': return 14;
3389 case 'F':
3390 case 'f': return 15;
3391 }
3392 }
3393
3394 static int getAccessorIdx(char c, bool isNumericAccessor) {
3395 if (isNumericAccessor)
3396 return getNumericAccessorIdx(c);
3397 else
3398 return getPointAccessorIdx(c);
3399 }
3400
3401 bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
3402 if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
3403 return unsigned(idx-1) < getNumElements();
3404 return false;
3405 }
3406
3407 bool isSugared() const { return false; }
3408 QualType desugar() const { return QualType(this, 0); }
3409
3410 static bool classof(const Type *T) {
3411 return T->getTypeClass() == ExtVector;
3412 }
3413};
3414
3415/// Represents a matrix type, as defined in the Matrix Types clang extensions.
3416/// __attribute__((matrix_type(rows, columns))), where "rows" specifies
3417/// number of rows and "columns" specifies the number of columns.
3418class MatrixType : public Type, public llvm::FoldingSetNode {
3419protected:
3420 friend class ASTContext;
3421
3422 /// The element type of the matrix.
3423 QualType ElementType;
3424
3425 MatrixType(QualType ElementTy, QualType CanonElementTy);
3426
3427 MatrixType(TypeClass TypeClass, QualType ElementTy, QualType CanonElementTy,
3428 const Expr *RowExpr = nullptr, const Expr *ColumnExpr = nullptr);
3429
3430public:
3431 /// Returns type of the elements being stored in the matrix
3432 QualType getElementType() const { return ElementType; }
3433
3434 /// Valid elements types are the following:
3435 /// * an integer type (as in C2x 6.2.5p19), but excluding enumerated types
3436 /// and _Bool
3437 /// * the standard floating types float or double
3438 /// * a half-precision floating point type, if one is supported on the target
3439 static bool isValidElementType(QualType T) {
3440 return T->isDependentType() ||
3441 (T->isRealType() && !T->isBooleanType() && !T->isEnumeralType());
3442 }
3443
3444 bool isSugared() const { return false; }
3445 QualType desugar() const { return QualType(this, 0); }
3446
3447 static bool classof(const Type *T) {
3448 return T->getTypeClass() == ConstantMatrix ||
3449 T->getTypeClass() == DependentSizedMatrix;
3450 }
3451};
3452
3453/// Represents a concrete matrix type with constant number of rows and columns
3454class ConstantMatrixType final : public MatrixType {
3455protected:
3456 friend class ASTContext;
3457
3458 /// Number of rows and columns.
3459 unsigned NumRows;
3460 unsigned NumColumns;
3461
3462 static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;
3463
3464 ConstantMatrixType(QualType MatrixElementType, unsigned NRows,
3465 unsigned NColumns, QualType CanonElementType);
3466
3467 ConstantMatrixType(TypeClass typeClass, QualType MatrixType, unsigned NRows,
3468 unsigned NColumns, QualType CanonElementType);
3469
3470public:
3471 /// Returns the number of rows in the matrix.
3472 unsigned getNumRows() const { return NumRows; }
3473
3474 /// Returns the number of columns in the matrix.
3475 unsigned getNumColumns() const { return NumColumns; }
3476
3477 /// Returns the number of elements required to embed the matrix into a vector.
3478 unsigned getNumElementsFlattened() const {
3479 return getNumRows() * getNumColumns();
3480 }
3481
3482 /// Returns true if \p NumElements is a valid matrix dimension.
3483 static constexpr bool isDimensionValid(size_t NumElements) {
3484 return NumElements > 0 && NumElements <= MaxElementsPerDimension;
3485 }
3486
3487 /// Returns the maximum number of elements per dimension.
3488 static constexpr unsigned getMaxElementsPerDimension() {
3489 return MaxElementsPerDimension;
3490 }
3491
3492 void Profile(llvm::FoldingSetNodeID &ID) {
3493 Profile(ID, getElementType(), getNumRows(), getNumColumns(),
3494 getTypeClass());
3495 }
3496
3497 static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
3498 unsigned NumRows, unsigned NumColumns,
3499 TypeClass TypeClass) {
3500 ID.AddPointer(ElementType.getAsOpaquePtr());
3501 ID.AddInteger(NumRows);
3502 ID.AddInteger(NumColumns);
3503 ID.AddInteger(TypeClass);
3504 }
3505
3506 static bool classof(const Type *T) {
3507 return T->getTypeClass() == ConstantMatrix;
3508 }
3509};
3510
3511/// Represents a matrix type where the type and the number of rows and columns
3512/// is dependent on a template.
3513class DependentSizedMatrixType final : public MatrixType {
3514 friend class ASTContext;
3515
3516 const ASTContext &Context;
3517 Expr *RowExpr;
3518 Expr *ColumnExpr;
3519
3520 SourceLocation loc;
3521
3522 DependentSizedMatrixType(const ASTContext &Context, QualType ElementType,
3523 QualType CanonicalType, Expr *RowExpr,
3524 Expr *ColumnExpr, SourceLocation loc);
3525
3526public:
3527 QualType getElementType() const { return ElementType; }
3528 Expr *getRowExpr() const { return RowExpr; }
3529 Expr *getColumnExpr() const { return ColumnExpr; }
3530 SourceLocation getAttributeLoc() const { return loc; }
3531
3532 bool isSugared() const { return false; }
3533 QualType desugar() const { return QualType(this, 0); }
3534
3535 static bool classof(const Type *T) {
3536 return T->getTypeClass() == DependentSizedMatrix;
3537 }
3538
3539 void Profile(llvm::FoldingSetNodeID &ID) {
3540 Profile(ID, Context, getElementType(), getRowExpr(), getColumnExpr());
3541 }
3542
3543 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3544 QualType ElementType, Expr *RowExpr, Expr *ColumnExpr);
3545};
3546
3547/// FunctionType - C99 6.7.5.3 - Function Declarators. This is the common base
3548/// class of FunctionNoProtoType and FunctionProtoType.
3549class FunctionType : public Type {
3550 // The type returned by the function.
3551 QualType ResultType;
3552
3553public:
3554 /// Interesting information about a specific parameter that can't simply
3555 /// be reflected in parameter's type. This is only used by FunctionProtoType
3556 /// but is in FunctionType to make this class available during the
3557 /// specification of the bases of FunctionProtoType.
3558 ///
3559 /// It makes sense to model language features this way when there's some
3560 /// sort of parameter-specific override (such as an attribute) that
3561 /// affects how the function is called. For example, the ARC ns_consumed
3562 /// attribute changes whether a parameter is passed at +0 (the default)
3563 /// or +1 (ns_consumed). This must be reflected in the function type,
3564 /// but isn't really a change to the parameter type.
3565 ///
3566 /// One serious disadvantage of modelling language features this way is
3567 /// that they generally do not work with language features that attempt
3568 /// to destructure types. For example, template argument deduction will
3569 /// not be able to match a parameter declared as
3570 /// T (*)(U)
3571 /// against an argument of type
3572 /// void (*)(__attribute__((ns_consumed)) id)
3573 /// because the substitution of T=void, U=id into the former will
3574 /// not produce the latter.
3575 class ExtParameterInfo {
3576 enum {
3577 ABIMask = 0x0F,
3578 IsConsumed = 0x10,
3579 HasPassObjSize = 0x20,
3580 IsNoEscape = 0x40,
3581 };
3582 unsigned char Data = 0;
3583
3584 public:
3585 ExtParameterInfo() = default;
3586
3587 /// Return the ABI treatment of this parameter.
3588 ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
3589 ExtParameterInfo withABI(ParameterABI kind) const {
3590 ExtParameterInfo copy = *this;
3591 copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
3592 return copy;
3593 }
3594
3595 /// Is this parameter considered "consumed" by Objective-C ARC?
3596 /// Consumed parameters must have retainable object type.
3597 bool isConsumed() const { return (Data & IsConsumed); }
3598 ExtParameterInfo withIsConsumed(bool consumed) const {
3599 ExtParameterInfo copy = *this;
3600 if (consumed)
3601 copy.Data |= IsConsumed;
3602 else
3603 copy.Data &= ~IsConsumed;
3604 return copy;
3605 }
3606
3607 bool hasPassObjectSize() const { return Data & HasPassObjSize; }
3608 ExtParameterInfo withHasPassObjectSize() const {
3609 ExtParameterInfo Copy = *this;
3610 Copy.Data |= HasPassObjSize;
3611 return Copy;
3612 }
3613
3614 bool isNoEscape() const { return Data & IsNoEscape; }
3615 ExtParameterInfo withIsNoEscape(bool NoEscape) const {
3616 ExtParameterInfo Copy = *this;
3617 if (NoEscape)
3618 Copy.Data |= IsNoEscape;
3619 else
3620 Copy.Data &= ~IsNoEscape;
3621 return Copy;
3622 }
3623
3624 unsigned char getOpaqueValue() const { return Data; }
3625 static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
3626 ExtParameterInfo result;
3627 result.Data = data;
3628 return result;
3629 }
3630
3631 friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
3632 return lhs.Data == rhs.Data;
3633 }
3634
3635 friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
3636 return lhs.Data != rhs.Data;
3637 }
3638 };
3639
3640 /// A class which abstracts out some details necessary for
3641 /// making a call.
3642 ///
3643 /// It is not actually used directly for storing this information in
3644 /// a FunctionType, although FunctionType does currently use the
3645 /// same bit-pattern.
3646 ///
3647 // If you add a field (say Foo), other than the obvious places (both,
3648 // constructors, compile failures), what you need to update is
3649 // * Operator==
3650 // * getFoo
3651 // * withFoo
3652 // * functionType. Add Foo, getFoo.
3653 // * ASTContext::getFooType
3654 // * ASTContext::mergeFunctionTypes
3655 // * FunctionNoProtoType::Profile
3656 // * FunctionProtoType::Profile
3657 // * TypePrinter::PrintFunctionProto
3658 // * AST read and write
3659 // * Codegen
3660 class ExtInfo {
3661 friend class FunctionType;
3662
3663 // Feel free to rearrange or add bits, but if you go over 16, you'll need to
3664 // adjust the Bits field below, and if you add bits, you'll need to adjust
3665 // Type::FunctionTypeBitfields::ExtInfo as well.
3666
3667 // | CC |noreturn|produces|nocallersavedregs|regparm|nocfcheck|cmsenscall|
3668 // |0 .. 4| 5 | 6 | 7 |8 .. 10| 11 | 12 |
3669 //
3670 // regparm is either 0 (no regparm attribute) or the regparm value+1.
3671 enum { CallConvMask = 0x1F };
3672 enum { NoReturnMask = 0x20 };
3673 enum { ProducesResultMask = 0x40 };
3674 enum { NoCallerSavedRegsMask = 0x80 };
3675 enum {
3676 RegParmMask = 0x700,
3677 RegParmOffset = 8
3678 };
3679 enum { NoCfCheckMask = 0x800 };
3680 enum { CmseNSCallMask = 0x1000 };
3681 uint16_t Bits = CC_C;
3682
3683 ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
3684
3685 public:
3686 // Constructor with no defaults. Use this when you know that you
3687 // have all the elements (when reading an AST file for example).
3688 ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
3689 bool producesResult, bool noCallerSavedRegs, bool NoCfCheck,
3690 bool cmseNSCall) {
3691 assert((!hasRegParm || regParm < 7) && "Invalid regparm value")(static_cast <bool> ((!hasRegParm || regParm < 7) &&
"Invalid regparm value") ? void (0) : __assert_fail ("(!hasRegParm || regParm < 7) && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 3691, __extension__ __PRETTY_FUNCTION__))
;
3692 Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
3693 (producesResult ? ProducesResultMask : 0) |
3694 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
3695 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
3696 (NoCfCheck ? NoCfCheckMask : 0) |
3697 (cmseNSCall ? CmseNSCallMask : 0);
3698 }
3699
3700 // Constructor with all defaults. Use when for example creating a
3701 // function known to use defaults.
3702 ExtInfo() = default;
3703
3704 // Constructor with just the calling convention, which is an important part
3705 // of the canonical type.
3706 ExtInfo(CallingConv CC) : Bits(CC) {}
3707
3708 bool getNoReturn() const { return Bits & NoReturnMask; }
3709 bool getProducesResult() const { return Bits & ProducesResultMask; }
3710 bool getCmseNSCall() const { return Bits & CmseNSCallMask; }
3711 bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
3712 bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
3713 bool getHasRegParm() const { return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
3714
3715 unsigned getRegParm() const {
3716 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
3717 if (RegParm > 0)
3718 --RegParm;
3719 return RegParm;
3720 }
3721
3722 CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }
3723
3724 bool operator==(ExtInfo Other) const {
3725 return Bits == Other.Bits;
3726 }
3727 bool operator!=(ExtInfo Other) const {
3728 return Bits != Other.Bits;
3729 }
3730
3731 // Note that we don't have setters. That is by design, use
3732 // the following with methods instead of mutating these objects.
3733
3734 ExtInfo withNoReturn(bool noReturn) const {
3735 if (noReturn)
3736 return ExtInfo(Bits | NoReturnMask);
3737 else
3738 return ExtInfo(Bits & ~NoReturnMask);
3739 }
3740
3741 ExtInfo withProducesResult(bool producesResult) const {
3742 if (producesResult)
3743 return ExtInfo(Bits | ProducesResultMask);
3744 else
3745 return ExtInfo(Bits & ~ProducesResultMask);
3746 }
3747
3748 ExtInfo withCmseNSCall(bool cmseNSCall) const {
3749 if (cmseNSCall)
3750 return ExtInfo(Bits | CmseNSCallMask);
3751 else
3752 return ExtInfo(Bits & ~CmseNSCallMask);
3753 }
3754
3755 ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
3756 if (noCallerSavedRegs)
3757 return ExtInfo(Bits | NoCallerSavedRegsMask);
3758 else
3759 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
3760 }
3761
3762 ExtInfo withNoCfCheck(bool noCfCheck) const {
3763 if (noCfCheck)
3764 return ExtInfo(Bits | NoCfCheckMask);
3765 else
3766 return ExtInfo(Bits & ~NoCfCheckMask);
3767 }
3768
3769 ExtInfo withRegParm(unsigned RegParm) const {
3770 assert(RegParm < 7 && "Invalid regparm value")(static_cast <bool> (RegParm < 7 && "Invalid regparm value"
) ? void (0) : __assert_fail ("RegParm < 7 && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 3770, __extension__ __PRETTY_FUNCTION__))
;
3771 return ExtInfo((Bits & ~RegParmMask) |
3772 ((RegParm + 1) << RegParmOffset));
3773 }
3774
3775 ExtInfo withCallingConv(CallingConv cc) const {
3776 return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
3777 }
3778
3779 void Profile(llvm::FoldingSetNodeID &ID) const {
3780 ID.AddInteger(Bits);
3781 }
3782 };
3783
3784 /// A simple holder for a QualType representing a type in an
3785 /// exception specification. Unfortunately needed by FunctionProtoType
3786 /// because TrailingObjects cannot handle repeated types.
3787 struct ExceptionType { QualType Type; };
3788
3789 /// A simple holder for various uncommon bits which do not fit in
3790 /// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
3791 /// alignment of subsequent objects in TrailingObjects. You must update
3792 /// hasExtraBitfields in FunctionProtoType after adding extra data here.
3793 struct alignas(void *) FunctionTypeExtraBitfields {
3794 /// The number of types in the exception specification.
3795 /// A whole unsigned is not needed here and according to
3796 /// [implimits] 8 bits would be enough here.
3797 unsigned NumExceptionType;
3798 };
3799
3800protected:
3801 FunctionType(TypeClass tc, QualType res, QualType Canonical,
3802 TypeDependence Dependence, ExtInfo Info)
3803 : Type(tc, Canonical, Dependence), ResultType(res) {
3804 FunctionTypeBits.ExtInfo = Info.Bits;
3805 }
3806
3807 Qualifiers getFastTypeQuals() const {
3808 return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
3809 }
3810
3811public:
3812 QualType getReturnType() const { return ResultType; }
3813
3814 bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
3815 unsigned getRegParmType() const { return getExtInfo().getRegParm(); }
3816
3817 /// Determine whether this function type includes the GNU noreturn
3818 /// attribute. The C++11 [[noreturn]] attribute does not affect the function
3819 /// type.
3820 bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }
3821
3822 bool getCmseNSCallAttr() const { return getExtInfo().getCmseNSCall(); }
3823 CallingConv getCallConv() const { return getExtInfo().getCC(); }
3824 ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }
3825
3826 static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
3827 "Const, volatile and restrict are assumed to be a subset of "
3828 "the fast qualifiers.");
3829
3830 bool isConst() const { return getFastTypeQuals().hasConst(); }
3831 bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
3832 bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }
3833
3834 /// Determine the type of an expression that calls a function of
3835 /// this type.
3836 QualType getCallResultType(const ASTContext &Context) const {
3837 return getReturnType().getNonLValueExprType(Context);
3838 }
3839
3840 static StringRef getNameForCallConv(CallingConv CC);
3841
3842 static bool classof(const Type *T) {
3843 return T->getTypeClass() == FunctionNoProto ||
3844 T->getTypeClass() == FunctionProto;
3845 }
3846};
3847
3848/// Represents a K&R-style 'int foo()' function, which has
3849/// no information available about its arguments.
3850class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
3851 friend class ASTContext; // ASTContext creates these.
3852
3853 FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
3854 : FunctionType(FunctionNoProto, Result, Canonical,
3855 Result->getDependence() &
3856 ~(TypeDependence::DependentInstantiation |
3857 TypeDependence::UnexpandedPack),
3858 Info) {}
3859
3860public:
3861 // No additional state past what FunctionType provides.
3862
3863 bool isSugared() const { return false; }
3864 QualType desugar() const { return QualType(this, 0); }
3865
3866 void Profile(llvm::FoldingSetNodeID &ID) {
3867 Profile(ID, getReturnType(), getExtInfo());
3868 }
3869
3870 static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
3871 ExtInfo Info) {
3872 Info.Profile(ID);
3873 ID.AddPointer(ResultType.getAsOpaquePtr());
3874 }
3875
3876 static bool classof(const Type *T) {
3877 return T->getTypeClass() == FunctionNoProto;
3878 }
3879};
3880
3881/// Represents a prototype with parameter type info, e.g.
3882/// 'int foo(int)' or 'int foo(void)'. 'void' is represented as having no
3883/// parameters, not as having a single void parameter. Such a type can have
3884/// an exception specification, but this specification is not part of the
3885/// canonical type. FunctionProtoType has several trailing objects, some of
3886/// which optional. For more information about the trailing objects see
3887/// the first comment inside FunctionProtoType.
3888class FunctionProtoType final
3889 : public FunctionType,
3890 public llvm::FoldingSetNode,
3891 private llvm::TrailingObjects<
3892 FunctionProtoType, QualType, SourceLocation,
3893 FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
3894 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
3895 friend class ASTContext; // ASTContext creates these.
3896 friend TrailingObjects;
3897
3898 // FunctionProtoType is followed by several trailing objects, some of
3899 // which optional. They are in order:
3900 //
3901 // * An array of getNumParams() QualType holding the parameter types.
3902 // Always present. Note that for the vast majority of FunctionProtoType,
3903 // these will be the only trailing objects.
3904 //
3905 // * Optionally if the function is variadic, the SourceLocation of the
3906 // ellipsis.
3907 //
3908 // * Optionally if some extra data is stored in FunctionTypeExtraBitfields
3909 // (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
3910 // a single FunctionTypeExtraBitfields. Present if and only if
3911 // hasExtraBitfields() is true.
3912 //
3913 // * Optionally exactly one of:
3914 // * an array of getNumExceptions() ExceptionType,
3915 // * a single Expr *,
3916 // * a pair of FunctionDecl *,
3917 // * a single FunctionDecl *
3918 // used to store information about the various types of exception
3919 // specification. See getExceptionSpecSize for the details.
3920 //
3921 // * Optionally an array of getNumParams() ExtParameterInfo holding
3922 // an ExtParameterInfo for each of the parameters. Present if and
3923 // only if hasExtParameterInfos() is true.
3924 //
3925 // * Optionally a Qualifiers object to represent extra qualifiers that can't
3926 // be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
3927 // if hasExtQualifiers() is true.
3928 //
3929 // The optional FunctionTypeExtraBitfields has to be before the data
3930 // related to the exception specification since it contains the number
3931 // of exception types.
3932 //
3933 // We put the ExtParameterInfos last. If all were equal, it would make
3934 // more sense to put these before the exception specification, because
3935 // it's much easier to skip past them compared to the elaborate switch
3936 // required to skip the exception specification. However, all is not
3937 // equal; ExtParameterInfos are used to model very uncommon features,
3938 // and it's better not to burden the more common paths.
3939
3940public:
3941 /// Holds information about the various types of exception specification.
3942 /// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
3943 /// used to group together the various bits of information about the
3944 /// exception specification.
3945 struct ExceptionSpecInfo {
3946 /// The kind of exception specification this is.
3947 ExceptionSpecificationType Type = EST_None;
3948
3949 /// Explicitly-specified list of exception types.
3950 ArrayRef<QualType> Exceptions;
3951
3952 /// Noexcept expression, if this is a computed noexcept specification.
3953 Expr *NoexceptExpr = nullptr;
3954
3955 /// The function whose exception specification this is, for
3956 /// EST_Unevaluated and EST_Uninstantiated.
3957 FunctionDecl *SourceDecl = nullptr;
3958
3959 /// The function template whose exception specification this is instantiated
3960 /// from, for EST_Uninstantiated.
3961 FunctionDecl *SourceTemplate = nullptr;
3962
3963 ExceptionSpecInfo() = default;
3964
3965 ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
3966 };
3967
3968 /// Extra information about a function prototype. ExtProtoInfo is not
3969 /// stored as such in FunctionProtoType but is used to group together
3970 /// the various bits of extra information about a function prototype.
3971 struct ExtProtoInfo {
3972 FunctionType::ExtInfo ExtInfo;
3973 bool Variadic : 1;
3974 bool HasTrailingReturn : 1;
3975 Qualifiers TypeQuals;
3976 RefQualifierKind RefQualifier = RQ_None;
3977 ExceptionSpecInfo ExceptionSpec;
3978 const ExtParameterInfo *ExtParameterInfos = nullptr;
3979 SourceLocation EllipsisLoc;
3980
3981 ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}
3982
3983 ExtProtoInfo(CallingConv CC)
3984 : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}
3985
3986 ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
3987 ExtProtoInfo Result(*this);
3988 Result.ExceptionSpec = ESI;
3989 return Result;
3990 }
3991 };
3992
3993private:
3994 unsigned numTrailingObjects(OverloadToken<QualType>) const {
3995 return getNumParams();
3996 }
3997
3998 unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
3999 return isVariadic();
4000 }
4001
4002 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
4003 return hasExtraBitfields();
4004 }
4005
4006 unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
4007 return getExceptionSpecSize().NumExceptionType;
4008 }
4009
4010 unsigned numTrailingObjects(OverloadToken<Expr *>) const {
4011 return getExceptionSpecSize().NumExprPtr;
4012 }
4013
4014 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
4015 return getExceptionSpecSize().NumFunctionDeclPtr;
4016 }
4017
4018 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
4019 return hasExtParameterInfos() ? getNumParams() : 0;
4020 }
4021
4022 /// Determine whether there are any argument types that
4023 /// contain an unexpanded parameter pack.
4024 static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
4025 unsigned numArgs) {
4026 for (unsigned Idx = 0; Idx < numArgs; ++Idx)
4027 if (ArgArray[Idx]->containsUnexpandedParameterPack())
4028 return true;
4029
4030 return false;
4031 }
4032
4033 FunctionProtoType(QualType result, ArrayRef<QualType> params,
4034 QualType canonical, const ExtProtoInfo &epi);
4035
4036 /// This struct is returned by getExceptionSpecSize and is used to
4037 /// translate an ExceptionSpecificationType to the number and kind
4038 /// of trailing objects related to the exception specification.
4039 struct ExceptionSpecSizeHolder {
4040 unsigned NumExceptionType;
4041 unsigned NumExprPtr;
4042 unsigned NumFunctionDeclPtr;
4043 };
4044
4045 /// Return the number and kind of trailing objects
4046 /// related to the exception specification.
4047 static ExceptionSpecSizeHolder
4048 getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
4049 switch (EST) {
4050 case EST_None:
4051 case EST_DynamicNone:
4052 case EST_MSAny:
4053 case EST_BasicNoexcept:
4054 case EST_Unparsed:
4055 case EST_NoThrow:
4056 return {0, 0, 0};
4057
4058 case EST_Dynamic:
4059 return {NumExceptions, 0, 0};
4060
4061 case EST_DependentNoexcept:
4062 case EST_NoexceptFalse:
4063 case EST_NoexceptTrue:
4064 return {0, 1, 0};
4065
4066 case EST_Uninstantiated:
4067 return {0, 0, 2};
4068
4069 case EST_Unevaluated:
4070 return {0, 0, 1};
4071 }
4072 llvm_unreachable("bad exception specification kind")::llvm::llvm_unreachable_internal("bad exception specification kind"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4072)
;
4073 }
4074
4075 /// Return the number and kind of trailing objects
4076 /// related to the exception specification.
4077 ExceptionSpecSizeHolder getExceptionSpecSize() const {
4078 return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
4079 }
4080
4081 /// Whether the trailing FunctionTypeExtraBitfields is present.
4082 static bool hasExtraBitfields(ExceptionSpecificationType EST) {
4083 // If the exception spec type is EST_Dynamic then we have > 0 exception
4084 // types and the exact number is stored in FunctionTypeExtraBitfields.
4085 return EST == EST_Dynamic;
4086 }
4087
4088 /// Whether the trailing FunctionTypeExtraBitfields is present.
4089 bool hasExtraBitfields() const {
4090 return hasExtraBitfields(getExceptionSpecType());
4091 }
4092
4093 bool hasExtQualifiers() const {
4094 return FunctionTypeBits.HasExtQuals;
4095 }
4096
4097public:
4098 unsigned getNumParams() const { return FunctionTypeBits.NumParams; }
4099
4100 QualType getParamType(unsigned i) const {
4101 assert(i < getNumParams() && "invalid parameter index")(static_cast <bool> (i < getNumParams() && "invalid parameter index"
) ? void (0) : __assert_fail ("i < getNumParams() && \"invalid parameter index\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4101, __extension__ __PRETTY_FUNCTION__))
;
4102 return param_type_begin()[i];
4103 }
4104
4105 ArrayRef<QualType> getParamTypes() const {
4106 return llvm::makeArrayRef(param_type_begin(), param_type_end());
4107 }
4108
4109 ExtProtoInfo getExtProtoInfo() const {
4110 ExtProtoInfo EPI;
4111 EPI.ExtInfo = getExtInfo();
4112 EPI.Variadic = isVariadic();
4113 EPI.EllipsisLoc = getEllipsisLoc();
4114 EPI.HasTrailingReturn = hasTrailingReturn();
4115 EPI.ExceptionSpec = getExceptionSpecInfo();
4116 EPI.TypeQuals = getMethodQuals();
4117 EPI.RefQualifier = getRefQualifier();
4118 EPI.ExtParameterInfos = getExtParameterInfosOrNull();
4119 return EPI;
4120 }
4121
4122 /// Get the kind of exception specification on this function.
4123 ExceptionSpecificationType getExceptionSpecType() const {
4124 return static_cast<ExceptionSpecificationType>(
4125 FunctionTypeBits.ExceptionSpecType);
4126 }
4127
4128 /// Return whether this function has any kind of exception spec.
4129 bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }
4130
4131 /// Return whether this function has a dynamic (throw) exception spec.
4132 bool hasDynamicExceptionSpec() const {
4133 return isDynamicExceptionSpec(getExceptionSpecType());
4134 }
4135
4136 /// Return whether this function has a noexcept exception spec.
4137 bool hasNoexceptExceptionSpec() const {
4138 return isNoexceptExceptionSpec(getExceptionSpecType());
4139 }
4140
4141 /// Return whether this function has a dependent exception spec.
4142 bool hasDependentExceptionSpec() const;
4143
4144 /// Return whether this function has an instantiation-dependent exception
4145 /// spec.
4146 bool hasInstantiationDependentExceptionSpec() const;
4147
4148 /// Return all the available information about this type's exception spec.
4149 ExceptionSpecInfo getExceptionSpecInfo() const {
4150 ExceptionSpecInfo Result;
4151 Result.Type = getExceptionSpecType();
4152 if (Result.Type == EST_Dynamic) {
4153 Result.Exceptions = exceptions();
4154 } else if (isComputedNoexcept(Result.Type)) {
4155 Result.NoexceptExpr = getNoexceptExpr();
4156 } else if (Result.Type == EST_Uninstantiated) {
4157 Result.SourceDecl = getExceptionSpecDecl();
4158 Result.SourceTemplate = getExceptionSpecTemplate();
4159 } else if (Result.Type == EST_Unevaluated) {
4160 Result.SourceDecl = getExceptionSpecDecl();
4161 }
4162 return Result;
4163 }
4164
4165 /// Return the number of types in the exception specification.
4166 unsigned getNumExceptions() const {
4167 return getExceptionSpecType() == EST_Dynamic
4168 ? getTrailingObjects<FunctionTypeExtraBitfields>()
4169 ->NumExceptionType
4170 : 0;
4171 }
4172
4173 /// Return the ith exception type, where 0 <= i < getNumExceptions().
4174 QualType getExceptionType(unsigned i) const {
4175 assert(i < getNumExceptions() && "Invalid exception number!")(static_cast <bool> (i < getNumExceptions() &&
"Invalid exception number!") ? void (0) : __assert_fail ("i < getNumExceptions() && \"Invalid exception number!\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4175, __extension__ __PRETTY_FUNCTION__))
;
4176 return exception_begin()[i];
4177 }
4178
4179 /// Return the expression inside noexcept(expression), or a null pointer
4180 /// if there is none (because the exception spec is not of this form).
4181 Expr *getNoexceptExpr() const {
4182 if (!isComputedNoexcept(getExceptionSpecType()))
4183 return nullptr;
4184 return *getTrailingObjects<Expr *>();
4185 }
4186
4187 /// If this function type has an exception specification which hasn't
4188 /// been determined yet (either because it has not been evaluated or because
4189 /// it has not been instantiated), this is the function whose exception
4190 /// specification is represented by this type.
4191 FunctionDecl *getExceptionSpecDecl() const {
4192 if (getExceptionSpecType() != EST_Uninstantiated &&
4193 getExceptionSpecType() != EST_Unevaluated)
4194 return nullptr;
4195 return getTrailingObjects<FunctionDecl *>()[0];
4196 }
4197
4198 /// If this function type has an uninstantiated exception
4199 /// specification, this is the function whose exception specification
4200 /// should be instantiated to find the exception specification for
4201 /// this type.
4202 FunctionDecl *getExceptionSpecTemplate() const {
4203 if (getExceptionSpecType() != EST_Uninstantiated)
4204 return nullptr;
4205 return getTrailingObjects<FunctionDecl *>()[1];
4206 }
4207
4208 /// Determine whether this function type has a non-throwing exception
4209 /// specification.
4210 CanThrowResult canThrow() const;
4211
4212 /// Determine whether this function type has a non-throwing exception
4213 /// specification. If this depends on template arguments, returns
4214 /// \c ResultIfDependent.
4215 bool isNothrow(bool ResultIfDependent = false) const {
4216 return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
4217 }
4218
4219 /// Whether this function prototype is variadic.
4220 bool isVariadic() const { return FunctionTypeBits.Variadic; }
4221
4222 SourceLocation getEllipsisLoc() const {
4223 return isVariadic() ? *getTrailingObjects<SourceLocation>()
4224 : SourceLocation();
4225 }
4226
4227 /// Determines whether this function prototype contains a
4228 /// parameter pack at the end.
4229 ///
4230 /// A function template whose last parameter is a parameter pack can be
4231 /// called with an arbitrary number of arguments, much like a variadic
4232 /// function.
4233 bool isTemplateVariadic() const;
4234
4235 /// Whether this function prototype has a trailing return type.
4236 bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }
4237
4238 Qualifiers getMethodQuals() const {
4239 if (hasExtQualifiers())
4240 return *getTrailingObjects<Qualifiers>();
4241 else
4242 return getFastTypeQuals();
4243 }
4244
4245 /// Retrieve the ref-qualifier associated with this function type.
4246 RefQualifierKind getRefQualifier() const {
4247 return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
4248 }
4249
4250 using param_type_iterator = const QualType *;
4251 using param_type_range = llvm::iterator_range<param_type_iterator>;
4252
4253 param_type_range param_types() const {
4254 return param_type_range(param_type_begin(), param_type_end());
4255 }
4256
4257 param_type_iterator param_type_begin() const {
4258 return getTrailingObjects<QualType>();
4259 }
4260
4261 param_type_iterator param_type_end() const {
4262 return param_type_begin() + getNumParams();
4263 }
4264
4265 using exception_iterator = const QualType *;
4266
4267 ArrayRef<QualType> exceptions() const {
4268 return llvm::makeArrayRef(exception_begin(), exception_end());
4269 }
4270
4271 exception_iterator exception_begin() const {
4272 return reinterpret_cast<exception_iterator>(
4273 getTrailingObjects<ExceptionType>());
4274 }
4275
4276 exception_iterator exception_end() const {
4277 return exception_begin() + getNumExceptions();
4278 }
4279
4280 /// Is there any interesting extra information for any of the parameters
4281 /// of this function type?
4282 bool hasExtParameterInfos() const {
4283 return FunctionTypeBits.HasExtParameterInfos;
4284 }
4285
4286 ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
4287 assert(hasExtParameterInfos())(static_cast <bool> (hasExtParameterInfos()) ? void (0)
: __assert_fail ("hasExtParameterInfos()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4287, __extension__ __PRETTY_FUNCTION__))
;
4288 return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
4289 getNumParams());
4290 }
4291
4292 /// Return a pointer to the beginning of the array of extra parameter
4293 /// information, if present, or else null if none of the parameters
4294 /// carry it. This is equivalent to getExtProtoInfo().ExtParameterInfos.
4295 const ExtParameterInfo *getExtParameterInfosOrNull() const {
4296 if (!hasExtParameterInfos())
4297 return nullptr;
4298 return getTrailingObjects<ExtParameterInfo>();
4299 }
4300
4301 ExtParameterInfo getExtParameterInfo(unsigned I) const {
4302 assert(I < getNumParams() && "parameter index out of range")(static_cast <bool> (I < getNumParams() && "parameter index out of range"
) ? void (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4302, __extension__ __PRETTY_FUNCTION__))
;
4303 if (hasExtParameterInfos())
4304 return getTrailingObjects<ExtParameterInfo>()[I];
4305 return ExtParameterInfo();
4306 }
4307
4308 ParameterABI getParameterABI(unsigned I) const {
4309 assert(I < getNumParams() && "parameter index out of range")(static_cast <bool> (I < getNumParams() && "parameter index out of range"
) ? void (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4309, __extension__ __PRETTY_FUNCTION__))
;
4310 if (hasExtParameterInfos())
4311 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
4312 return ParameterABI::Ordinary;
4313 }
4314
4315 bool isParamConsumed(unsigned I) const {
4316 assert(I < getNumParams() && "parameter index out of range")(static_cast <bool> (I < getNumParams() && "parameter index out of range"
) ? void (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4316, __extension__ __PRETTY_FUNCTION__))
;
4317 if (hasExtParameterInfos())
4318 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
4319 return false;
4320 }
4321
4322 bool isSugared() const { return false; }
4323 QualType desugar() const { return QualType(this, 0); }
4324
4325 void printExceptionSpecification(raw_ostream &OS,
4326 const PrintingPolicy &Policy) const;
4327
4328 static bool classof(const Type *T) {
4329 return T->getTypeClass() == FunctionProto;
4330 }
4331
4332 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
4333 static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
4334 param_type_iterator ArgTys, unsigned NumArgs,
4335 const ExtProtoInfo &EPI, const ASTContext &Context,
4336 bool Canonical);
4337};
4338
4339/// Represents the dependent type named by a dependently-scoped
4340/// typename using declaration, e.g.
4341/// using typename Base<T>::foo;
4342///
4343/// Template instantiation turns these into the underlying type.
4344class UnresolvedUsingType : public Type {
4345 friend class ASTContext; // ASTContext creates these.
4346
4347 UnresolvedUsingTypenameDecl *Decl;
4348
4349 UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
4350 : Type(UnresolvedUsing, QualType(),
4351 TypeDependence::DependentInstantiation),
4352 Decl(const_cast<UnresolvedUsingTypenameDecl *>(D)) {}
4353
4354public:
4355 UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }
4356
4357 bool isSugared() const { return false; }
4358 QualType desugar() const { return QualType(this, 0); }
4359
4360 static bool classof(const Type *T) {
4361 return T->getTypeClass() == UnresolvedUsing;
4362 }
4363
4364 void Profile(llvm::FoldingSetNodeID &ID) {
4365 return Profile(ID, Decl);
4366 }
4367
4368 static void Profile(llvm::FoldingSetNodeID &ID,
4369 UnresolvedUsingTypenameDecl *D) {
4370 ID.AddPointer(D);
4371 }
4372};
4373
4374class TypedefType : public Type {
4375 TypedefNameDecl *Decl;
4376
4377private:
4378 friend class ASTContext; // ASTContext creates these.
4379
4380 TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType underlying,
4381 QualType can);
4382
4383public:
4384 TypedefNameDecl *getDecl() const { return Decl; }
4385
4386 bool isSugared() const { return true; }
4387 QualType desugar() const;
4388
4389 static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4390};
4391
4392/// Sugar type that represents a type that was qualified by a qualifier written
4393/// as a macro invocation.
4394class MacroQualifiedType : public Type {
4395 friend class ASTContext; // ASTContext creates these.
4396
4397 QualType UnderlyingTy;
4398 const IdentifierInfo *MacroII;
4399
4400 MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
4401 const IdentifierInfo *MacroII)
4402 : Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
4403 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
4404 assert(isa<AttributedType>(UnderlyingTy) &&(static_cast <bool> (isa<AttributedType>(UnderlyingTy
) && "Expected a macro qualified type to only wrap attributed types."
) ? void (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4405, __extension__ __PRETTY_FUNCTION__))
4405 "Expected a macro qualified type to only wrap attributed types.")(static_cast <bool> (isa<AttributedType>(UnderlyingTy
) && "Expected a macro qualified type to only wrap attributed types."
) ? void (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4405, __extension__ __PRETTY_FUNCTION__))
;
4406 }
4407
4408public:
4409 const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
4410 QualType getUnderlyingType() const { return UnderlyingTy; }
4411
4412 /// Return this attributed type's modified type with no qualifiers attached to
4413 /// it.
4414 QualType getModifiedType() const;
4415
4416 bool isSugared() const { return true; }
4417 QualType desugar() const;
4418
4419 static bool classof(const Type *T) {
4420 return T->getTypeClass() == MacroQualified;
4421 }
4422};
4423
4424/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4425class TypeOfExprType : public Type {
4426 Expr *TOExpr;
4427
4428protected:
4429 friend class ASTContext; // ASTContext creates these.
4430
4431 TypeOfExprType(Expr *E, QualType can = QualType());
4432
4433public:
4434 Expr *getUnderlyingExpr() const { return TOExpr; }
4435
4436 /// Remove a single level of sugar.
4437 QualType desugar() const;
4438
4439 /// Returns whether this type directly provides sugar.
4440 bool isSugared() const;
4441
4442 static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4443};
4444
4445/// Internal representation of canonical, dependent
4446/// `typeof(expr)` types.
4447///
4448/// This class is used internally by the ASTContext to manage
4449/// canonical, dependent types, only. Clients will only see instances
4450/// of this class via TypeOfExprType nodes.
4451class DependentTypeOfExprType
4452 : public TypeOfExprType, public llvm::FoldingSetNode {
4453 const ASTContext &Context;
4454
4455public:
4456 DependentTypeOfExprType(const ASTContext &Context, Expr *E)
4457 : TypeOfExprType(E), Context(Context) {}
4458
4459 void Profile(llvm::FoldingSetNodeID &ID) {
4460 Profile(ID, Context, getUnderlyingExpr());
4461 }
4462
4463 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4464 Expr *E);
4465};
4466
4467/// Represents `typeof(type)`, a GCC extension.
4468class TypeOfType : public Type {
4469 friend class ASTContext; // ASTContext creates these.
4470
4471 QualType TOType;
4472
4473 TypeOfType(QualType T, QualType can)
4474 : Type(TypeOf, can, T->getDependence()), TOType(T) {
4475 assert(!isa<TypedefType>(can) && "Invalid canonical type")(static_cast <bool> (!isa<TypedefType>(can) &&
"Invalid canonical type") ? void (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4475, __extension__ __PRETTY_FUNCTION__))
;
4476 }
4477
4478public:
4479 QualType getUnderlyingType() const { return TOType; }
4480
4481 /// Remove a single level of sugar.
4482 QualType desugar() const { return getUnderlyingType(); }
4483
4484 /// Returns whether this type directly provides sugar.
4485 bool isSugared() const { return true; }
4486
4487 static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4488};
4489
4490/// Represents the type `decltype(expr)` (C++11).
4491class DecltypeType : public Type {
4492 Expr *E;
4493 QualType UnderlyingType;
4494
4495protected:
4496 friend class ASTContext; // ASTContext creates these.
4497
4498 DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
4499
4500public:
4501 Expr *getUnderlyingExpr() const { return E; }
4502 QualType getUnderlyingType() const { return UnderlyingType; }
4503
4504 /// Remove a single level of sugar.
4505 QualType desugar() const;
4506
4507 /// Returns whether this type directly provides sugar.
4508 bool isSugared() const;
4509
4510 static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4511};
4512
4513/// Internal representation of canonical, dependent
4514/// decltype(expr) types.
4515///
4516/// This class is used internally by the ASTContext to manage
4517/// canonical, dependent types, only. Clients will only see instances
4518/// of this class via DecltypeType nodes.
4519class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
4520 const ASTContext &Context;
4521
4522public:
4523 DependentDecltypeType(const ASTContext &Context, Expr *E);
4524
4525 void Profile(llvm::FoldingSetNodeID &ID) {
4526 Profile(ID, Context, getUnderlyingExpr());
4527 }
4528
4529 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4530 Expr *E);
4531};
4532
4533/// A unary type transform, which is a type constructed from another.
4534class UnaryTransformType : public Type {
4535public:
4536 enum UTTKind {
4537 EnumUnderlyingType
4538 };
4539
4540private:
4541 /// The untransformed type.
4542 QualType BaseType;
4543
4544 /// The transformed type if not dependent, otherwise the same as BaseType.
4545 QualType UnderlyingType;
4546
4547 UTTKind UKind;
4548
4549protected:
4550 friend class ASTContext;
4551
4552 UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
4553 QualType CanonicalTy);
4554
4555public:
4556 bool isSugared() const { return !isDependentType(); }
4557 QualType desugar() const { return UnderlyingType; }
4558
4559 QualType getUnderlyingType() const { return UnderlyingType; }
4560 QualType getBaseType() const { return BaseType; }
4561
4562 UTTKind getUTTKind() const { return UKind; }
4563
4564 static bool classof(const Type *T) {
4565 return T->getTypeClass() == UnaryTransform;
4566 }
4567};
4568
4569/// Internal representation of canonical, dependent
4570/// __underlying_type(type) types.
4571///
4572/// This class is used internally by the ASTContext to manage
4573/// canonical, dependent types, only. Clients will only see instances
4574/// of this class via UnaryTransformType nodes.
4575class DependentUnaryTransformType : public UnaryTransformType,
4576 public llvm::FoldingSetNode {
4577public:
4578 DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
4579 UTTKind UKind);
4580
4581 void Profile(llvm::FoldingSetNodeID &ID) {
4582 Profile(ID, getBaseType(), getUTTKind());
4583 }
4584
4585 static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
4586 UTTKind UKind) {
4587 ID.AddPointer(BaseType.getAsOpaquePtr());
4588 ID.AddInteger((unsigned)UKind);
4589 }
4590};
4591
4592class TagType : public Type {
4593 friend class ASTReader;
4594 template <class T> friend class serialization::AbstractTypeReader;
4595
4596 /// Stores the TagDecl associated with this type. The decl may point to any
4597 /// TagDecl that declares the entity.
4598 TagDecl *decl;
4599
4600protected:
4601 TagType(TypeClass TC, const TagDecl *D, QualType can);
4602
4603public:
4604 TagDecl *getDecl() const;
4605
4606 /// Determines whether this type is in the process of being defined.
4607 bool isBeingDefined() const;
4608
4609 static bool classof(const Type *T) {
4610 return T->getTypeClass() == Enum || T->getTypeClass() == Record;
4611 }
4612};
4613
4614/// A helper class that allows the use of isa/cast/dyncast
4615/// to detect TagType objects of structs/unions/classes.
4616class RecordType : public TagType {
4617protected:
4618 friend class ASTContext; // ASTContext creates these.
4619
4620 explicit RecordType(const RecordDecl *D)
4621 : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4622 explicit RecordType(TypeClass TC, RecordDecl *D)
4623 : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4624
4625public:
4626 RecordDecl *getDecl() const {
4627 return reinterpret_cast<RecordDecl*>(TagType::getDecl());
4628 }
4629
4630 /// Recursively check all fields in the record for const-ness. If any field
4631 /// is declared const, return true. Otherwise, return false.
4632 bool hasConstFields() const;
4633
4634 bool isSugared() const { return false; }
4635 QualType desugar() const { return QualType(this, 0); }
4636
4637 static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4638};
4639
4640/// A helper class that allows the use of isa/cast/dyncast
4641/// to detect TagType objects of enums.
4642class EnumType : public TagType {
4643 friend class ASTContext; // ASTContext creates these.
4644
4645 explicit EnumType(const EnumDecl *D)
4646 : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4647
4648public:
4649 EnumDecl *getDecl() const {
4650 return reinterpret_cast<EnumDecl*>(TagType::getDecl());
4651 }
4652
4653 bool isSugared() const { return false; }
4654 QualType desugar() const { return QualType(this, 0); }
4655
4656 static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4657};
4658
4659/// An attributed type is a type to which a type attribute has been applied.
4660///
4661/// The "modified type" is the fully-sugared type to which the attributed
4662/// type was applied; generally it is not canonically equivalent to the
4663/// attributed type. The "equivalent type" is the minimally-desugared type
4664/// which the type is canonically equivalent to.
4665///
4666/// For example, in the following attributed type:
4667/// int32_t __attribute__((vector_size(16)))
4668/// - the modified type is the TypedefType for int32_t
4669/// - the equivalent type is VectorType(16, int32_t)
4670/// - the canonical type is VectorType(16, int)
4671class AttributedType : public Type, public llvm::FoldingSetNode {
4672public:
4673 using Kind = attr::Kind;
4674
4675private:
4676 friend class ASTContext; // ASTContext creates these
4677
4678 QualType ModifiedType;
4679 QualType EquivalentType;
4680
4681 AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
4682 QualType equivalent)
4683 : Type(Attributed, canon, equivalent->getDependence()),
4684 ModifiedType(modified), EquivalentType(equivalent) {
4685 AttributedTypeBits.AttrKind = attrKind;
4686 }
4687
4688public:
4689 Kind getAttrKind() const {
4690 return static_cast<Kind>(AttributedTypeBits.AttrKind);
4691 }
4692
4693 QualType getModifiedType() const { return ModifiedType; }
4694 QualType getEquivalentType() const { return EquivalentType; }
4695
4696 bool isSugared() const { return true; }
4697 QualType desugar() const { return getEquivalentType(); }
4698
4699 /// Does this attribute behave like a type qualifier?
4700 ///
4701 /// A type qualifier adjusts a type to provide specialized rules for
4702 /// a specific object, like the standard const and volatile qualifiers.
4703 /// This includes attributes controlling things like nullability,
4704 /// address spaces, and ARC ownership. The value of the object is still
4705 /// largely described by the modified type.
4706 ///
4707 /// In contrast, many type attributes "rewrite" their modified type to
4708 /// produce a fundamentally different type, not necessarily related in any
4709 /// formalizable way to the original type. For example, calling convention
4710 /// and vector attributes are not simple type qualifiers.
4711 ///
4712 /// Type qualifiers are often, but not always, reflected in the canonical
4713 /// type.
4714 bool isQualifier() const;
4715
4716 bool isMSTypeSpec() const;
4717
4718 bool isCallingConv() const;
4719
4720 llvm::Optional<NullabilityKind> getImmediateNullability() const;
4721
4722 /// Retrieve the attribute kind corresponding to the given
4723 /// nullability kind.
4724 static Kind getNullabilityAttrKind(NullabilityKind kind) {
4725 switch (kind) {
4726 case NullabilityKind::NonNull:
4727 return attr::TypeNonNull;
4728
4729 case NullabilityKind::Nullable:
4730 return attr::TypeNullable;
4731
4732 case NullabilityKind::NullableResult:
4733 return attr::TypeNullableResult;
4734
4735 case NullabilityKind::Unspecified:
4736 return attr::TypeNullUnspecified;
4737 }
4738 llvm_unreachable("Unknown nullability kind.")::llvm::llvm_unreachable_internal("Unknown nullability kind."
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 4738)
;
4739 }
4740
4741 /// Strip off the top-level nullability annotation on the given
4742 /// type, if it's there.
4743 ///
4744 /// \param T The type to strip. If the type is exactly an
4745 /// AttributedType specifying nullability (without looking through
4746 /// type sugar), the nullability is returned and this type changed
4747 /// to the underlying modified type.
4748 ///
4749 /// \returns the top-level nullability, if present.
4750 static Optional<NullabilityKind> stripOuterNullability(QualType &T);
4751
4752 void Profile(llvm::FoldingSetNodeID &ID) {
4753 Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
4754 }
4755
4756 static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
4757 QualType modified, QualType equivalent) {
4758 ID.AddInteger(attrKind);
4759 ID.AddPointer(modified.getAsOpaquePtr());
4760 ID.AddPointer(equivalent.getAsOpaquePtr());
4761 }
4762
4763 static bool classof(const Type *T) {
4764 return T->getTypeClass() == Attributed;
4765 }
4766};
4767
4768class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4769 friend class ASTContext; // ASTContext creates these
4770
4771 // Helper data collector for canonical types.
4772 struct CanonicalTTPTInfo {
4773 unsigned Depth : 15;
4774 unsigned ParameterPack : 1;
4775 unsigned Index : 16;
4776 };
4777
4778 union {
4779 // Info for the canonical type.
4780 CanonicalTTPTInfo CanTTPTInfo;
4781
4782 // Info for the non-canonical type.
4783 TemplateTypeParmDecl *TTPDecl;
4784 };
4785
4786 /// Build a non-canonical type.
4787 TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
4788 : Type(TemplateTypeParm, Canon,
4789 TypeDependence::DependentInstantiation |
4790 (Canon->getDependence() & TypeDependence::UnexpandedPack)),
4791 TTPDecl(TTPDecl) {}
4792
4793 /// Build the canonical type.
4794 TemplateTypeParmType(unsigned D, unsigned I, bool PP)
4795 : Type(TemplateTypeParm, QualType(this, 0),
4796 TypeDependence::DependentInstantiation |
4797 (PP ? TypeDependence::UnexpandedPack : TypeDependence::None)) {
4798 CanTTPTInfo.Depth = D;
4799 CanTTPTInfo.Index = I;
4800 CanTTPTInfo.ParameterPack = PP;
4801 }
4802
4803 const CanonicalTTPTInfo& getCanTTPTInfo() const {
4804 QualType Can = getCanonicalTypeInternal();
4805 return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
4806 }
4807
4808public:
4809 unsigned getDepth() const { return getCanTTPTInfo().Depth; }
4810 unsigned getIndex() const { return getCanTTPTInfo().Index; }
4811 bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }
4812
4813 TemplateTypeParmDecl *getDecl() const {
4814 return isCanonicalUnqualified() ? nullptr : TTPDecl;
4815 }
4816
4817 IdentifierInfo *getIdentifier() const;
4818
4819 bool isSugared() const { return false; }
4820 QualType desugar() const { return QualType(this, 0); }
4821
4822 void Profile(llvm::FoldingSetNodeID &ID) {
4823 Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
4824 }
4825
4826 static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
4827 unsigned Index, bool ParameterPack,
4828 TemplateTypeParmDecl *TTPDecl) {
4829 ID.AddInteger(Depth);
4830 ID.AddInteger(Index);
4831 ID.AddBoolean(ParameterPack);
4832 ID.AddPointer(TTPDecl);
4833 }
4834
4835 static bool classof(const Type *T) {
4836 return T->getTypeClass() == TemplateTypeParm;
4837 }
4838};
4839
4840/// Represents the result of substituting a type for a template
4841/// type parameter.
4842///
4843/// Within an instantiated template, all template type parameters have
4844/// been replaced with these. They are used solely to record that a
4845/// type was originally written as a template type parameter;
4846/// therefore they are never canonical.
4847class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4848 friend class ASTContext;
4849
4850 // The original type parameter.
4851 const TemplateTypeParmType *Replaced;
4852
4853 SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
4854 : Type(SubstTemplateTypeParm, Canon, Canon->getDependence()),
4855 Replaced(Param) {}
4856
4857public:
4858 /// Gets the template parameter that was substituted for.
4859 const TemplateTypeParmType *getReplacedParameter() const {
4860 return Replaced;
4861 }
4862
4863 /// Gets the type that was substituted for the template
4864 /// parameter.
4865 QualType getReplacementType() const {
4866 return getCanonicalTypeInternal();
4867 }
4868
4869 bool isSugared() const { return true; }
4870 QualType desugar() const { return getReplacementType(); }
4871
4872 void Profile(llvm::FoldingSetNodeID &ID) {
4873 Profile(ID, getReplacedParameter(), getReplacementType());
4874 }
4875
4876 static void Profile(llvm::FoldingSetNodeID &ID,
4877 const TemplateTypeParmType *Replaced,
4878 QualType Replacement) {
4879 ID.AddPointer(Replaced);
4880 ID.AddPointer(Replacement.getAsOpaquePtr());
4881 }
4882
4883 static bool classof(const Type *T) {
4884 return T->getTypeClass() == SubstTemplateTypeParm;
4885 }
4886};
4887
4888/// Represents the result of substituting a set of types for a template
4889/// type parameter pack.
4890///
4891/// When a pack expansion in the source code contains multiple parameter packs
4892/// and those parameter packs correspond to different levels of template
4893/// parameter lists, this type node is used to represent a template type
4894/// parameter pack from an outer level, which has already had its argument pack
4895/// substituted but that still lives within a pack expansion that itself
4896/// could not be instantiated. When actually performing a substitution into
4897/// that pack expansion (e.g., when all template parameters have corresponding
4898/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4899/// at the current pack substitution index.
4900class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
4901 friend class ASTContext;
4902
4903 /// The original type parameter.
4904 const TemplateTypeParmType *Replaced;
4905
4906 /// A pointer to the set of template arguments that this
4907 /// parameter pack is instantiated with.
4908 const TemplateArgument *Arguments;
4909
4910 SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
4911 QualType Canon,
4912 const TemplateArgument &ArgPack);
4913
4914public:
4915 IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }
4916
4917 /// Gets the template parameter that was substituted for.
4918 const TemplateTypeParmType *getReplacedParameter() const {
4919 return Replaced;
4920 }
4921
4922 unsigned getNumArgs() const {
4923 return SubstTemplateTypeParmPackTypeBits.NumArgs;
4924 }
4925
4926 bool isSugared() const { return false; }
4927 QualType desugar() const { return QualType(this, 0); }
4928
4929 TemplateArgument getArgumentPack() const;
4930
4931 void Profile(llvm::FoldingSetNodeID &ID);
4932 static void Profile(llvm::FoldingSetNodeID &ID,
4933 const TemplateTypeParmType *Replaced,
4934 const TemplateArgument &ArgPack);
4935
4936 static bool classof(const Type *T) {
4937 return T->getTypeClass() == SubstTemplateTypeParmPack;
4938 }
4939};
4940
4941/// Common base class for placeholders for types that get replaced by
4942/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4943/// class template types, and constrained type names.
4944///
4945/// These types are usually a placeholder for a deduced type. However, before
4946/// the initializer is attached, or (usually) if the initializer is
4947/// type-dependent, there is no deduced type and the type is canonical. In
4948/// the latter case, it is also a dependent type.
4949class DeducedType : public Type {
4950protected:
4951 DeducedType(TypeClass TC, QualType DeducedAsType,
4952 TypeDependence ExtraDependence)
4953 : Type(TC,
4954 // FIXME: Retain the sugared deduced type?
4955 DeducedAsType.isNull() ? QualType(this, 0)
4956 : DeducedAsType.getCanonicalType(),
4957 ExtraDependence | (DeducedAsType.isNull()
4958 ? TypeDependence::None
4959 : DeducedAsType->getDependence() &
4960 ~TypeDependence::VariablyModified)) {}
4961
4962public:
4963 bool isSugared() const { return !isCanonicalUnqualified(); }
4964 QualType desugar() const { return getCanonicalTypeInternal(); }
4965
4966 /// Get the type deduced for this placeholder type, or null if it's
4967 /// either not been deduced or was deduced to a dependent type.
4968 QualType getDeducedType() const {
4969 return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
4970 }
4971 bool isDeduced() const {
4972 return !isCanonicalUnqualified() || isDependentType();
4973 }
4974
4975 static bool classof(const Type *T) {
4976 return T->getTypeClass() == Auto ||
4977 T->getTypeClass() == DeducedTemplateSpecialization;
4978 }
4979};
4980
4981/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
4982/// by a type-constraint.
4983class alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
4984 friend class ASTContext; // ASTContext creates these
4985
4986 ConceptDecl *TypeConstraintConcept;
4987
4988 AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
4989 TypeDependence ExtraDependence, ConceptDecl *CD,
4990 ArrayRef<TemplateArgument> TypeConstraintArgs);
4991
4992 const TemplateArgument *getArgBuffer() const {
4993 return reinterpret_cast<const TemplateArgument*>(this+1);
4994 }
4995
4996 TemplateArgument *getArgBuffer() {
4997 return reinterpret_cast<TemplateArgument*>(this+1);
4998 }
4999
5000public:
5001 /// Retrieve the template arguments.
5002 const TemplateArgument *getArgs() const {
5003 return getArgBuffer();
5004 }
5005
5006 /// Retrieve the number of template arguments.
5007 unsigned getNumArgs() const {
5008 return AutoTypeBits.NumArgs;
5009 }
5010
5011 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5012
5013 ArrayRef<TemplateArgument> getTypeConstraintArguments() const {
5014 return {getArgs(), getNumArgs()};
5015 }
5016
5017 ConceptDecl *getTypeConstraintConcept() const {
5018 return TypeConstraintConcept;
5019 }
5020
5021 bool isConstrained() const {
5022 return TypeConstraintConcept != nullptr;
5023 }
5024
5025 bool isDecltypeAuto() const {
5026 return getKeyword() == AutoTypeKeyword::DecltypeAuto;
5027 }
5028
5029 AutoTypeKeyword getKeyword() const {
5030 return (AutoTypeKeyword)AutoTypeBits.Keyword;
5031 }
5032
5033 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
5034 Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(),
5035 getTypeConstraintConcept(), getTypeConstraintArguments());
5036 }
5037
5038 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
5039 QualType Deduced, AutoTypeKeyword Keyword,
5040 bool IsDependent, ConceptDecl *CD,
5041 ArrayRef<TemplateArgument> Arguments);
5042
5043 static bool classof(const Type *T) {
5044 return T->getTypeClass() == Auto;
5045 }
5046};
5047
5048/// Represents a C++17 deduced template specialization type.
5049class DeducedTemplateSpecializationType : public DeducedType,
5050 public llvm::FoldingSetNode {
5051 friend class ASTContext; // ASTContext creates these
5052
5053 /// The name of the template whose arguments will be deduced.
5054 TemplateName Template;
5055
5056 DeducedTemplateSpecializationType(TemplateName Template,
5057 QualType DeducedAsType,
5058 bool IsDeducedAsDependent)
5059 : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
5060 toTypeDependence(Template.getDependence()) |
5061 (IsDeducedAsDependent
5062 ? TypeDependence::DependentInstantiation
5063 : TypeDependence::None)),
5064 Template(Template) {}
5065
5066public:
5067 /// Retrieve the name of the template that we are deducing.
5068 TemplateName getTemplateName() const { return Template;}
5069
5070 void Profile(llvm::FoldingSetNodeID &ID) {
5071 Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
5072 }
5073
5074 static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
5075 QualType Deduced, bool IsDependent) {
5076 Template.Profile(ID);
5077 ID.AddPointer(Deduced.getAsOpaquePtr());
5078 ID.AddBoolean(IsDependent);
5079 }
5080
5081 static bool classof(const Type *T) {
5082 return T->getTypeClass() == DeducedTemplateSpecialization;
5083 }
5084};
5085
5086/// Represents a type template specialization; the template
5087/// must be a class template, a type alias template, or a template
5088/// template parameter. A template which cannot be resolved to one of
5089/// these, e.g. because it is written with a dependent scope
5090/// specifier, is instead represented as a
5091/// @c DependentTemplateSpecializationType.
5092///
5093/// A non-dependent template specialization type is always "sugar",
5094/// typically for a \c RecordType. For example, a class template
5095/// specialization type of \c vector<int> will refer to a tag type for
5096/// the instantiation \c std::vector<int, std::allocator<int>>
5097///
5098/// Template specializations are dependent if either the template or
5099/// any of the template arguments are dependent, in which case the
5100/// type may also be canonical.
5101///
5102/// Instances of this type are allocated with a trailing array of
5103/// TemplateArguments, followed by a QualType representing the
5104/// non-canonical aliased type when the template is a type alias
5105/// template.
5106class alignas(8) TemplateSpecializationType
5107 : public Type,
5108 public llvm::FoldingSetNode {
5109 friend class ASTContext; // ASTContext creates these
5110
5111 /// The name of the template being specialized. This is
5112 /// either a TemplateName::Template (in which case it is a
5113 /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
5114 /// TypeAliasTemplateDecl*), a
5115 /// TemplateName::SubstTemplateTemplateParmPack, or a
5116 /// TemplateName::SubstTemplateTemplateParm (in which case the
5117 /// replacement must, recursively, be one of these).
5118 TemplateName Template;
5119
5120 TemplateSpecializationType(TemplateName T,
5121 ArrayRef<TemplateArgument> Args,
5122 QualType Canon,
5123 QualType Aliased);
5124
5125public:
5126 /// Determine whether any of the given template arguments are dependent.
5127 ///
5128 /// The converted arguments should be supplied when known; whether an
5129 /// argument is dependent can depend on the conversions performed on it
5130 /// (for example, a 'const int' passed as a template argument might be
5131 /// dependent if the parameter is a reference but non-dependent if the
5132 /// parameter is an int).
5133 ///
5134 /// Note that the \p Args parameter is unused: this is intentional, to remind
5135 /// the caller that they need to pass in the converted arguments, not the
5136 /// specified arguments.
5137 static bool
5138 anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
5139 ArrayRef<TemplateArgument> Converted);
5140 static bool
5141 anyDependentTemplateArguments(const TemplateArgumentListInfo &,
5142 ArrayRef<TemplateArgument> Converted);
5143 static bool anyInstantiationDependentTemplateArguments(
5144 ArrayRef<TemplateArgumentLoc> Args);
5145
5146 /// True if this template specialization type matches a current
5147 /// instantiation in the context in which it is found.
5148 bool isCurrentInstantiation() const {
5149 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
5150 }
5151
5152 /// Determine if this template specialization type is for a type alias
5153 /// template that has been substituted.
5154 ///
5155 /// Nearly every template specialization type whose template is an alias
5156 /// template will be substituted. However, this is not the case when
5157 /// the specialization contains a pack expansion but the template alias
5158 /// does not have a corresponding parameter pack, e.g.,
5159 ///
5160 /// \code
5161 /// template<typename T, typename U, typename V> struct S;
5162 /// template<typename T, typename U> using A = S<T, int, U>;
5163 /// template<typename... Ts> struct X {
5164 /// typedef A<Ts...> type; // not a type alias
5165 /// };
5166 /// \endcode
5167 bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }
5168
5169 /// Get the aliased type, if this is a specialization of a type alias
5170 /// template.
5171 QualType getAliasedType() const {
5172 assert(isTypeAlias() && "not a type alias template specialization")(static_cast <bool> (isTypeAlias() && "not a type alias template specialization"
) ? void (0) : __assert_fail ("isTypeAlias() && \"not a type alias template specialization\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5172, __extension__ __PRETTY_FUNCTION__))
;
5173 return *reinterpret_cast<const QualType*>(end());
5174 }
5175
5176 using iterator = const TemplateArgument *;
5177
5178 iterator begin() const { return getArgs(); }
5179 iterator end() const; // defined inline in TemplateBase.h
5180
5181 /// Retrieve the name of the template that we are specializing.
5182 TemplateName getTemplateName() const { return Template; }
5183
5184 /// Retrieve the template arguments.
5185 const TemplateArgument *getArgs() const {
5186 return reinterpret_cast<const TemplateArgument *>(this + 1);
5187 }
5188
5189 /// Retrieve the number of template arguments.
5190 unsigned getNumArgs() const {
5191 return TemplateSpecializationTypeBits.NumArgs;
5192 }
5193
5194 /// Retrieve a specific template argument as a type.
5195 /// \pre \c isArgType(Arg)
5196 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5197
5198 ArrayRef<TemplateArgument> template_arguments() const {
5199 return {getArgs(), getNumArgs()};
5200 }
5201
5202 bool isSugared() const {
5203 return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
5204 }
5205
5206 QualType desugar() const {
5207 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
5208 }
5209
5210 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
5211 Profile(ID, Template, template_arguments(), Ctx);
5212 if (isTypeAlias())
5213 getAliasedType().Profile(ID);
5214 }
5215
5216 static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
5217 ArrayRef<TemplateArgument> Args,
5218 const ASTContext &Context);
5219
5220 static bool classof(const Type *T) {
5221 return T->getTypeClass() == TemplateSpecialization;
5222 }
5223};
5224
5225/// Print a template argument list, including the '<' and '>'
5226/// enclosing the template arguments.
5227void printTemplateArgumentList(raw_ostream &OS,
5228 ArrayRef<TemplateArgument> Args,
5229 const PrintingPolicy &Policy,
5230 const TemplateParameterList *TPL = nullptr);
5231
5232void printTemplateArgumentList(raw_ostream &OS,
5233 ArrayRef<TemplateArgumentLoc> Args,
5234 const PrintingPolicy &Policy,
5235 const TemplateParameterList *TPL = nullptr);
5236
5237void printTemplateArgumentList(raw_ostream &OS,
5238 const TemplateArgumentListInfo &Args,
5239 const PrintingPolicy &Policy,
5240 const TemplateParameterList *TPL = nullptr);
5241
5242/// The injected class name of a C++ class template or class
5243/// template partial specialization. Used to record that a type was
5244/// spelled with a bare identifier rather than as a template-id; the
5245/// equivalent for non-templated classes is just RecordType.
5246///
5247/// Injected class name types are always dependent. Template
5248/// instantiation turns these into RecordTypes.
5249///
5250/// Injected class name types are always canonical. This works
5251/// because it is impossible to compare an injected class name type
5252/// with the corresponding non-injected template type, for the same
5253/// reason that it is impossible to directly compare template
5254/// parameters from different dependent contexts: injected class name
5255/// types can only occur within the scope of a particular templated
5256/// declaration, and within that scope every template specialization
5257/// will canonicalize to the injected class name (when appropriate
5258/// according to the rules of the language).
5259class InjectedClassNameType : public Type {
5260 friend class ASTContext; // ASTContext creates these.
5261 friend class ASTNodeImporter;
5262 friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
5263 // currently suitable for AST reading, too much
5264 // interdependencies.
5265 template <class T> friend class serialization::AbstractTypeReader;
5266
5267 CXXRecordDecl *Decl;
5268
5269 /// The template specialization which this type represents.
5270 /// For example, in
5271 /// template <class T> class A { ... };
5272 /// this is A<T>, whereas in
5273 /// template <class X, class Y> class A<B<X,Y> > { ... };
5274 /// this is A<B<X,Y> >.
5275 ///
5276 /// It is always unqualified, always a template specialization type,
5277 /// and always dependent.
5278 QualType InjectedType;
5279
5280 InjectedClassNameType(CXXRecordDecl *D, QualType TST)
5281 : Type(InjectedClassName, QualType(),
5282 TypeDependence::DependentInstantiation),
5283 Decl(D), InjectedType(TST) {
5284 assert(isa<TemplateSpecializationType>(TST))(static_cast <bool> (isa<TemplateSpecializationType>
(TST)) ? void (0) : __assert_fail ("isa<TemplateSpecializationType>(TST)"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5284, __extension__ __PRETTY_FUNCTION__))
;
5285 assert(!TST.hasQualifiers())(static_cast <bool> (!TST.hasQualifiers()) ? void (0) :
__assert_fail ("!TST.hasQualifiers()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5285, __extension__ __PRETTY_FUNCTION__))
;
5286 assert(TST->isDependentType())(static_cast <bool> (TST->isDependentType()) ? void (
0) : __assert_fail ("TST->isDependentType()", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5286, __extension__ __PRETTY_FUNCTION__))
;
5287 }
5288
5289public:
5290 QualType getInjectedSpecializationType() const { return InjectedType; }
5291
5292 const TemplateSpecializationType *getInjectedTST() const {
5293 return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
5294 }
5295
5296 TemplateName getTemplateName() const {
5297 return getInjectedTST()->getTemplateName();
5298 }
5299
5300 CXXRecordDecl *getDecl() const;
5301
5302 bool isSugared() const { return false; }
5303 QualType desugar() const { return QualType(this, 0); }
5304
5305 static bool classof(const Type *T) {
5306 return T->getTypeClass() == InjectedClassName;
5307 }
5308};
5309
5310/// The kind of a tag type.
5311enum TagTypeKind {
5312 /// The "struct" keyword.
5313 TTK_Struct,
5314
5315 /// The "__interface" keyword.
5316 TTK_Interface,
5317
5318 /// The "union" keyword.
5319 TTK_Union,
5320
5321 /// The "class" keyword.
5322 TTK_Class,
5323
5324 /// The "enum" keyword.
5325 TTK_Enum
5326};
5327
5328/// The elaboration keyword that precedes a qualified type name or
5329/// introduces an elaborated-type-specifier.
5330enum ElaboratedTypeKeyword {
5331 /// The "struct" keyword introduces the elaborated-type-specifier.
5332 ETK_Struct,
5333
5334 /// The "__interface" keyword introduces the elaborated-type-specifier.
5335 ETK_Interface,
5336
5337 /// The "union" keyword introduces the elaborated-type-specifier.
5338 ETK_Union,
5339
5340 /// The "class" keyword introduces the elaborated-type-specifier.
5341 ETK_Class,
5342
5343 /// The "enum" keyword introduces the elaborated-type-specifier.
5344 ETK_Enum,
5345
5346 /// The "typename" keyword precedes the qualified type name, e.g.,
5347 /// \c typename T::type.
5348 ETK_Typename,
5349
5350 /// No keyword precedes the qualified type name.
5351 ETK_None
5352};
5353
5354/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5355/// The keyword in stored in the free bits of the base class.
5356/// Also provides a few static helpers for converting and printing
5357/// elaborated type keyword and tag type kind enumerations.
5358class TypeWithKeyword : public Type {
5359protected:
5360 TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
5361 QualType Canonical, TypeDependence Dependence)
5362 : Type(tc, Canonical, Dependence) {
5363 TypeWithKeywordBits.Keyword = Keyword;
5364 }
5365
5366public:
5367 ElaboratedTypeKeyword getKeyword() const {
5368 return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
5369 }
5370
5371 /// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
5372 static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);
5373
5374 /// Converts a type specifier (DeclSpec::TST) into a tag type kind.
5375 /// It is an error to provide a type specifier which *isn't* a tag kind here.
5376 static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);
5377
5378 /// Converts a TagTypeKind into an elaborated type keyword.
5379 static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);
5380
5381 /// Converts an elaborated type keyword into a TagTypeKind.
5382 /// It is an error to provide an elaborated type keyword
5383 /// which *isn't* a tag kind here.
5384 static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);
5385
5386 static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);
5387
5388 static StringRef getKeywordName(ElaboratedTypeKeyword Keyword);
5389
5390 static StringRef getTagTypeKindName(TagTypeKind Kind) {
5391 return getKeywordName(getKeywordForTagTypeKind(Kind));
5392 }
5393
5394 class CannotCastToThisType {};
5395 static CannotCastToThisType classof(const Type *);
5396};
5397
5398/// Represents a type that was referred to using an elaborated type
5399/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5400/// or both.
5401///
5402/// This type is used to keep track of a type name as written in the
5403/// source code, including tag keywords and any nested-name-specifiers.
5404/// The type itself is always "sugar", used to express what was written
5405/// in the source code but containing no additional semantic information.
5406class ElaboratedType final
5407 : public TypeWithKeyword,
5408 public llvm::FoldingSetNode,
5409 private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
5410 friend class ASTContext; // ASTContext creates these
5411 friend TrailingObjects;
5412
5413 /// The nested name specifier containing the qualifier.
5414 NestedNameSpecifier *NNS;
5415
5416 /// The type that this qualified name refers to.
5417 QualType NamedType;
5418
5419 /// The (re)declaration of this tag type owned by this occurrence is stored
5420 /// as a trailing object if there is one. Use getOwnedTagDecl to obtain
5421 /// it, or obtain a null pointer if there is none.
5422
5423 ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
5424 QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
5425 : TypeWithKeyword(Keyword, Elaborated, CanonType,
5426 // Any semantic dependence on the qualifier will have
5427 // been incorporated into NamedType. We still need to
5428 // track syntactic (instantiation / error / pack)
5429 // dependence on the qualifier.
5430 NamedType->getDependence() |
5431 (NNS ? toSyntacticDependence(
5432 toTypeDependence(NNS->getDependence()))
5433 : TypeDependence::None)),
5434 NNS(NNS), NamedType(NamedType) {
5435 ElaboratedTypeBits.HasOwnedTagDecl = false;
5436 if (OwnedTagDecl) {
5437 ElaboratedTypeBits.HasOwnedTagDecl = true;
5438 *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
5439 }
5440 assert(!(Keyword == ETK_None && NNS == nullptr) &&(static_cast <bool> (!(Keyword == ETK_None && NNS
== nullptr) && "ElaboratedType cannot have elaborated type keyword "
"and name qualifier both null.") ? void (0) : __assert_fail (
"!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5442, __extension__ __PRETTY_FUNCTION__))
5441 "ElaboratedType cannot have elaborated type keyword "(static_cast <bool> (!(Keyword == ETK_None && NNS
== nullptr) && "ElaboratedType cannot have elaborated type keyword "
"and name qualifier both null.") ? void (0) : __assert_fail (
"!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5442, __extension__ __PRETTY_FUNCTION__))
5442 "and name qualifier both null.")(static_cast <bool> (!(Keyword == ETK_None && NNS
== nullptr) && "ElaboratedType cannot have elaborated type keyword "
"and name qualifier both null.") ? void (0) : __assert_fail (
"!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5442, __extension__ __PRETTY_FUNCTION__))
;
5443 }
5444
5445public:
5446 /// Retrieve the qualification on this type.
5447 NestedNameSpecifier *getQualifier() const { return NNS; }
5448
5449 /// Retrieve the type named by the qualified-id.
5450 QualType getNamedType() const { return NamedType; }
5451
5452 /// Remove a single level of sugar.
5453 QualType desugar() const { return getNamedType(); }
5454
5455 /// Returns whether this type directly provides sugar.
5456 bool isSugared() const { return true; }
5457
5458 /// Return the (re)declaration of this type owned by this occurrence of this
5459 /// type, or nullptr if there is none.
5460 TagDecl *getOwnedTagDecl() const {
5461 return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
5462 : nullptr;
5463 }
5464
5465 void Profile(llvm::FoldingSetNodeID &ID) {
5466 Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
5467 }
5468
5469 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
5470 NestedNameSpecifier *NNS, QualType NamedType,
5471 TagDecl *OwnedTagDecl) {
5472 ID.AddInteger(Keyword);
5473 ID.AddPointer(NNS);
5474 NamedType.Profile(ID);
5475 ID.AddPointer(OwnedTagDecl);
5476 }
5477
5478 static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5479};
5480
5481/// Represents a qualified type name for which the type name is
5482/// dependent.
5483///
5484/// DependentNameType represents a class of dependent types that involve a
5485/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5486/// name of a type. The DependentNameType may start with a "typename" (for a
5487/// typename-specifier), "class", "struct", "union", or "enum" (for a
5488/// dependent elaborated-type-specifier), or nothing (in contexts where we
5489/// know that we must be referring to a type, e.g., in a base class specifier).
5490/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5491/// mode, this type is used with non-dependent names to delay name lookup until
5492/// instantiation.
5493class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
5494 friend class ASTContext; // ASTContext creates these
5495
5496 /// The nested name specifier containing the qualifier.
5497 NestedNameSpecifier *NNS;
5498
5499 /// The type that this typename specifier refers to.
5500 const IdentifierInfo *Name;
5501
5502 DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
5503 const IdentifierInfo *Name, QualType CanonType)
5504 : TypeWithKeyword(Keyword, DependentName, CanonType,
5505 TypeDependence::DependentInstantiation |
5506 toTypeDependence(NNS->getDependence())),
5507 NNS(NNS), Name(Name) {}
5508
5509public:
5510 /// Retrieve the qualification on this type.
5511 NestedNameSpecifier *getQualifier() const { return NNS; }
5512
5513 /// Retrieve the type named by the typename specifier as an identifier.
5514 ///
5515 /// This routine will return a non-NULL identifier pointer when the
5516 /// form of the original typename was terminated by an identifier,
5517 /// e.g., "typename T::type".
5518 const IdentifierInfo *getIdentifier() const {
5519 return Name;
5520 }
5521
5522 bool isSugared() const { return false; }
5523 QualType desugar() const { return QualType(this, 0); }
5524
5525 void Profile(llvm::FoldingSetNodeID &ID) {
5526 Profile(ID, getKeyword(), NNS, Name);
5527 }
5528
5529 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
5530 NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
5531 ID.AddInteger(Keyword);
5532 ID.AddPointer(NNS);
5533 ID.AddPointer(Name);
5534 }
5535
5536 static bool classof(const Type *T) {
5537 return T->getTypeClass() == DependentName;
5538 }
5539};
5540
5541/// Represents a template specialization type whose template cannot be
5542/// resolved, e.g.
5543/// A<T>::template B<T>
5544class alignas(8) DependentTemplateSpecializationType
5545 : public TypeWithKeyword,
5546 public llvm::FoldingSetNode {
5547 friend class ASTContext; // ASTContext creates these
5548
5549 /// The nested name specifier containing the qualifier.
5550 NestedNameSpecifier *NNS;
5551
5552 /// The identifier of the template.
5553 const IdentifierInfo *Name;
5554
5555 DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
5556 NestedNameSpecifier *NNS,
5557 const IdentifierInfo *Name,
5558 ArrayRef<TemplateArgument> Args,
5559 QualType Canon);
5560
5561 const TemplateArgument *getArgBuffer() const {
5562 return reinterpret_cast<const TemplateArgument*>(this+1);
5563 }
5564
5565 TemplateArgument *getArgBuffer() {
5566 return reinterpret_cast<TemplateArgument*>(this+1);
5567 }
5568
5569public:
5570 NestedNameSpecifier *getQualifier() const { return NNS; }
5571 const IdentifierInfo *getIdentifier() const { return Name; }
5572
5573 /// Retrieve the template arguments.
5574 const TemplateArgument *getArgs() const {
5575 return getArgBuffer();
5576 }
5577
5578 /// Retrieve the number of template arguments.
5579 unsigned getNumArgs() const {
5580 return DependentTemplateSpecializationTypeBits.NumArgs;
5581 }
5582
5583 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5584
5585 ArrayRef<TemplateArgument> template_arguments() const {
5586 return {getArgs(), getNumArgs()};
5587 }
5588
5589 using iterator = const TemplateArgument *;
5590
5591 iterator begin() const { return getArgs(); }
5592 iterator end() const; // inline in TemplateBase.h
5593
5594 bool isSugared() const { return false; }
5595 QualType desugar() const { return QualType(this, 0); }
5596
5597 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
5598 Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()});
5599 }
5600
5601 static void Profile(llvm::FoldingSetNodeID &ID,
5602 const ASTContext &Context,
5603 ElaboratedTypeKeyword Keyword,
5604 NestedNameSpecifier *Qualifier,
5605 const IdentifierInfo *Name,
5606 ArrayRef<TemplateArgument> Args);
5607
5608 static bool classof(const Type *T) {
5609 return T->getTypeClass() == DependentTemplateSpecialization;
5610 }
5611};
5612
5613/// Represents a pack expansion of types.
5614///
5615/// Pack expansions are part of C++11 variadic templates. A pack
5616/// expansion contains a pattern, which itself contains one or more
5617/// "unexpanded" parameter packs. When instantiated, a pack expansion
5618/// produces a series of types, each instantiated from the pattern of
5619/// the expansion, where the Ith instantiation of the pattern uses the
5620/// Ith arguments bound to each of the unexpanded parameter packs. The
5621/// pack expansion is considered to "expand" these unexpanded
5622/// parameter packs.
5623///
5624/// \code
5625/// template<typename ...Types> struct tuple;
5626///
5627/// template<typename ...Types>
5628/// struct tuple_of_references {
5629/// typedef tuple<Types&...> type;
5630/// };
5631/// \endcode
5632///
5633/// Here, the pack expansion \c Types&... is represented via a
5634/// PackExpansionType whose pattern is Types&.
5635class PackExpansionType : public Type, public llvm::FoldingSetNode {
5636 friend class ASTContext; // ASTContext creates these
5637
5638 /// The pattern of the pack expansion.
5639 QualType Pattern;
5640
5641 PackExpansionType(QualType Pattern, QualType Canon,
5642 Optional<unsigned> NumExpansions)
5643 : Type(PackExpansion, Canon,
5644 (Pattern->getDependence() | TypeDependence::Dependent |
5645 TypeDependence::Instantiation) &
5646 ~TypeDependence::UnexpandedPack),
5647 Pattern(Pattern) {
5648 PackExpansionTypeBits.NumExpansions =
5649 NumExpansions ? *NumExpansions + 1 : 0;
5650 }
5651
5652public:
5653 /// Retrieve the pattern of this pack expansion, which is the
5654 /// type that will be repeatedly instantiated when instantiating the
5655 /// pack expansion itself.
5656 QualType getPattern() const { return Pattern; }
5657
5658 /// Retrieve the number of expansions that this pack expansion will
5659 /// generate, if known.
5660 Optional<unsigned> getNumExpansions() const {
5661 if (PackExpansionTypeBits.NumExpansions)
5662 return PackExpansionTypeBits.NumExpansions - 1;
5663 return None;
5664 }
5665
5666 bool isSugared() const { return false; }
5667 QualType desugar() const { return QualType(this, 0); }
5668
5669 void Profile(llvm::FoldingSetNodeID &ID) {
5670 Profile(ID, getPattern(), getNumExpansions());
5671 }
5672
5673 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
5674 Optional<unsigned> NumExpansions) {
5675 ID.AddPointer(Pattern.getAsOpaquePtr());
5676 ID.AddBoolean(NumExpansions.hasValue());
5677 if (NumExpansions)
5678 ID.AddInteger(*NumExpansions);
5679 }
5680
5681 static bool classof(const Type *T) {
5682 return T->getTypeClass() == PackExpansion;
5683 }
5684};
5685
5686/// This class wraps the list of protocol qualifiers. For types that can
5687/// take ObjC protocol qualifers, they can subclass this class.
5688template <class T>
5689class ObjCProtocolQualifiers {
5690protected:
5691 ObjCProtocolQualifiers() = default;
5692
5693 ObjCProtocolDecl * const *getProtocolStorage() const {
5694 return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
5695 }
5696
5697 ObjCProtocolDecl **getProtocolStorage() {
5698 return static_cast<T*>(this)->getProtocolStorageImpl();
5699 }
5700
5701 void setNumProtocols(unsigned N) {
5702 static_cast<T*>(this)->setNumProtocolsImpl(N);
5703 }
5704
5705 void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
5706 setNumProtocols(protocols.size());
5707 assert(getNumProtocols() == protocols.size() &&(static_cast <bool> (getNumProtocols() == protocols.size
() && "bitfield overflow in protocol count") ? void (
0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5708, __extension__ __PRETTY_FUNCTION__))
5708 "bitfield overflow in protocol count")(static_cast <bool> (getNumProtocols() == protocols.size
() && "bitfield overflow in protocol count") ? void (
0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5708, __extension__ __PRETTY_FUNCTION__))
;
5709 if (!protocols.empty())
5710 memcpy(getProtocolStorage(), protocols.data(),
5711 protocols.size() * sizeof(ObjCProtocolDecl*));
5712 }
5713
5714public:
5715 using qual_iterator = ObjCProtocolDecl * const *;
5716 using qual_range = llvm::iterator_range<qual_iterator>;
5717
5718 qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
5719 qual_iterator qual_begin() const { return getProtocolStorage(); }
5720 qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }
5721
5722 bool qual_empty() const { return getNumProtocols() == 0; }
5723
5724 /// Return the number of qualifying protocols in this type, or 0 if
5725 /// there are none.
5726 unsigned getNumProtocols() const {
5727 return static_cast<const T*>(this)->getNumProtocolsImpl();
5728 }
5729
5730 /// Fetch a protocol by index.
5731 ObjCProtocolDecl *getProtocol(unsigned I) const {
5732 assert(I < getNumProtocols() && "Out-of-range protocol access")(static_cast <bool> (I < getNumProtocols() &&
"Out-of-range protocol access") ? void (0) : __assert_fail (
"I < getNumProtocols() && \"Out-of-range protocol access\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5732, __extension__ __PRETTY_FUNCTION__))
;
5733 return qual_begin()[I];
5734 }
5735
5736 /// Retrieve all of the protocol qualifiers.
5737 ArrayRef<ObjCProtocolDecl *> getProtocols() const {
5738 return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
5739 }
5740};
5741
5742/// Represents a type parameter type in Objective C. It can take
5743/// a list of protocols.
5744class ObjCTypeParamType : public Type,
5745 public ObjCProtocolQualifiers<ObjCTypeParamType>,
5746 public llvm::FoldingSetNode {
5747 friend class ASTContext;
5748 friend class ObjCProtocolQualifiers<ObjCTypeParamType>;
5749
5750 /// The number of protocols stored on this type.
5751 unsigned NumProtocols : 6;
5752
5753 ObjCTypeParamDecl *OTPDecl;
5754
5755 /// The protocols are stored after the ObjCTypeParamType node. In the
5756 /// canonical type, the list of protocols are sorted alphabetically
5757 /// and uniqued.
5758 ObjCProtocolDecl **getProtocolStorageImpl();
5759
5760 /// Return the number of qualifying protocols in this interface type,
5761 /// or 0 if there are none.
5762 unsigned getNumProtocolsImpl() const {
5763 return NumProtocols;
5764 }
5765
5766 void setNumProtocolsImpl(unsigned N) {
5767 NumProtocols = N;
5768 }
5769
5770 ObjCTypeParamType(const ObjCTypeParamDecl *D,
5771 QualType can,
5772 ArrayRef<ObjCProtocolDecl *> protocols);
5773
5774public:
5775 bool isSugared() const { return true; }
5776 QualType desugar() const { return getCanonicalTypeInternal(); }
5777
5778 static bool classof(const Type *T) {
5779 return T->getTypeClass() == ObjCTypeParam;
5780 }
5781
5782 void Profile(llvm::FoldingSetNodeID &ID);
5783 static void Profile(llvm::FoldingSetNodeID &ID,
5784 const ObjCTypeParamDecl *OTPDecl,
5785 QualType CanonicalType,
5786 ArrayRef<ObjCProtocolDecl *> protocols);
5787
5788 ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5789};
5790
5791/// Represents a class type in Objective C.
5792///
5793/// Every Objective C type is a combination of a base type, a set of
5794/// type arguments (optional, for parameterized classes) and a list of
5795/// protocols.
5796///
5797/// Given the following declarations:
5798/// \code
5799/// \@class C<T>;
5800/// \@protocol P;
5801/// \endcode
5802///
5803/// 'C' is an ObjCInterfaceType C. It is sugar for an ObjCObjectType
5804/// with base C and no protocols.
5805///
5806/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5807/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5808/// protocol list.
5809/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5810/// and protocol list [P].
5811///
5812/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5813/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5814/// and no protocols.
5815///
5816/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5817/// with base BuiltinType::ObjCIdType and protocol list [P]. Eventually
5818/// this should get its own sugar class to better represent the source.
5819class ObjCObjectType : public Type,
5820 public ObjCProtocolQualifiers<ObjCObjectType> {
5821 friend class ObjCProtocolQualifiers<ObjCObjectType>;
5822
5823 // ObjCObjectType.NumTypeArgs - the number of type arguments stored
5824 // after the ObjCObjectPointerType node.
5825 // ObjCObjectType.NumProtocols - the number of protocols stored
5826 // after the type arguments of ObjCObjectPointerType node.
5827 //
5828 // These protocols are those written directly on the type. If
5829 // protocol qualifiers ever become additive, the iterators will need
5830 // to get kindof complicated.
5831 //
5832 // In the canonical object type, these are sorted alphabetically
5833 // and uniqued.
5834
5835 /// Either a BuiltinType or an InterfaceType or sugar for either.
5836 QualType BaseType;
5837
5838 /// Cached superclass type.
5839 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
5840 CachedSuperClassType;
5841
5842 QualType *getTypeArgStorage();
5843 const QualType *getTypeArgStorage() const {
5844 return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
5845 }
5846
5847 ObjCProtocolDecl **getProtocolStorageImpl();
5848 /// Return the number of qualifying protocols in this interface type,
5849 /// or 0 if there are none.
5850 unsigned getNumProtocolsImpl() const {
5851 return ObjCObjectTypeBits.NumProtocols;
5852 }
5853 void setNumProtocolsImpl(unsigned N) {
5854 ObjCObjectTypeBits.NumProtocols = N;
5855 }
5856
5857protected:
5858 enum Nonce_ObjCInterface { Nonce_ObjCInterface };
5859
5860 ObjCObjectType(QualType Canonical, QualType Base,
5861 ArrayRef<QualType> typeArgs,
5862 ArrayRef<ObjCProtocolDecl *> protocols,
5863 bool isKindOf);
5864
5865 ObjCObjectType(enum Nonce_ObjCInterface)
5866 : Type(ObjCInterface, QualType(), TypeDependence::None),
5867 BaseType(QualType(this_(), 0)) {
5868 ObjCObjectTypeBits.NumProtocols = 0;
5869 ObjCObjectTypeBits.NumTypeArgs = 0;
5870 ObjCObjectTypeBits.IsKindOf = 0;
5871 }
5872
5873 void computeSuperClassTypeSlow() const;
5874
5875public:
5876 /// Gets the base type of this object type. This is always (possibly
5877 /// sugar for) one of:
5878 /// - the 'id' builtin type (as opposed to the 'id' type visible to the
5879 /// user, which is a typedef for an ObjCObjectPointerType)
5880 /// - the 'Class' builtin type (same caveat)
5881 /// - an ObjCObjectType (currently always an ObjCInterfaceType)
5882 QualType getBaseType() const { return BaseType; }
5883
5884 bool isObjCId() const {
5885 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
5886 }
5887
5888 bool isObjCClass() const {
5889 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
5890 }
5891
5892 bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
5893 bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
5894 bool isObjCUnqualifiedIdOrClass() const {
5895 if (!qual_empty()) return false;
5896 if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
5897 return T->getKind() == BuiltinType::ObjCId ||
5898 T->getKind() == BuiltinType::ObjCClass;
5899 return false;
5900 }
5901 bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
5902 bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }
5903
5904 /// Gets the interface declaration for this object type, if the base type
5905 /// really is an interface.
5906 ObjCInterfaceDecl *getInterface() const;
5907
5908 /// Determine whether this object type is "specialized", meaning
5909 /// that it has type arguments.
5910 bool isSpecialized() const;
5911
5912 /// Determine whether this object type was written with type arguments.
5913 bool isSpecializedAsWritten() const {
5914 return ObjCObjectTypeBits.NumTypeArgs > 0;
5915 }
5916
5917 /// Determine whether this object type is "unspecialized", meaning
5918 /// that it has no type arguments.
5919 bool isUnspecialized() const { return !isSpecialized(); }
5920
5921 /// Determine whether this object type is "unspecialized" as
5922 /// written, meaning that it has no type arguments.
5923 bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }
5924
5925 /// Retrieve the type arguments of this object type (semantically).
5926 ArrayRef<QualType> getTypeArgs() const;
5927
5928 /// Retrieve the type arguments of this object type as they were
5929 /// written.
5930 ArrayRef<QualType> getTypeArgsAsWritten() const {
5931 return llvm::makeArrayRef(getTypeArgStorage(),
5932 ObjCObjectTypeBits.NumTypeArgs);
5933 }
5934
5935 /// Whether this is a "__kindof" type as written.
5936 bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }
5937
5938 /// Whether this ia a "__kindof" type (semantically).
5939 bool isKindOfType() const;
5940
5941 /// Retrieve the type of the superclass of this object type.
5942 ///
5943 /// This operation substitutes any type arguments into the
5944 /// superclass of the current class type, potentially producing a
5945 /// specialization of the superclass type. Produces a null type if
5946 /// there is no superclass.
5947 QualType getSuperClassType() const {
5948 if (!CachedSuperClassType.getInt())
5949 computeSuperClassTypeSlow();
5950
5951 assert(CachedSuperClassType.getInt() && "Superclass not set?")(static_cast <bool> (CachedSuperClassType.getInt() &&
"Superclass not set?") ? void (0) : __assert_fail ("CachedSuperClassType.getInt() && \"Superclass not set?\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 5951, __extension__ __PRETTY_FUNCTION__))
;
5952 return QualType(CachedSuperClassType.getPointer(), 0);
5953 }
5954
5955 /// Strip off the Objective-C "kindof" type and (with it) any
5956 /// protocol qualifiers.
5957 QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;
5958
5959 bool isSugared() const { return false; }
5960 QualType desugar() const { return QualType(this, 0); }
5961
5962 static bool classof(const Type *T) {
5963 return T->getTypeClass() == ObjCObject ||
5964 T->getTypeClass() == ObjCInterface;
5965 }
5966};
5967
5968/// A class providing a concrete implementation
5969/// of ObjCObjectType, so as to not increase the footprint of
5970/// ObjCInterfaceType. Code outside of ASTContext and the core type
5971/// system should not reference this type.
5972class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
5973 friend class ASTContext;
5974
5975 // If anyone adds fields here, ObjCObjectType::getProtocolStorage()
5976 // will need to be modified.
5977
5978 ObjCObjectTypeImpl(QualType Canonical, QualType Base,
5979 ArrayRef<QualType> typeArgs,
5980 ArrayRef<ObjCProtocolDecl *> protocols,
5981 bool isKindOf)
5982 : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}
5983
5984public:
5985 void Profile(llvm::FoldingSetNodeID &ID);
5986 static void Profile(llvm::FoldingSetNodeID &ID,
5987 QualType Base,
5988 ArrayRef<QualType> typeArgs,
5989 ArrayRef<ObjCProtocolDecl *> protocols,
5990 bool isKindOf);
5991};
5992
5993inline QualType *ObjCObjectType::getTypeArgStorage() {
5994 return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5995}
5996
5997inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
5998 return reinterpret_cast<ObjCProtocolDecl**>(
5999 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
6000}
6001
6002inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
6003 return reinterpret_cast<ObjCProtocolDecl**>(
6004 static_cast<ObjCTypeParamType*>(this)+1);
6005}
6006
6007/// Interfaces are the core concept in Objective-C for object oriented design.
6008/// They basically correspond to C++ classes. There are two kinds of interface
6009/// types: normal interfaces like `NSString`, and qualified interfaces, which
6010/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
6011///
6012/// ObjCInterfaceType guarantees the following properties when considered
6013/// as a subtype of its superclass, ObjCObjectType:
6014/// - There are no protocol qualifiers. To reinforce this, code which
6015/// tries to invoke the protocol methods via an ObjCInterfaceType will
6016/// fail to compile.
6017/// - It is its own base type. That is, if T is an ObjCInterfaceType*,
6018/// T->getBaseType() == QualType(T, 0).
6019class ObjCInterfaceType : public ObjCObjectType {
6020 friend class ASTContext; // ASTContext creates these.
6021 friend class ASTReader;
6022 friend class ObjCInterfaceDecl;
6023 template <class T> friend class serialization::AbstractTypeReader;
6024
6025 mutable ObjCInterfaceDecl *Decl;
6026
6027 ObjCInterfaceType(const ObjCInterfaceDecl *D)
6028 : ObjCObjectType(Nonce_ObjCInterface),
6029 Decl(const_cast<ObjCInterfaceDecl*>(D)) {}
6030
6031public:
6032 /// Get the declaration of this interface.
6033 ObjCInterfaceDecl *getDecl() const { return Decl; }
6034
6035 bool isSugared() const { return false; }
6036 QualType desugar() const { return QualType(this, 0); }
6037
6038 static bool classof(const Type *T) {
6039 return T->getTypeClass() == ObjCInterface;
6040 }
6041
6042 // Nonsense to "hide" certain members of ObjCObjectType within this
6043 // class. People asking for protocols on an ObjCInterfaceType are
6044 // not going to get what they want: ObjCInterfaceTypes are
6045 // guaranteed to have no protocols.
6046 enum {
6047 qual_iterator,
6048 qual_begin,
6049 qual_end,
6050 getNumProtocols,
6051 getProtocol
6052 };
6053};
6054
6055inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
6056 QualType baseType = getBaseType();
6057 while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
6058 if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
6059 return T->getDecl();
6060
6061 baseType = ObjT->getBaseType();
6062 }
6063
6064 return nullptr;
6065}
6066
6067/// Represents a pointer to an Objective C object.
6068///
6069/// These are constructed from pointer declarators when the pointee type is
6070/// an ObjCObjectType (or sugar for one). In addition, the 'id' and 'Class'
6071/// types are typedefs for these, and the protocol-qualified types 'id<P>'
6072/// and 'Class<P>' are translated into these.
6073///
6074/// Pointers to pointers to Objective C objects are still PointerTypes;
6075/// only the first level of pointer gets it own type implementation.
6076class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
6077 friend class ASTContext; // ASTContext creates these.
6078
6079 QualType PointeeType;
6080
6081 ObjCObjectPointerType(QualType Canonical, QualType Pointee)
6082 : Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
6083 PointeeType(Pointee) {}
6084
6085public:
6086 /// Gets the type pointed to by this ObjC pointer.
6087 /// The result will always be an ObjCObjectType or sugar thereof.
6088 QualType getPointeeType() const { return PointeeType; }
6089
6090 /// Gets the type pointed to by this ObjC pointer. Always returns non-null.
6091 ///
6092 /// This method is equivalent to getPointeeType() except that
6093 /// it discards any typedefs (or other sugar) between this
6094 /// type and the "outermost" object type. So for:
6095 /// \code
6096 /// \@class A; \@protocol P; \@protocol Q;
6097 /// typedef A<P> AP;
6098 /// typedef A A1;
6099 /// typedef A1<P> A1P;
6100 /// typedef A1P<Q> A1PQ;
6101 /// \endcode
6102 /// For 'A*', getObjectType() will return 'A'.
6103 /// For 'A<P>*', getObjectType() will return 'A<P>'.
6104 /// For 'AP*', getObjectType() will return 'A<P>'.
6105 /// For 'A1*', getObjectType() will return 'A'.
6106 /// For 'A1<P>*', getObjectType() will return 'A1<P>'.
6107 /// For 'A1P*', getObjectType() will return 'A1<P>'.
6108 /// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
6109 /// adding protocols to a protocol-qualified base discards the
6110 /// old qualifiers (for now). But if it didn't, getObjectType()
6111 /// would return 'A1P<Q>' (and we'd have to make iterating over
6112 /// qualifiers more complicated).
6113 const ObjCObjectType *getObjectType() const {
6114 return PointeeType->castAs<ObjCObjectType>();
6115 }
6116
6117 /// If this pointer points to an Objective C
6118 /// \@interface type, gets the type for that interface. Any protocol
6119 /// qualifiers on the interface are ignored.
6120 ///
6121 /// \return null if the base type for this pointer is 'id' or 'Class'
6122 const ObjCInterfaceType *getInterfaceType() const;
6123
6124 /// If this pointer points to an Objective \@interface
6125 /// type, gets the declaration for that interface.
6126 ///
6127 /// \return null if the base type for this pointer is 'id' or 'Class'
6128 ObjCInterfaceDecl *getInterfaceDecl() const {
6129 return getObjectType()->getInterface();
6130 }
6131
6132 /// True if this is equivalent to the 'id' type, i.e. if
6133 /// its object type is the primitive 'id' type with no protocols.
6134 bool isObjCIdType() const {
6135 return getObjectType()->isObjCUnqualifiedId();
6136 }
6137
6138 /// True if this is equivalent to the 'Class' type,
6139 /// i.e. if its object tive is the primitive 'Class' type with no protocols.
6140 bool isObjCClassType() const {
6141 return getObjectType()->isObjCUnqualifiedClass();
6142 }
6143
6144 /// True if this is equivalent to the 'id' or 'Class' type,
6145 bool isObjCIdOrClassType() const {
6146 return getObjectType()->isObjCUnqualifiedIdOrClass();
6147 }
6148
6149 /// True if this is equivalent to 'id<P>' for some non-empty set of
6150 /// protocols.
6151 bool isObjCQualifiedIdType() const {
6152 return getObjectType()->isObjCQualifiedId();
6153 }
6154
6155 /// True if this is equivalent to 'Class<P>' for some non-empty set of
6156 /// protocols.
6157 bool isObjCQualifiedClassType() const {
6158 return getObjectType()->isObjCQualifiedClass();
6159 }
6160
6161 /// Whether this is a "__kindof" type.
6162 bool isKindOfType() const { return getObjectType()->isKindOfType(); }
6163
6164 /// Whether this type is specialized, meaning that it has type arguments.
6165 bool isSpecialized() const { return getObjectType()->isSpecialized(); }
6166
6167 /// Whether this type is specialized, meaning that it has type arguments.
6168 bool isSpecializedAsWritten() const {
6169 return getObjectType()->isSpecializedAsWritten();
6170 }
6171
6172 /// Whether this type is unspecialized, meaning that is has no type arguments.
6173 bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }
6174
6175 /// Determine whether this object type is "unspecialized" as
6176 /// written, meaning that it has no type arguments.
6177 bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }
6178
6179 /// Retrieve the type arguments for this type.
6180 ArrayRef<QualType> getTypeArgs() const {
6181 return getObjectType()->getTypeArgs();
6182 }
6183
6184 /// Retrieve the type arguments for this type.
6185 ArrayRef<QualType> getTypeArgsAsWritten() const {
6186 return getObjectType()->getTypeArgsAsWritten();
6187 }
6188
6189 /// An iterator over the qualifiers on the object type. Provided
6190 /// for convenience. This will always iterate over the full set of
6191 /// protocols on a type, not just those provided directly.
6192 using qual_iterator = ObjCObjectType::qual_iterator;
6193 using qual_range = llvm::iterator_range<qual_iterator>;
6194
6195 qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
6196
6197 qual_iterator qual_begin() const {
6198 return getObjectType()->qual_begin();
6199 }
6200
6201 qual_iterator qual_end() const {
6202 return getObjectType()->qual_end();
6203 }
6204
6205 bool qual_empty() const { return getObjectType()->qual_empty(); }
6206
6207 /// Return the number of qualifying protocols on the object type.
6208 unsigned getNumProtocols() const {
6209 return getObjectType()->getNumProtocols();
6210 }
6211
6212 /// Retrieve a qualifying protocol by index on the object type.
6213 ObjCProtocolDecl *getProtocol(unsigned I) const {
6214 return getObjectType()->getProtocol(I);
6215 }
6216
6217 bool isSugared() const { return false; }
6218 QualType desugar() const { return QualType(this, 0); }
6219
6220 /// Retrieve the type of the superclass of this object pointer type.
6221 ///
6222 /// This operation substitutes any type arguments into the
6223 /// superclass of the current class type, potentially producing a
6224 /// pointer to a specialization of the superclass type. Produces a
6225 /// null type if there is no superclass.
6226 QualType getSuperClassType() const;
6227
6228 /// Strip off the Objective-C "kindof" type and (with it) any
6229 /// protocol qualifiers.
6230 const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
6231 const ASTContext &ctx) const;
6232
6233 void Profile(llvm::FoldingSetNodeID &ID) {
6234 Profile(ID, getPointeeType());
6235 }
6236
6237 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
6238 ID.AddPointer(T.getAsOpaquePtr());
6239 }
6240
6241 static bool classof(const Type *T) {
6242 return T->getTypeClass() == ObjCObjectPointer;
6243 }
6244};
6245
6246class AtomicType : public Type, public llvm::FoldingSetNode {
6247 friend class ASTContext; // ASTContext creates these.
6248
6249 QualType ValueType;
6250
6251 AtomicType(QualType ValTy, QualType Canonical)
6252 : Type(Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}
6253
6254public:
6255 /// Gets the type contained by this atomic type, i.e.
6256 /// the type returned by performing an atomic load of this atomic type.
6257 QualType getValueType() const { return ValueType; }
6258
6259 bool isSugared() const { return false; }
6260 QualType desugar() const { return QualType(this, 0); }
6261
6262 void Profile(llvm::FoldingSetNodeID &ID) {
6263 Profile(ID, getValueType());
6264 }
6265
6266 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
6267 ID.AddPointer(T.getAsOpaquePtr());
6268 }
6269
6270 static bool classof(const Type *T) {
6271 return T->getTypeClass() == Atomic;
6272 }
6273};
6274
6275/// PipeType - OpenCL20.
6276class PipeType : public Type, public llvm::FoldingSetNode {
6277 friend class ASTContext; // ASTContext creates these.
6278
6279 QualType ElementType;
6280 bool isRead;
6281
6282 PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
6283 : Type(Pipe, CanonicalPtr, elemType->getDependence()),
6284 ElementType(elemType), isRead(isRead) {}
6285
6286public:
6287 QualType getElementType() const { return ElementType; }
6288
6289 bool isSugared() const { return false; }
6290
6291 QualType desugar() const { return QualType(this, 0); }
6292
6293 void Profile(llvm::FoldingSetNodeID &ID) {
6294 Profile(ID, getElementType(), isReadOnly());
6295 }
6296
6297 static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
6298 ID.AddPointer(T.getAsOpaquePtr());
6299 ID.AddBoolean(isRead);
6300 }
6301
6302 static bool classof(const Type *T) {
6303 return T->getTypeClass() == Pipe;
6304 }
6305
6306 bool isReadOnly() const { return isRead; }
6307};
6308
6309/// A fixed int type of a specified bitwidth.
6310class ExtIntType final : public Type, public llvm::FoldingSetNode {
6311 friend class ASTContext;
6312 unsigned IsUnsigned : 1;
6313 unsigned NumBits : 24;
6314
6315protected:
6316 ExtIntType(bool isUnsigned, unsigned NumBits);
6317
6318public:
6319 bool isUnsigned() const { return IsUnsigned; }
6320 bool isSigned() const { return !IsUnsigned; }
6321 unsigned getNumBits() const { return NumBits; }
6322
6323 bool isSugared() const { return false; }
6324 QualType desugar() const { return QualType(this, 0); }
6325
6326 void Profile(llvm::FoldingSetNodeID &ID) {
6327 Profile(ID, isUnsigned(), getNumBits());
6328 }
6329
6330 static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned,
6331 unsigned NumBits) {
6332 ID.AddBoolean(IsUnsigned);
6333 ID.AddInteger(NumBits);
6334 }
6335
6336 static bool classof(const Type *T) { return T->getTypeClass() == ExtInt; }
6337};
6338
6339class DependentExtIntType final : public Type, public llvm::FoldingSetNode {
6340 friend class ASTContext;
6341 const ASTContext &Context;
6342 llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
6343
6344protected:
6345 DependentExtIntType(const ASTContext &Context, bool IsUnsigned,
6346 Expr *NumBits);
6347
6348public:
6349 bool isUnsigned() const;
6350 bool isSigned() const { return !isUnsigned(); }
6351 Expr *getNumBitsExpr() const;
6352
6353 bool isSugared() const { return false; }
6354 QualType desugar() const { return QualType(this, 0); }
6355
6356 void Profile(llvm::FoldingSetNodeID &ID) {
6357 Profile(ID, Context, isUnsigned(), getNumBitsExpr());
6358 }
6359 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
6360 bool IsUnsigned, Expr *NumBitsExpr);
6361
6362 static bool classof(const Type *T) {
6363 return T->getTypeClass() == DependentExtInt;
6364 }
6365};
6366
6367/// A qualifier set is used to build a set of qualifiers.
6368class QualifierCollector : public Qualifiers {
6369public:
6370 QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}
6371
6372 /// Collect any qualifiers on the given type and return an
6373 /// unqualified type. The qualifiers are assumed to be consistent
6374 /// with those already in the type.
6375 const Type *strip(QualType type) {
6376 addFastQualifiers(type.getLocalFastQualifiers());
6377 if (!type.hasLocalNonFastQualifiers())
6378 return type.getTypePtrUnsafe();
6379
6380 const ExtQuals *extQuals = type.getExtQualsUnsafe();
6381 addConsistentQualifiers(extQuals->getQualifiers());
6382 return extQuals->getBaseType();
6383 }
6384
6385 /// Apply the collected qualifiers to the given type.
6386 QualType apply(const ASTContext &Context, QualType QT) const;
6387
6388 /// Apply the collected qualifiers to the given type.
6389 QualType apply(const ASTContext &Context, const Type* T) const;
6390};
6391
6392/// A container of type source information.
6393///
6394/// A client can read the relevant info using TypeLoc wrappers, e.g:
6395/// @code
6396/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
6397/// TL.getBeginLoc().print(OS, SrcMgr);
6398/// @endcode
6399class alignas(8) TypeSourceInfo {
6400 // Contains a memory block after the class, used for type source information,
6401 // allocated by ASTContext.
6402 friend class ASTContext;
6403
6404 QualType Ty;
6405
6406 TypeSourceInfo(QualType ty) : Ty(ty) {}
6407
6408public:
6409 /// Return the type wrapped by this type source info.
6410 QualType getType() const { return Ty; }
6411
6412 /// Return the TypeLoc wrapper for the type source info.
6413 TypeLoc getTypeLoc() const; // implemented in TypeLoc.h
6414
6415 /// Override the type stored in this TypeSourceInfo. Use with caution!
6416 void overrideType(QualType T) { Ty = T; }
6417};
6418
6419// Inline function definitions.
6420
6421inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
6422 SplitQualType desugar =
6423 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
6424 desugar.Quals.addConsistentQualifiers(Quals);
6425 return desugar;
6426}
6427
6428inline const Type *QualType::getTypePtr() const {
6429 return getCommonPtr()->BaseType;
6430}
6431
6432inline const Type *QualType::getTypePtrOrNull() const {
6433 return (isNull() ? nullptr : getCommonPtr()->BaseType);
6434}
6435
6436inline SplitQualType QualType::split() const {
6437 if (!hasLocalNonFastQualifiers())
6438 return SplitQualType(getTypePtrUnsafe(),
6439 Qualifiers::fromFastMask(getLocalFastQualifiers()));
6440
6441 const ExtQuals *eq = getExtQualsUnsafe();
6442 Qualifiers qs = eq->getQualifiers();
6443 qs.addFastQualifiers(getLocalFastQualifiers());
6444 return SplitQualType(eq->getBaseType(), qs);
6445}
6446
6447inline Qualifiers QualType::getLocalQualifiers() const {
6448 Qualifiers Quals;
6449 if (hasLocalNonFastQualifiers())
6450 Quals = getExtQualsUnsafe()->getQualifiers();
6451 Quals.addFastQualifiers(getLocalFastQualifiers());
6452 return Quals;
6453}
6454
6455inline Qualifiers QualType::getQualifiers() const {
6456 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
6457 quals.addFastQualifiers(getLocalFastQualifiers());
6458 return quals;
6459}
6460
6461inline unsigned QualType::getCVRQualifiers() const {
6462 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
6463 cvr |= getLocalCVRQualifiers();
6464 return cvr;
6465}
6466
6467inline QualType QualType::getCanonicalType() const {
6468 QualType canon = getCommonPtr()->CanonicalType;
6469 return canon.withFastQualifiers(getLocalFastQualifiers());
6470}
6471
6472inline bool QualType::isCanonical() const {
6473 return getTypePtr()->isCanonicalUnqualified();
6474}
6475
6476inline bool QualType::isCanonicalAsParam() const {
6477 if (!isCanonical()) return false;
6478 if (hasLocalQualifiers()) return false;
6479
6480 const Type *T = getTypePtr();
6481 if (T->isVariablyModifiedType() && T->hasSizedVLAType())
6482 return false;
6483
6484 return !isa<FunctionType>(T) && !isa<ArrayType>(T);
6485}
6486
6487inline bool QualType::isConstQualified() const {
6488 return isLocalConstQualified() ||
6489 getCommonPtr()->CanonicalType.isLocalConstQualified();
6490}
6491
6492inline bool QualType::isRestrictQualified() const {
6493 return isLocalRestrictQualified() ||
6494 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6495}
6496
6497
6498inline bool QualType::isVolatileQualified() const {
6499 return isLocalVolatileQualified() ||
6500 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6501}
6502
6503inline bool QualType::hasQualifiers() const {
6504 return hasLocalQualifiers() ||
6505 getCommonPtr()->CanonicalType.hasLocalQualifiers();
6506}
6507
6508inline QualType QualType::getUnqualifiedType() const {
6509 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
6510 return QualType(getTypePtr(), 0);
6511
6512 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6513}
6514
6515inline SplitQualType QualType::getSplitUnqualifiedType() const {
6516 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
6517 return split();
6518
6519 return getSplitUnqualifiedTypeImpl(*this);
6520}
6521
6522inline void QualType::removeLocalConst() {
6523 removeLocalFastQualifiers(Qualifiers::Const);
6524}
6525
6526inline void QualType::removeLocalRestrict() {
6527 removeLocalFastQualifiers(Qualifiers::Restrict);
6528}
6529
6530inline void QualType::removeLocalVolatile() {
6531 removeLocalFastQualifiers(Qualifiers::Volatile);
6532}
6533
6534inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
6535 assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")(static_cast <bool> (!(Mask & ~Qualifiers::CVRMask)
&& "mask has non-CVR bits") ? void (0) : __assert_fail
("!(Mask & ~Qualifiers::CVRMask) && \"mask has non-CVR bits\""
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 6535, __extension__ __PRETTY_FUNCTION__))
;
6536 static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
6537 "Fast bits differ from CVR bits!");
6538
6539 // Fast path: we don't need to touch the slow qualifiers.
6540 removeLocalFastQualifiers(Mask);
6541}
6542
6543/// Check if this type has any address space qualifier.
6544inline bool QualType::hasAddressSpace() const {
6545 return getQualifiers().hasAddressSpace();
6546}
6547
6548/// Return the address space of this type.
6549inline LangAS QualType::getAddressSpace() const {
6550 return getQualifiers().getAddressSpace();
6551}
6552
6553/// Return the gc attribute of this type.
6554inline Qualifiers::GC QualType::getObjCGCAttr() const {
6555 return getQualifiers().getObjCGCAttr();
6556}
6557
6558inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
6559 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6560 return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
6561 return false;
6562}
6563
6564inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
6565 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6566 return hasNonTrivialToPrimitiveDestructCUnion(RD);
6567 return false;
6568}
6569
6570inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
6571 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6572 return hasNonTrivialToPrimitiveCopyCUnion(RD);
6573 return false;
6574}
6575
6576inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
6577 if (const auto *PT = t.getAs<PointerType>()) {
6578 if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
6579 return FT->getExtInfo();
6580 } else if (const auto *FT = t.getAs<FunctionType>())
6581 return FT->getExtInfo();
6582
6583 return FunctionType::ExtInfo();
6584}
6585
6586inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
6587 return getFunctionExtInfo(*t);
6588}
6589
6590/// Determine whether this type is more
6591/// qualified than the Other type. For example, "const volatile int"
6592/// is more qualified than "const int", "volatile int", and
6593/// "int". However, it is not more qualified than "const volatile
6594/// int".
6595inline bool QualType::isMoreQualifiedThan(QualType other) const {
6596 Qualifiers MyQuals = getQualifiers();
6597 Qualifiers OtherQuals = other.getQualifiers();
6598 return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6599}
6600
6601/// Determine whether this type is at last
6602/// as qualified as the Other type. For example, "const volatile
6603/// int" is at least as qualified as "const int", "volatile int",
6604/// "int", and "const volatile int".
6605inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
6606 Qualifiers OtherQuals = other.getQualifiers();
6607
6608 // Ignore __unaligned qualifier if this type is a void.
6609 if (getUnqualifiedType()->isVoidType())
6610 OtherQuals.removeUnaligned();
6611
6612 return getQualifiers().compatiblyIncludes(OtherQuals);
6613}
6614
6615/// If Type is a reference type (e.g., const
6616/// int&), returns the type that the reference refers to ("const
6617/// int"). Otherwise, returns the type itself. This routine is used
6618/// throughout Sema to implement C++ 5p6:
6619///
6620/// If an expression initially has the type "reference to T" (8.3.2,
6621/// 8.5.3), the type is adjusted to "T" prior to any further
6622/// analysis, the expression designates the object or function
6623/// denoted by the reference, and the expression is an lvalue.
6624inline QualType QualType::getNonReferenceType() const {
6625 if (const auto *RefType = (*this)->getAs<ReferenceType>())
6626 return RefType->getPointeeType();
6627 else
6628 return *this;
6629}
6630
6631inline bool QualType::isCForbiddenLValueType() const {
6632 return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
6633 getTypePtr()->isFunctionType());
6634}
6635
6636/// Tests whether the type is categorized as a fundamental type.
6637///
6638/// \returns True for types specified in C++0x [basic.fundamental].
6639inline bool Type::isFundamentalType() const {
6640 return isVoidType() ||
6641 isNullPtrType() ||
6642 // FIXME: It's really annoying that we don't have an
6643 // 'isArithmeticType()' which agrees with the standard definition.
6644 (isArithmeticType() && !isEnumeralType());
6645}
6646
6647/// Tests whether the type is categorized as a compound type.
6648///
6649/// \returns True for types specified in C++0x [basic.compound].
6650inline bool Type::isCompoundType() const {
6651 // C++0x [basic.compound]p1:
6652 // Compound types can be constructed in the following ways:
6653 // -- arrays of objects of a given type [...];
6654 return isArrayType() ||
6655 // -- functions, which have parameters of given types [...];
6656 isFunctionType() ||
6657 // -- pointers to void or objects or functions [...];
6658 isPointerType() ||
6659 // -- references to objects or functions of a given type. [...]
6660 isReferenceType() ||
6661 // -- classes containing a sequence of objects of various types, [...];
6662 isRecordType() ||
6663 // -- unions, which are classes capable of containing objects of different
6664 // types at different times;
6665 isUnionType() ||
6666 // -- enumerations, which comprise a set of named constant values. [...];
6667 isEnumeralType() ||
6668 // -- pointers to non-static class members, [...].
6669 isMemberPointerType();
6670}
6671
6672inline bool Type::isFunctionType() const {
6673 return isa<FunctionType>(CanonicalType);
6674}
6675
6676inline bool Type::isPointerType() const {
6677 return isa<PointerType>(CanonicalType);
6678}
6679
6680inline bool Type::isAnyPointerType() const {
6681 return isPointerType() || isObjCObjectPointerType();
6682}
6683
6684inline bool Type::isBlockPointerType() const {
6685 return isa<BlockPointerType>(CanonicalType);
6686}
6687
6688inline bool Type::isReferenceType() const {
6689 return isa<ReferenceType>(CanonicalType);
6690}
6691
6692inline bool Type::isLValueReferenceType() const {
6693 return isa<LValueReferenceType>(CanonicalType);
6694}
6695
6696inline bool Type::isRValueReferenceType() const {
6697 return isa<RValueReferenceType>(CanonicalType);
6698}
6699
6700inline bool Type::isObjectPointerType() const {
6701 // Note: an "object pointer type" is not the same thing as a pointer to an
6702 // object type; rather, it is a pointer to an object type or a pointer to cv
6703 // void.
6704 if (const auto *T = getAs<PointerType>())
6705 return !T->getPointeeType()->isFunctionType();
6706 else
6707 return false;
6708}
6709
6710inline bool Type::isFunctionPointerType() const {
6711 if (const auto *T = getAs<PointerType>())
6712 return T->getPointeeType()->isFunctionType();
6713 else
6714 return false;
6715}
6716
6717inline bool Type::isFunctionReferenceType() const {
6718 if (const auto *T = getAs<ReferenceType>())
6719 return T->getPointeeType()->isFunctionType();
6720 else
6721 return false;
6722}
6723
6724inline bool Type::isMemberPointerType() const {
6725 return isa<MemberPointerType>(CanonicalType);
6726}
6727
6728inline bool Type::isMemberFunctionPointerType() const {
6729 if (const auto *T = getAs<MemberPointerType>())
6730 return T->isMemberFunctionPointer();
6731 else
6732 return false;
6733}
6734
6735inline bool Type::isMemberDataPointerType() const {
6736 if (const auto *T = getAs<MemberPointerType>())
6737 return T->isMemberDataPointer();
6738 else
6739 return false;
6740}
6741
6742inline bool Type::isArrayType() const {
6743 return isa<ArrayType>(CanonicalType);
6744}
6745
6746inline bool Type::isConstantArrayType() const {
6747 return isa<ConstantArrayType>(CanonicalType);
6748}
6749
6750inline bool Type::isIncompleteArrayType() const {
6751 return isa<IncompleteArrayType>(CanonicalType);
6752}
6753
6754inline bool Type::isVariableArrayType() const {
6755 return isa<VariableArrayType>(CanonicalType);
6756}
6757
6758inline bool Type::isDependentSizedArrayType() const {
6759 return isa<DependentSizedArrayType>(CanonicalType);
6760}
6761
6762inline bool Type::isBuiltinType() const {
6763 return isa<BuiltinType>(CanonicalType);
6764}
6765
6766inline bool Type::isRecordType() const {
6767 return isa<RecordType>(CanonicalType);
18
Assuming field 'CanonicalType' is a 'RecordType'
19
Returning the value 1, which participates in a condition later
6768}
6769
6770inline bool Type::isEnumeralType() const {
6771 return isa<EnumType>(CanonicalType);
6772}
6773
6774inline bool Type::isAnyComplexType() const {
6775 return isa<ComplexType>(CanonicalType);
6776}
6777
6778inline bool Type::isVectorType() const {
6779 return isa<VectorType>(CanonicalType);
6780}
6781
6782inline bool Type::isExtVectorType() const {
6783 return isa<ExtVectorType>(CanonicalType);
6784}
6785
6786inline bool Type::isMatrixType() const {
6787 return isa<MatrixType>(CanonicalType);
6788}
6789
6790inline bool Type::isConstantMatrixType() const {
6791 return isa<ConstantMatrixType>(CanonicalType);
6792}
6793
6794inline bool Type::isDependentAddressSpaceType() const {
6795 return isa<DependentAddressSpaceType>(CanonicalType);
6796}
6797
6798inline bool Type::isObjCObjectPointerType() const {
6799 return isa<ObjCObjectPointerType>(CanonicalType);
6800}
6801
6802inline bool Type::isObjCObjectType() const {
6803 return isa<ObjCObjectType>(CanonicalType);
6804}
6805
6806inline bool Type::isObjCObjectOrInterfaceType() const {
6807 return isa<ObjCInterfaceType>(CanonicalType) ||
6808 isa<ObjCObjectType>(CanonicalType);
6809}
6810
6811inline bool Type::isAtomicType() const {
6812 return isa<AtomicType>(CanonicalType);
6813}
6814
6815inline bool Type::isUndeducedAutoType() const {
6816 return isa<AutoType>(CanonicalType);
6817}
6818
6819inline bool Type::isObjCQualifiedIdType() const {
6820 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6821 return OPT->isObjCQualifiedIdType();
6822 return false;
6823}
6824
6825inline bool Type::isObjCQualifiedClassType() const {
6826 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6827 return OPT->isObjCQualifiedClassType();
6828 return false;
6829}
6830
6831inline bool Type::isObjCIdType() const {
6832 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6833 return OPT->isObjCIdType();
6834 return false;
6835}
6836
6837inline bool Type::isObjCClassType() const {
6838 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6839 return OPT->isObjCClassType();
6840 return false;
6841}
6842
6843inline bool Type::isObjCSelType() const {
6844 if (const auto *OPT = getAs<PointerType>())
6845 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
6846 return false;
6847}
6848
6849inline bool Type::isObjCBuiltinType() const {
6850 return isObjCIdType() || isObjCClassType() || isObjCSelType();
6851}
6852
6853inline bool Type::isDecltypeType() const {
6854 return isa<DecltypeType>(this);
6855}
6856
6857#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6858 inline bool Type::is##Id##Type() const { \
6859 return isSpecificBuiltinType(BuiltinType::Id); \
6860 }
6861#include "clang/Basic/OpenCLImageTypes.def"
6862
6863inline bool Type::isSamplerT() const {
6864 return isSpecificBuiltinType(BuiltinType::OCLSampler);
6865}
6866
6867inline bool Type::isEventT() const {
6868 return isSpecificBuiltinType(BuiltinType::OCLEvent);
6869}
6870
6871inline bool Type::isClkEventT() const {
6872 return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6873}
6874
6875inline bool Type::isQueueT() const {
6876 return isSpecificBuiltinType(BuiltinType::OCLQueue);
6877}
6878
6879inline bool Type::isReserveIDT() const {
6880 return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6881}
6882
6883inline bool Type::isImageType() const {
6884#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
6885 return
6886#include "clang/Basic/OpenCLImageTypes.def"
6887 false; // end boolean or operation
6888}
6889
6890inline bool Type::isPipeType() const {
6891 return isa<PipeType>(CanonicalType);
6892}
6893
6894inline bool Type::isExtIntType() const {
6895 return isa<ExtIntType>(CanonicalType);
6896}
6897
6898#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6899 inline bool Type::is##Id##Type() const { \
6900 return isSpecificBuiltinType(BuiltinType::Id); \
6901 }
6902#include "clang/Basic/OpenCLExtensionTypes.def"
6903
6904inline bool Type::isOCLIntelSubgroupAVCType() const {
6905#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
6906 isOCLIntelSubgroupAVC##Id##Type() ||
6907 return
6908#include "clang/Basic/OpenCLExtensionTypes.def"
6909 false; // end of boolean or operation
6910}
6911
6912inline bool Type::isOCLExtOpaqueType() const {
6913#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
6914 return
6915#include "clang/Basic/OpenCLExtensionTypes.def"
6916 false; // end of boolean or operation
6917}
6918
6919inline bool Type::isOpenCLSpecificType() const {
6920 return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
6921 isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6922}
6923
6924inline bool Type::isTemplateTypeParmType() const {
6925 return isa<TemplateTypeParmType>(CanonicalType);
6926}
6927
6928inline bool Type::isSpecificBuiltinType(unsigned K) const {
6929 if (const BuiltinType *BT = getAs<BuiltinType>()) {
6930 return BT->getKind() == static_cast<BuiltinType::Kind>(K);
6931 }
6932 return false;
6933}
6934
6935inline bool Type::isPlaceholderType() const {
6936 if (const auto *BT = dyn_cast<BuiltinType>(this))
6937 return BT->isPlaceholderType();
6938 return false;
6939}
6940
6941inline const BuiltinType *Type::getAsPlaceholderType() const {
6942 if (const auto *BT = dyn_cast<BuiltinType>(this))
6943 if (BT->isPlaceholderType())
6944 return BT;
6945 return nullptr;
6946}
6947
6948inline bool Type::isSpecificPlaceholderType(unsigned K) const {
6949 assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))(static_cast <bool> (BuiltinType::isPlaceholderTypeKind
((BuiltinType::Kind) K)) ? void (0) : __assert_fail ("BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 6949, __extension__ __PRETTY_FUNCTION__))
;
6950 return isSpecificBuiltinType(K);
6951}
6952
6953inline bool Type::isNonOverloadPlaceholderType() const {
6954 if (const auto *BT = dyn_cast<BuiltinType>(this))
6955 return BT->isNonOverloadPlaceholderType();
6956 return false;
6957}
6958
6959inline bool Type::isVoidType() const {
6960 return isSpecificBuiltinType(BuiltinType::Void);
6961}
6962
6963inline bool Type::isHalfType() const {
6964 // FIXME: Should we allow complex __fp16? Probably not.
6965 return isSpecificBuiltinType(BuiltinType::Half);
6966}
6967
6968inline bool Type::isFloat16Type() const {
6969 return isSpecificBuiltinType(BuiltinType::Float16);
6970}
6971
6972inline bool Type::isBFloat16Type() const {
6973 return isSpecificBuiltinType(BuiltinType::BFloat16);
6974}
6975
6976inline bool Type::isFloat128Type() const {
6977 return isSpecificBuiltinType(BuiltinType::Float128);
6978}
6979
6980inline bool Type::isNullPtrType() const {
6981 return isSpecificBuiltinType(BuiltinType::NullPtr);
6982}
6983
6984bool IsEnumDeclComplete(EnumDecl *);
6985bool IsEnumDeclScoped(EnumDecl *);
6986
6987inline bool Type::isIntegerType() const {
6988 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6989 return BT->getKind() >= BuiltinType::Bool &&
6990 BT->getKind() <= BuiltinType::Int128;
6991 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
6992 // Incomplete enum types are not treated as integer types.
6993 // FIXME: In C++, enum types are never integer types.
6994 return IsEnumDeclComplete(ET->getDecl()) &&
6995 !IsEnumDeclScoped(ET->getDecl());
6996 }
6997 return isExtIntType();
6998}
6999
7000inline bool Type::isFixedPointType() const {
7001 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7002 return BT->getKind() >= BuiltinType::ShortAccum &&
7003 BT->getKind() <= BuiltinType::SatULongFract;
7004 }
7005 return false;
7006}
7007
7008inline bool Type::isFixedPointOrIntegerType() const {
7009 return isFixedPointType() || isIntegerType();
7010}
7011
7012inline bool Type::isSaturatedFixedPointType() const {
7013 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7014 return BT->getKind() >= BuiltinType::SatShortAccum &&
7015 BT->getKind() <= BuiltinType::SatULongFract;
7016 }
7017 return false;
7018}
7019
7020inline bool Type::isUnsaturatedFixedPointType() const {
7021 return isFixedPointType() && !isSaturatedFixedPointType();
7022}
7023
7024inline bool Type::isSignedFixedPointType() const {
7025 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
7026 return ((BT->getKind() >= BuiltinType::ShortAccum &&
7027 BT->getKind() <= BuiltinType::LongAccum) ||
7028 (BT->getKind() >= BuiltinType::ShortFract &&
7029 BT->getKind() <= BuiltinType::LongFract) ||
7030 (BT->getKind() >= BuiltinType::SatShortAccum &&
7031 BT->getKind() <= BuiltinType::SatLongAccum) ||
7032 (BT->getKind() >= BuiltinType::SatShortFract &&
7033 BT->getKind() <= BuiltinType::SatLongFract));
7034 }
7035 return false;
7036}
7037
7038inline bool Type::isUnsignedFixedPointType() const {
7039 return isFixedPointType() && !isSignedFixedPointType();
7040}
7041
7042inline bool Type::isScalarType() const {
7043 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7044 return BT->getKind() > BuiltinType::Void &&
7045 BT->getKind() <= BuiltinType::NullPtr;
7046 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
7047 // Enums are scalar types, but only if they are defined. Incomplete enums
7048 // are not treated as scalar types.
7049 return IsEnumDeclComplete(ET->getDecl());
7050 return isa<PointerType>(CanonicalType) ||
7051 isa<BlockPointerType>(CanonicalType) ||
7052 isa<MemberPointerType>(CanonicalType) ||
7053 isa<ComplexType>(CanonicalType) ||
7054 isa<ObjCObjectPointerType>(CanonicalType) ||
7055 isExtIntType();
7056}
7057
7058inline bool Type::isIntegralOrEnumerationType() const {
7059 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7060 return BT->getKind() >= BuiltinType::Bool &&
7061 BT->getKind() <= BuiltinType::Int128;
7062
7063 // Check for a complete enum type; incomplete enum types are not properly an
7064 // enumeration type in the sense required here.
7065 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
7066 return IsEnumDeclComplete(ET->getDecl());
7067
7068 return isExtIntType();
7069}
7070
7071inline bool Type::isBooleanType() const {
7072 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
7073 return BT->getKind() == BuiltinType::Bool;
7074 return false;
7075}
7076
7077inline bool Type::isUndeducedType() const {
7078 auto *DT = getContainedDeducedType();
7079 return DT && !DT->isDeduced();
7080}
7081
7082/// Determines whether this is a type for which one can define
7083/// an overloaded operator.
7084inline bool Type::isOverloadableType() const {
7085 return isDependentType() || isRecordType() || isEnumeralType();
7086}
7087
7088/// Determines whether this type is written as a typedef-name.
7089inline bool Type::isTypedefNameType() const {
7090 if (getAs<TypedefType>())
7091 return true;
7092 if (auto *TST = getAs<TemplateSpecializationType>())
7093 return TST->isTypeAlias();
7094 return false;
7095}
7096
7097/// Determines whether this type can decay to a pointer type.
7098inline bool Type::canDecayToPointerType() const {
7099 return isFunctionType() || isArrayType();
7100}
7101
7102inline bool Type::hasPointerRepresentation() const {
7103 return (isPointerType() || isReferenceType() || isBlockPointerType() ||
7104 isObjCObjectPointerType() || isNullPtrType());
7105}
7106
7107inline bool Type::hasObjCPointerRepresentation() const {
7108 return isObjCObjectPointerType();
7109}
7110
7111inline const Type *Type::getBaseElementTypeUnsafe() const {
7112 const Type *type = this;
7113 while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
7114 type = arrayType->getElementType().getTypePtr();
7115 return type;
7116}
7117
7118inline const Type *Type::getPointeeOrArrayElementType() const {
7119 const Type *type = this;
7120 if (type->isAnyPointerType())
7121 return type->getPointeeType().getTypePtr();
7122 else if (type->isArrayType())
7123 return type->getBaseElementTypeUnsafe();
7124 return type;
7125}
7126/// Insertion operator for partial diagnostics. This allows sending adress
7127/// spaces into a diagnostic with <<.
7128inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
7129 LangAS AS) {
7130 PD.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
7131 DiagnosticsEngine::ArgumentKind::ak_addrspace);
7132 return PD;
7133}
7134
7135/// Insertion operator for partial diagnostics. This allows sending Qualifiers
7136/// into a diagnostic with <<.
7137inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
7138 Qualifiers Q) {
7139 PD.AddTaggedVal(Q.getAsOpaqueValue(),
7140 DiagnosticsEngine::ArgumentKind::ak_qual);
7141 return PD;
7142}
7143
7144/// Insertion operator for partial diagnostics. This allows sending QualType's
7145/// into a diagnostic with <<.
7146inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
7147 QualType T) {
7148 PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
7149 DiagnosticsEngine::ak_qualtype);
7150 return PD;
7151}
7152
7153// Helper class template that is used by Type::getAs to ensure that one does
7154// not try to look through a qualified type to get to an array type.
7155template <typename T>
7156using TypeIsArrayType =
7157 std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
7158 std::is_base_of<ArrayType, T>::value>;
7159
7160// Member-template getAs<specific type>'.
7161template <typename T> const T *Type::getAs() const {
7162 static_assert(!TypeIsArrayType<T>::value,
7163 "ArrayType cannot be used with getAs!");
7164
7165 // If this is directly a T type, return it.
7166 if (const auto *Ty = dyn_cast<T>(this))
7167 return Ty;
7168
7169 // If the canonical form of this type isn't the right kind, reject it.
7170 if (!isa<T>(CanonicalType))
7171 return nullptr;
7172
7173 // If this is a typedef for the type, strip the typedef off without
7174 // losing all typedef information.
7175 return cast<T>(getUnqualifiedDesugaredType());
7176}
7177
7178template <typename T> const T *Type::getAsAdjusted() const {
7179 static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");
7180
7181 // If this is directly a T type, return it.
7182 if (const auto *Ty = dyn_cast<T>(this))
7183 return Ty;
7184
7185 // If the canonical form of this type isn't the right kind, reject it.
7186 if (!isa<T>(CanonicalType))
7187 return nullptr;
7188
7189 // Strip off type adjustments that do not modify the underlying nature of the
7190 // type.
7191 const Type *Ty = this;
7192 while (Ty) {
7193 if (const auto *A = dyn_cast<AttributedType>(Ty))
7194 Ty = A->getModifiedType().getTypePtr();
7195 else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
7196 Ty = E->desugar().getTypePtr();
7197 else if (const auto *P = dyn_cast<ParenType>(Ty))
7198 Ty = P->desugar().getTypePtr();
7199 else if (const auto *A = dyn_cast<AdjustedType>(Ty))
7200 Ty = A->desugar().getTypePtr();
7201 else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
7202 Ty = M->desugar().getTypePtr();
7203 else
7204 break;
7205 }
7206
7207 // Just because the canonical type is correct does not mean we can use cast<>,
7208 // since we may not have stripped off all the sugar down to the base type.
7209 return dyn_cast<T>(Ty);
7210}
7211
7212inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
7213 // If this is directly an array type, return it.
7214 if (const auto *arr = dyn_cast<ArrayType>(this))
7215 return arr;
7216
7217 // If the canonical form of this type isn't the right kind, reject it.
7218 if (!isa<ArrayType>(CanonicalType))
7219 return nullptr;
7220
7221 // If this is a typedef for the type, strip the typedef off without
7222 // losing all typedef information.
7223 return cast<ArrayType>(getUnqualifiedDesugaredType());
7224}
7225
7226template <typename T> const T *Type::castAs() const {
7227 static_assert(!TypeIsArrayType<T>::value,
7228 "ArrayType cannot be used with castAs!");
7229
7230 if (const auto *ty = dyn_cast<T>(this)) return ty;
7231 assert(isa<T>(CanonicalType))(static_cast <bool> (isa<T>(CanonicalType)) ? void
(0) : __assert_fail ("isa<T>(CanonicalType)", "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 7231, __extension__ __PRETTY_FUNCTION__))
;
7232 return cast<T>(getUnqualifiedDesugaredType());
7233}
7234
7235inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
7236 assert(isa<ArrayType>(CanonicalType))(static_cast <bool> (isa<ArrayType>(CanonicalType
)) ? void (0) : __assert_fail ("isa<ArrayType>(CanonicalType)"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 7236, __extension__ __PRETTY_FUNCTION__))
;
7237 if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
7238 return cast<ArrayType>(getUnqualifiedDesugaredType());
7239}
7240
7241DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
7242 QualType CanonicalPtr)
7243 : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
7244#ifndef NDEBUG
7245 QualType Adjusted = getAdjustedType();
7246 (void)AttributedType::stripOuterNullability(Adjusted);
7247 assert(isa<PointerType>(Adjusted))(static_cast <bool> (isa<PointerType>(Adjusted)) ?
void (0) : __assert_fail ("isa<PointerType>(Adjusted)"
, "/build/llvm-toolchain-snapshot-14~++20210828111110+16086d47c0d0/clang/include/clang/AST/Type.h"
, 7247, __extension__ __PRETTY_FUNCTION__))
;
7248#endif
7249}
7250
7251QualType DecayedType::getPointeeType() const {
7252 QualType Decayed = getDecayedType();
7253 (void)AttributedType::stripOuterNullability(Decayed);
7254 return cast<PointerType>(Decayed)->getPointeeType();
7255}
7256
7257// Get the decimal string representation of a fixed point type, represented
7258// as a scaled integer.
7259// TODO: At some point, we should change the arguments to instead just accept an
7260// APFixedPoint instead of APSInt and scale.
7261void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
7262 unsigned Scale);
7263
7264} // namespace clang
7265
7266#endif // LLVM_CLANG_AST_TYPE_H