Bug Summary

File:src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGObjCMac.cpp
Warning:line 7824, column 33
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGObjCMac.cpp

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/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")__builtin_unreachable();
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() &&((void)0)
1766 "NullReturnState::complete - arg not on object")((void)0);
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")__builtin_unreachable();
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)((void)0);
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?")((void)0);
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")__builtin_unreachable();
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)((void)0);
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()) ==((void)0)
2200 CGM.getContext().getCanonicalType(ResultType) &&((void)0)
2201 "Result type mismatch!")((void)0);
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?")__builtin_unreachable();
2312 case Qualifiers::OCL_None: llvm_unreachable("known nonzero")__builtin_unreachable();
2313 }
2314 llvm_unreachable("bad objc ownership")__builtin_unreachable();
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")((void)0);
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)((void)0)
2470 == CGM.getTarget().getPointerWidth(0))((void)0);
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 && 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())
2532 return;
2533 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2534
2535 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
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()) {
2545 LastFieldBitfieldOrUnnamed = Field;
2546 LastBitfieldOrUnnamedOffset = FieldOffset;
2547 continue;
2548 }
2549
2550 LastFieldBitfieldOrUnnamed = nullptr;
2551 QualType FQT = Field->getType();
2552 if (FQT->isRecordType() || FQT->isUnionType()) {
2553 if (FQT->isUnionType())
2554 HasUnion = true;
2555
2556 BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
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")((void)0);
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")((void)0);
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();
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));
2649
2650 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
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"llx" "", 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)((void)0);
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")((void)0);
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)((void)0);
3011 assert(!T->isArrayType() && "__block array variable should not be caught")((void)0);
3012 CharUnits fieldOffset;
3013 RunSkipBlockVars.clear();
3014 bool hasUnion = false;
3015 if (const RecordType *record = T->getAs<RecordType>()) {
3016 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
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())((void)0);
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)((void)0);
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 &&((void)0)
3656 "Forward metaclass reference has incorrect type.")((void)0);
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 &&((void)0)
3719 "Forward metaclass reference has incorrect type.")((void)0);
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 &&((void)0)
3750 "Forward metaclass reference has incorrect type.")((void)0);
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 &&((void)0)
3764 "Forward class metadata reference has incorrect type.")((void)0);
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")((void)0);
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 &&((void)0)
4114 "GenerateDirectMethod() should be called with the Class Interface")((void)0);
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())((void)0);
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?")((void)0);
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")((void)0);
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!")((void)0);
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?")((void)0);
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())((void)0);
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()) &&((void)0)
4958 "Unexpected rethrow outside @catch block.")((void)0);
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")((void)0);
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")((void)0);
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")((void)0);
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")((void)0);
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")((void)0);
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")__builtin_unreachable();
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) == "__" &&((void)0)
5118 "expected the name to begin with __")((void)0);
5119 return Section.substr(2).str();
5120 case llvm::Triple::COFF:
5121 assert(Section.substr(0, 2) == "__" &&((void)0)
5122 "expected the name to begin with __")((void)0);
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")__builtin_unreachable();
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)((void)0);
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?")((void)0);
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)((void)0)
5448 == CGM.getPointerSize())((void)0);
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")((void)0);
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))((void)0);
5473 }
5474 assert(IvarsInfo.back().Offset < InstanceEnd)((void)0);
5475
5476 assert(buffer.empty())((void)0);
5477
5478 // Skip the next N words.
5479 auto skip = [&](unsigned numWords) {
5480 assert(numWords > 0)((void)0);
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)((void)0);
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)((void)0);
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)((void)0);
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() ||((void)0)
6249 SectionName.startswith("__DATA")) &&((void)0)
6250 "SectionName expected to start with __DATA on MachO")((void)0);
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)((void)0);
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")((void)0);
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")((void)0);
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() &&((void)0)
6677 "attempting to get a protocol ref to a static protocol.")((void)0);
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?")((void)0);
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")((void)0);
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() &&((void)0)
7035 "attempting to GetOrEmit a non-runtime protocol")((void)0);
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() &&((void)0)
7084 "emitting protocol metadata without definition")((void)0);
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")((void)0);
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)((void)0);
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 &&((void)0)
7511 "classref was emitted with the wrong type?")((void)0);
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) ||((void)0)
7597 cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage())((void)0);
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")((void)0);
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")((void)0);
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")((void)0);
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")((void)0);
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()) {
1
Calling 'Type::isObjCIdType'
5
Returning from 'Type::isObjCIdType'
6
Calling 'Type::isObjCQualifiedIdType'
10
Returning from 'Type::isObjCQualifiedIdType'
11
Taking false branch
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>();
12
Assuming the object is not a 'ObjCObjectPointerType'
13
'PT' initialized to a null pointer value
7822 assert(PT && "Invalid @catch type.")((void)0);
7823
7824 const ObjCInterfaceType *IT = PT->getInterfaceType();
14
Called C++ object pointer is null
7825 assert(IT && "Invalid @catch type.")((void)0);
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")((void)0);
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)((void)0);
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")__builtin_unreachable();
7949 }
7950 llvm_unreachable("bad runtime")__builtin_unreachable();
7951}

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