Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGObjCMac.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn373517/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn373517=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-02-234743-9763-1 -x c++ /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/CodeGen/CGObjCMac.cpp

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

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