Bug Summary

File:clang/lib/CodeGen/CGObjCMac.cpp
Warning:line 2633, 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 -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-11/lib/clang/11.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-11~++20200309111110+2c36c23f347/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/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-11/lib/clang/11.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-11~++20200309111110+2c36c23f347/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -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-2020-03-09-184146-41876-1 -x c++ /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CGObjCMac.cpp

/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/clang/lib/CodeGen/CGObjCMac.cpp

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