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-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/include -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/include -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/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-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd=. -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-01-13-084841-49055-1 -x c++ /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp

/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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::None());
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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 2300)
;
2301 }
2302 llvm_unreachable("bad objc ownership")::llvm::llvm_unreachable_internal("bad objc ownership", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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 && RD->isUnion());
1
Assuming 'RD' is null
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())
2
Assuming the condition is false
3
Taking false branch
2520 return;
2521 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2522
2523 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
4
Assuming 'i' is not equal to 'e'
5
Loop condition is true. Entering loop body
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()) {
6
Assuming the condition is false
7
Assuming the condition is false
8
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()) {
9
Calling 'Type::isRecordType'
12
Returning from 'Type::isRecordType'
2541 if (FQT->isUnionType())
13
Assuming the condition is false
14
Taking false branch
2542 HasUnion = true;
2543
2544 BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
15
Assuming the object is not a 'RecordType'
16
Passing null pointer value via 1st parameter 'RT'
17
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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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();
18
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));
2638
2639 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/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-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 2999, __PRETTY_FUNCTION__))
;
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-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3000, __PRETTY_FUNCTION__))
;
3001 CharUnits fieldOffset;
3002 RunSkipBlockVars.clear();
3003 bool hasUnion = false;
3004 if (const RecordType *record = T->getAs<RecordType>()) {
3005 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
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 =
3051 CGF.CGM.GetAddrOfConstantCString(ID->getObjCRuntimeNameAsString())
3052 .getPointer();
3053 ASTContext &ctx = CGF.CGM.getContext();
3054 className =
3055 CGF.Builder.CreateBitCast(className,
3056 CGF.ConvertType(
3057 ctx.getPointerType(ctx.CharTy.withConst())));
3058 llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
3059 call->setDoesNotThrow();
3060 return call;
3061}
3062
3063/*
3064// Objective-C 1.0 extensions
3065struct _objc_protocol {
3066struct _objc_protocol_extension *isa;
3067char *protocol_name;
3068struct _objc_protocol_list *protocol_list;
3069struct _objc__method_prototype_list *instance_methods;
3070struct _objc__method_prototype_list *class_methods
3071};
3072
3073See EmitProtocolExtension().
3074*/
3075llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
3076 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
3077
3078 // Early exit if a defining object has already been generated.
3079 if (Entry && Entry->hasInitializer())
3080 return Entry;
3081
3082 // Use the protocol definition, if there is one.
3083 if (const ObjCProtocolDecl *Def = PD->getDefinition())
3084 PD = Def;
3085
3086 // FIXME: I don't understand why gcc generates this, or where it is
3087 // resolved. Investigate. Its also wasteful to look this up over and over.
3088 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3089
3090 // Construct method lists.
3091 auto methodLists = ProtocolMethodLists::get(PD);
3092
3093 ConstantInitBuilder builder(CGM);
3094 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
3095 values.add(EmitProtocolExtension(PD, methodLists));
3096 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
3097 values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
3098 PD->protocol_begin(), PD->protocol_end()));
3099 values.add(methodLists.emitMethodList(this, PD,
3100 ProtocolMethodLists::RequiredInstanceMethods));
3101 values.add(methodLists.emitMethodList(this, PD,
3102 ProtocolMethodLists::RequiredClassMethods));
3103
3104 if (Entry) {
3105 // Already created, update the initializer.
3106 assert(Entry->hasPrivateLinkage())((Entry->hasPrivateLinkage()) ? static_cast<void> (0
) : __assert_fail ("Entry->hasPrivateLinkage()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3106, __PRETTY_FUNCTION__))
;
3107 values.finishAndSetAsInitializer(Entry);
3108 } else {
3109 Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
3110 CGM.getPointerAlign(),
3111 /*constant*/ false,
3112 llvm::GlobalValue::PrivateLinkage);
3113 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3114
3115 Protocols[PD->getIdentifier()] = Entry;
3116 }
3117 CGM.addCompilerUsedGlobal(Entry);
3118
3119 return Entry;
3120}
3121
3122llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
3123 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
3124
3125 if (!Entry) {
3126 // We use the initializer as a marker of whether this is a forward
3127 // reference or not. At module finalization we add the empty
3128 // contents for protocols which were referenced but never defined.
3129 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
3130 false, llvm::GlobalValue::PrivateLinkage,
3131 nullptr, "OBJC_PROTOCOL_" + PD->getName());
3132 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3133 // FIXME: Is this necessary? Why only for protocol?
3134 Entry->setAlignment(llvm::Align(4));
3135 }
3136
3137 return Entry;
3138}
3139
3140/*
3141 struct _objc_protocol_extension {
3142 uint32_t size;
3143 struct objc_method_description_list *optional_instance_methods;
3144 struct objc_method_description_list *optional_class_methods;
3145 struct objc_property_list *instance_properties;
3146 const char ** extendedMethodTypes;
3147 struct objc_property_list *class_properties;
3148 };
3149*/
3150llvm::Constant *
3151CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
3152 const ProtocolMethodLists &methodLists) {
3153 auto optInstanceMethods =
3154 methodLists.emitMethodList(this, PD,
3155 ProtocolMethodLists::OptionalInstanceMethods);
3156 auto optClassMethods =
3157 methodLists.emitMethodList(this, PD,
3158 ProtocolMethodLists::OptionalClassMethods);
3159
3160 auto extendedMethodTypes =
3161 EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3162 methodLists.emitExtendedTypesArray(this),
3163 ObjCTypes);
3164
3165 auto instanceProperties =
3166 EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3167 ObjCTypes, false);
3168 auto classProperties =
3169 EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3170 PD, ObjCTypes, true);
3171
3172 // Return null if no extension bits are used.
3173 if (optInstanceMethods->isNullValue() &&
3174 optClassMethods->isNullValue() &&
3175 extendedMethodTypes->isNullValue() &&
3176 instanceProperties->isNullValue() &&
3177 classProperties->isNullValue()) {
3178 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3179 }
3180
3181 uint64_t size =
3182 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3183
3184 ConstantInitBuilder builder(CGM);
3185 auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3186 values.addInt(ObjCTypes.IntTy, size);
3187 values.add(optInstanceMethods);
3188 values.add(optClassMethods);
3189 values.add(instanceProperties);
3190 values.add(extendedMethodTypes);
3191 values.add(classProperties);
3192
3193 // No special section, but goes in llvm.used
3194 return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3195 StringRef(), CGM.getPointerAlign(), true);
3196}
3197
3198/*
3199 struct objc_protocol_list {
3200 struct objc_protocol_list *next;
3201 long count;
3202 Protocol *list[];
3203 };
3204*/
3205llvm::Constant *
3206CGObjCMac::EmitProtocolList(Twine name,
3207 ObjCProtocolDecl::protocol_iterator begin,
3208 ObjCProtocolDecl::protocol_iterator end) {
3209 // Just return null for empty protocol lists
3210 if (begin == end)
3211 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3212
3213 ConstantInitBuilder builder(CGM);
3214 auto values = builder.beginStruct();
3215
3216 // This field is only used by the runtime.
3217 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3218
3219 // Reserve a slot for the count.
3220 auto countSlot = values.addPlaceholder();
3221
3222 auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3223 for (; begin != end; ++begin) {
3224 refsArray.add(GetProtocolRef(*begin));
3225 }
3226 auto count = refsArray.size();
3227
3228 // This list is null terminated.
3229 refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3230
3231 refsArray.finishAndAddTo(values);
3232 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3233
3234 StringRef section;
3235 if (CGM.getTriple().isOSBinFormatMachO())
3236 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3237
3238 llvm::GlobalVariable *GV =
3239 CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3240 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3241}
3242
3243static void
3244PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
3245 SmallVectorImpl<const ObjCPropertyDecl *> &Properties,
3246 const ObjCProtocolDecl *Proto,
3247 bool IsClassProperty) {
3248 for (const auto *PD : Proto->properties()) {
3249 if (IsClassProperty != PD->isClassProperty())
3250 continue;
3251 if (!PropertySet.insert(PD->getIdentifier()).second)
3252 continue;
3253 Properties.push_back(PD);
3254 }
3255
3256 for (const auto *P : Proto->protocols())
3257 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3258}
3259
3260/*
3261 struct _objc_property {
3262 const char * const name;
3263 const char * const attributes;
3264 };
3265
3266 struct _objc_property_list {
3267 uint32_t entsize; // sizeof (struct _objc_property)
3268 uint32_t prop_count;
3269 struct _objc_property[prop_count];
3270 };
3271*/
3272llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3273 const Decl *Container,
3274 const ObjCContainerDecl *OCD,
3275 const ObjCCommonTypesHelper &ObjCTypes,
3276 bool IsClassProperty) {
3277 if (IsClassProperty) {
3278 // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3279 // with deployment target < 9.0.
3280 const llvm::Triple &Triple = CGM.getTarget().getTriple();
3281 if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
3282 (Triple.isiOS() && Triple.isOSVersionLT(9)))
3283 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3284 }
3285
3286 SmallVector<const ObjCPropertyDecl *, 16> Properties;
3287 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3288
3289 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3290 for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3291 for (auto *PD : ClassExt->properties()) {
3292 if (IsClassProperty != PD->isClassProperty())
3293 continue;
3294 PropertySet.insert(PD->getIdentifier());
3295 Properties.push_back(PD);
3296 }
3297
3298 for (const auto *PD : OCD->properties()) {
3299 if (IsClassProperty != PD->isClassProperty())
3300 continue;
3301 // Don't emit duplicate metadata for properties that were already in a
3302 // class extension.
3303 if (!PropertySet.insert(PD->getIdentifier()).second)
3304 continue;
3305 Properties.push_back(PD);
3306 }
3307
3308 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3309 for (const auto *P : OID->all_referenced_protocols())
3310 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3311 }
3312 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3313 for (const auto *P : CD->protocols())
3314 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3315 }
3316
3317 // Return null for empty list.
3318 if (Properties.empty())
3319 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3320
3321 unsigned propertySize =
3322 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3323
3324 ConstantInitBuilder builder(CGM);
3325 auto values = builder.beginStruct();
3326 values.addInt(ObjCTypes.IntTy, propertySize);
3327 values.addInt(ObjCTypes.IntTy, Properties.size());
3328 auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3329 for (auto PD : Properties) {
3330 if (PD->isDirectProperty())
3331 continue;
3332 auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3333 property.add(GetPropertyName(PD->getIdentifier()));
3334 property.add(GetPropertyTypeString(PD, Container));
3335 property.finishAndAddTo(propertiesArray);
3336 }
3337 propertiesArray.finishAndAddTo(values);
3338
3339 StringRef Section;
3340 if (CGM.getTriple().isOSBinFormatMachO())
3341 Section = (ObjCABI == 2) ? "__DATA, __objc_const"
3342 : "__OBJC,__property,regular,no_dead_strip";
3343
3344 llvm::GlobalVariable *GV =
3345 CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3346 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3347}
3348
3349llvm::Constant *
3350CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3351 ArrayRef<llvm::Constant*> MethodTypes,
3352 const ObjCCommonTypesHelper &ObjCTypes) {
3353 // Return null for empty list.
3354 if (MethodTypes.empty())
3355 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3356
3357 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3358 MethodTypes.size());
3359 llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3360
3361 StringRef Section;
3362 if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
3363 Section = "__DATA, __objc_const";
3364
3365 llvm::GlobalVariable *GV =
3366 CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3367 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3368}
3369
3370/*
3371 struct _objc_category {
3372 char *category_name;
3373 char *class_name;
3374 struct _objc_method_list *instance_methods;
3375 struct _objc_method_list *class_methods;
3376 struct _objc_protocol_list *protocols;
3377 uint32_t size; // <rdar://4585769>
3378 struct _objc_property_list *instance_properties;
3379 struct _objc_property_list *class_properties;
3380 };
3381*/
3382void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3383 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3384
3385 // FIXME: This is poor design, the OCD should have a pointer to the category
3386 // decl. Additionally, note that Category can be null for the @implementation
3387 // w/o an @interface case. Sema should just create one for us as it does for
3388 // @implementation so everyone else can live life under a clear blue sky.
3389 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3390 const ObjCCategoryDecl *Category =
3391 Interface->FindCategoryDeclaration(OCD->getIdentifier());
3392
3393 SmallString<256> ExtName;
3394 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3395 << OCD->getName();
3396
3397 ConstantInitBuilder Builder(CGM);
3398 auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3399
3400 enum {
3401 InstanceMethods,
3402 ClassMethods,
3403 NumMethodLists
3404 };
3405 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3406 for (const auto *MD : OCD->methods()) {
3407 if (!MD->isDirectMethod())
3408 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3409 }
3410
3411 Values.add(GetClassName(OCD->getName()));
3412 Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3413 LazySymbols.insert(Interface->getIdentifier());
3414
3415 Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3416 Methods[InstanceMethods]));
3417 Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3418 Methods[ClassMethods]));
3419 if (Category) {
3420 Values.add(
3421 EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3422 Category->protocol_begin(), Category->protocol_end()));
3423 } else {
3424 Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3425 }
3426 Values.addInt(ObjCTypes.IntTy, Size);
3427
3428 // If there is no category @interface then there can be no properties.
3429 if (Category) {
3430 Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
3431 OCD, Category, ObjCTypes, false));
3432 Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3433 OCD, Category, ObjCTypes, true));
3434 } else {
3435 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3436 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3437 }
3438
3439 llvm::GlobalVariable *GV =
3440 CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3441 "__OBJC,__category,regular,no_dead_strip",
3442 CGM.getPointerAlign(), true);
3443 DefinedCategories.push_back(GV);
3444 DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3445 // method definition entries must be clear for next implementation.
3446 MethodDefinitions.clear();
3447}
3448
3449enum FragileClassFlags {
3450 /// Apparently: is not a meta-class.
3451 FragileABI_Class_Factory = 0x00001,
3452
3453 /// Is a meta-class.
3454 FragileABI_Class_Meta = 0x00002,
3455
3456 /// Has a non-trivial constructor or destructor.
3457 FragileABI_Class_HasCXXStructors = 0x02000,
3458
3459 /// Has hidden visibility.
3460 FragileABI_Class_Hidden = 0x20000,
3461
3462 /// Class implementation was compiled under ARC.
3463 FragileABI_Class_CompiledByARC = 0x04000000,
3464
3465 /// Class implementation was compiled under MRC and has MRC weak ivars.
3466 /// Exclusive with CompiledByARC.
3467 FragileABI_Class_HasMRCWeakIvars = 0x08000000,
3468};
3469
3470enum NonFragileClassFlags {
3471 /// Is a meta-class.
3472 NonFragileABI_Class_Meta = 0x00001,
3473
3474 /// Is a root class.
3475 NonFragileABI_Class_Root = 0x00002,
3476
3477 /// Has a non-trivial constructor or destructor.
3478 NonFragileABI_Class_HasCXXStructors = 0x00004,
3479
3480 /// Has hidden visibility.
3481 NonFragileABI_Class_Hidden = 0x00010,
3482
3483 /// Has the exception attribute.
3484 NonFragileABI_Class_Exception = 0x00020,
3485
3486 /// (Obsolete) ARC-specific: this class has a .release_ivars method
3487 NonFragileABI_Class_HasIvarReleaser = 0x00040,
3488
3489 /// Class implementation was compiled under ARC.
3490 NonFragileABI_Class_CompiledByARC = 0x00080,
3491
3492 /// Class has non-trivial destructors, but zero-initialization is okay.
3493 NonFragileABI_Class_HasCXXDestructorOnly = 0x00100,
3494
3495 /// Class implementation was compiled under MRC and has MRC weak ivars.
3496 /// Exclusive with CompiledByARC.
3497 NonFragileABI_Class_HasMRCWeakIvars = 0x00200,
3498};
3499
3500static bool hasWeakMember(QualType type) {
3501 if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3502 return true;
3503 }
3504
3505 if (auto recType = type->getAs<RecordType>()) {
3506 for (auto field : recType->getDecl()->fields()) {
3507 if (hasWeakMember(field->getType()))
3508 return true;
3509 }
3510 }
3511
3512 return false;
3513}
3514
3515/// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3516/// (and actually fill in a layout string) if we really do have any
3517/// __weak ivars.
3518static bool hasMRCWeakIvars(CodeGenModule &CGM,
3519 const ObjCImplementationDecl *ID) {
3520 if (!CGM.getLangOpts().ObjCWeak) return false;
3521 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC)((CGM.getLangOpts().getGC() == LangOptions::NonGC) ? static_cast
<void> (0) : __assert_fail ("CGM.getLangOpts().getGC() == LangOptions::NonGC"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3521, __PRETTY_FUNCTION__))
;
3522
3523 for (const ObjCIvarDecl *ivar =
3524 ID->getClassInterface()->all_declared_ivar_begin();
3525 ivar; ivar = ivar->getNextIvar()) {
3526 if (hasWeakMember(ivar->getType()))
3527 return true;
3528 }
3529
3530 return false;
3531}
3532
3533/*
3534 struct _objc_class {
3535 Class isa;
3536 Class super_class;
3537 const char *name;
3538 long version;
3539 long info;
3540 long instance_size;
3541 struct _objc_ivar_list *ivars;
3542 struct _objc_method_list *methods;
3543 struct _objc_cache *cache;
3544 struct _objc_protocol_list *protocols;
3545 // Objective-C 1.0 extensions (<rdr://4585769>)
3546 const char *ivar_layout;
3547 struct _objc_class_ext *ext;
3548 };
3549
3550 See EmitClassExtension();
3551*/
3552void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3553 IdentifierInfo *RuntimeName =
3554 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
3555 DefinedSymbols.insert(RuntimeName);
3556
3557 std::string ClassName = ID->getNameAsString();
3558 // FIXME: Gross
3559 ObjCInterfaceDecl *Interface =
3560 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3561 llvm::Constant *Protocols =
3562 EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3563 Interface->all_referenced_protocol_begin(),
3564 Interface->all_referenced_protocol_end());
3565 unsigned Flags = FragileABI_Class_Factory;
3566 if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3567 Flags |= FragileABI_Class_HasCXXStructors;
3568
3569 bool hasMRCWeak = false;
3570
3571 if (CGM.getLangOpts().ObjCAutoRefCount)
3572 Flags |= FragileABI_Class_CompiledByARC;
3573 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3574 Flags |= FragileABI_Class_HasMRCWeakIvars;
3575
3576 CharUnits Size =
3577 CGM.getContext().getASTObjCImplementationLayout(ID).getSize();
3578
3579 // FIXME: Set CXX-structors flag.
3580 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3581 Flags |= FragileABI_Class_Hidden;
3582
3583 enum {
3584 InstanceMethods,
3585 ClassMethods,
3586 NumMethodLists
3587 };
3588 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3589 for (const auto *MD : ID->methods()) {
3590 if (!MD->isDirectMethod())
3591 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3592 }
3593
3594 for (const auto *PID : ID->property_impls()) {
3595 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3596 if (PID->getPropertyDecl()->isDirectProperty())
3597 continue;
3598 if (ObjCMethodDecl *MD = PID->getGetterMethodDecl())
3599 if (GetMethodDefinition(MD))
3600 Methods[InstanceMethods].push_back(MD);
3601 if (ObjCMethodDecl *MD = PID->getSetterMethodDecl())
3602 if (GetMethodDefinition(MD))
3603 Methods[InstanceMethods].push_back(MD);
3604 }
3605 }
3606
3607 ConstantInitBuilder builder(CGM);
3608 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3609 values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3610 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3611 // Record a reference to the super class.
3612 LazySymbols.insert(Super->getIdentifier());
3613
3614 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3615 ObjCTypes.ClassPtrTy);
3616 } else {
3617 values.addNullPointer(ObjCTypes.ClassPtrTy);
3618 }
3619 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3620 // Version is always 0.
3621 values.addInt(ObjCTypes.LongTy, 0);
3622 values.addInt(ObjCTypes.LongTy, Flags);
3623 values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3624 values.add(EmitIvarList(ID, false));
3625 values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3626 Methods[InstanceMethods]));
3627 // cache is always NULL.
3628 values.addNullPointer(ObjCTypes.CachePtrTy);
3629 values.add(Protocols);
3630 values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3631 values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3632 /*isMetaclass*/ false));
3633
3634 std::string Name("OBJC_CLASS_");
3635 Name += ClassName;
3636 const char *Section = "__OBJC,__class,regular,no_dead_strip";
3637 // Check for a forward reference.
3638 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3639 if (GV) {
3640 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&((GV->getType()->getElementType() == ObjCTypes.ClassTy &&
"Forward metaclass reference has incorrect type.") ? static_cast
<void> (0) : __assert_fail ("GV->getType()->getElementType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3641, __PRETTY_FUNCTION__))
3641 "Forward metaclass reference has incorrect type.")((GV->getType()->getElementType() == ObjCTypes.ClassTy &&
"Forward metaclass reference has incorrect type.") ? static_cast
<void> (0) : __assert_fail ("GV->getType()->getElementType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3641, __PRETTY_FUNCTION__))
;
3642 values.finishAndSetAsInitializer(GV);
3643 GV->setSection(Section);
3644 GV->setAlignment(CGM.getPointerAlign().getAsAlign());
3645 CGM.addCompilerUsedGlobal(GV);
3646 } else
3647 GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3648 DefinedClasses.push_back(GV);
3649 ImplementedClasses.push_back(Interface);
3650 // method definition entries must be clear for next implementation.
3651 MethodDefinitions.clear();
3652}
3653
3654llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3655 llvm::Constant *Protocols,
3656 ArrayRef<const ObjCMethodDecl*> Methods) {
3657 unsigned Flags = FragileABI_Class_Meta;
3658 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3659
3660 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3661 Flags |= FragileABI_Class_Hidden;
3662
3663 ConstantInitBuilder builder(CGM);
3664 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3665 // The isa for the metaclass is the root of the hierarchy.
3666 const ObjCInterfaceDecl *Root = ID->getClassInterface();
3667 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3668 Root = Super;
3669 values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3670 ObjCTypes.ClassPtrTy);
3671 // The super class for the metaclass is emitted as the name of the
3672 // super class. The runtime fixes this up to point to the
3673 // *metaclass* for the super class.
3674 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3675 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3676 ObjCTypes.ClassPtrTy);
3677 } else {
3678 values.addNullPointer(ObjCTypes.ClassPtrTy);
3679 }
3680 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3681 // Version is always 0.
3682 values.addInt(ObjCTypes.LongTy, 0);
3683 values.addInt(ObjCTypes.LongTy, Flags);
3684 values.addInt(ObjCTypes.LongTy, Size);
3685 values.add(EmitIvarList(ID, true));
3686 values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3687 Methods));
3688 // cache is always NULL.
3689 values.addNullPointer(ObjCTypes.CachePtrTy);
3690 values.add(Protocols);
3691 // ivar_layout for metaclass is always NULL.
3692 values.addNullPointer(ObjCTypes.Int8PtrTy);
3693 // The class extension is used to store class properties for metaclasses.
3694 values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3695 /*isMetaclass*/true));
3696
3697 std::string Name("OBJC_METACLASS_");
3698 Name += ID->getName();
3699
3700 // Check for a forward reference.
3701 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3702 if (GV) {
3703 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&((GV->getType()->getElementType() == ObjCTypes.ClassTy &&
"Forward metaclass reference has incorrect type.") ? static_cast
<void> (0) : __assert_fail ("GV->getType()->getElementType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3704, __PRETTY_FUNCTION__))
3704 "Forward metaclass reference has incorrect type.")((GV->getType()->getElementType() == ObjCTypes.ClassTy &&
"Forward metaclass reference has incorrect type.") ? static_cast
<void> (0) : __assert_fail ("GV->getType()->getElementType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3704, __PRETTY_FUNCTION__))
;
3705 values.finishAndSetAsInitializer(GV);
3706 } else {
3707 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3708 /*constant*/ false,
3709 llvm::GlobalValue::PrivateLinkage);
3710 }
3711 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3712 CGM.addCompilerUsedGlobal(GV);
3713
3714 return GV;
3715}
3716
3717llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3718 std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3719
3720 // FIXME: Should we look these up somewhere other than the module. Its a bit
3721 // silly since we only generate these while processing an implementation, so
3722 // exactly one pointer would work if know when we entered/exitted an
3723 // implementation block.
3724
3725 // Check for an existing forward reference.
3726 // Previously, metaclass with internal linkage may have been defined.
3727 // pass 'true' as 2nd argument so it is returned.
3728 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3729 if (!GV)
3730 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3731 llvm::GlobalValue::PrivateLinkage, nullptr,
3732 Name);
3733
3734 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&((GV->getType()->getElementType() == ObjCTypes.ClassTy &&
"Forward metaclass reference has incorrect type.") ? static_cast
<void> (0) : __assert_fail ("GV->getType()->getElementType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3735, __PRETTY_FUNCTION__))
3735 "Forward metaclass reference has incorrect type.")((GV->getType()->getElementType() == ObjCTypes.ClassTy &&
"Forward metaclass reference has incorrect type.") ? static_cast
<void> (0) : __assert_fail ("GV->getType()->getElementType() == ObjCTypes.ClassTy && \"Forward metaclass reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3735, __PRETTY_FUNCTION__))
;
3736 return GV;
3737}
3738
3739llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3740 std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3741 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3742
3743 if (!GV)
3744 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3745 llvm::GlobalValue::PrivateLinkage, nullptr,
3746 Name);
3747
3748 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&((GV->getType()->getElementType() == ObjCTypes.ClassTy &&
"Forward class metadata reference has incorrect type.") ? static_cast
<void> (0) : __assert_fail ("GV->getType()->getElementType() == ObjCTypes.ClassTy && \"Forward class metadata reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3749, __PRETTY_FUNCTION__))
3749 "Forward class metadata reference has incorrect type.")((GV->getType()->getElementType() == ObjCTypes.ClassTy &&
"Forward class metadata reference has incorrect type.") ? static_cast
<void> (0) : __assert_fail ("GV->getType()->getElementType() == ObjCTypes.ClassTy && \"Forward class metadata reference has incorrect type.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3749, __PRETTY_FUNCTION__))
;
3750 return GV;
3751}
3752
3753/*
3754 Emit a "class extension", which in this specific context means extra
3755 data that doesn't fit in the normal fragile-ABI class structure, and
3756 has nothing to do with the language concept of a class extension.
3757
3758 struct objc_class_ext {
3759 uint32_t size;
3760 const char *weak_ivar_layout;
3761 struct _objc_property_list *properties;
3762 };
3763*/
3764llvm::Constant *
3765CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3766 CharUnits InstanceSize, bool hasMRCWeakIvars,
3767 bool isMetaclass) {
3768 // Weak ivar layout.
3769 llvm::Constant *layout;
3770 if (isMetaclass) {
3771 layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3772 } else {
3773 layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3774 hasMRCWeakIvars);
3775 }
3776
3777 // Properties.
3778 llvm::Constant *propertyList =
3779 EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_")
3780 : Twine("_OBJC_$_PROP_LIST_"))
3781 + ID->getName(),
3782 ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3783
3784 // Return null if no extension bits are used.
3785 if (layout->isNullValue() && propertyList->isNullValue()) {
3786 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3787 }
3788
3789 uint64_t size =
3790 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3791
3792 ConstantInitBuilder builder(CGM);
3793 auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3794 values.addInt(ObjCTypes.IntTy, size);
3795 values.add(layout);
3796 values.add(propertyList);
3797
3798 return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3799 "__OBJC,__class_ext,regular,no_dead_strip",
3800 CGM.getPointerAlign(), true);
3801}
3802
3803/*
3804 struct objc_ivar {
3805 char *ivar_name;
3806 char *ivar_type;
3807 int ivar_offset;
3808 };
3809
3810 struct objc_ivar_list {
3811 int ivar_count;
3812 struct objc_ivar list[count];
3813 };
3814*/
3815llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3816 bool ForClass) {
3817 // When emitting the root class GCC emits ivar entries for the
3818 // actual class structure. It is not clear if we need to follow this
3819 // behavior; for now lets try and get away with not doing it. If so,
3820 // the cleanest solution would be to make up an ObjCInterfaceDecl
3821 // for the class.
3822 if (ForClass)
3823 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3824
3825 const ObjCInterfaceDecl *OID = ID->getClassInterface();
3826
3827 ConstantInitBuilder builder(CGM);
3828 auto ivarList = builder.beginStruct();
3829 auto countSlot = ivarList.addPlaceholder();
3830 auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3831
3832 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3833 IVD; IVD = IVD->getNextIvar()) {
3834 // Ignore unnamed bit-fields.
3835 if (!IVD->getDeclName())
3836 continue;
3837
3838 auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3839 ivar.add(GetMethodVarName(IVD->getIdentifier()));
3840 ivar.add(GetMethodVarType(IVD));
3841 ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3842 ivar.finishAndAddTo(ivars);
3843 }
3844
3845 // Return null for empty list.
3846 auto count = ivars.size();
3847 if (count == 0) {
3848 ivars.abandon();
3849 ivarList.abandon();
3850 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3851 }
3852
3853 ivars.finishAndAddTo(ivarList);
3854 ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3855
3856 llvm::GlobalVariable *GV;
3857 if (ForClass)
3858 GV =
3859 CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3860 "__OBJC,__class_vars,regular,no_dead_strip",
3861 CGM.getPointerAlign(), true);
3862 else
3863 GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3864 "__OBJC,__instance_vars,regular,no_dead_strip",
3865 CGM.getPointerAlign(), true);
3866 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3867}
3868
3869/// Build a struct objc_method_description constant for the given method.
3870///
3871/// struct objc_method_description {
3872/// SEL method_name;
3873/// char *method_types;
3874/// };
3875void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3876 const ObjCMethodDecl *MD) {
3877 auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3878 description.addBitCast(GetMethodVarName(MD->getSelector()),
3879 ObjCTypes.SelectorPtrTy);
3880 description.add(GetMethodVarType(MD));
3881 description.finishAndAddTo(builder);
3882}
3883
3884/// Build a struct objc_method constant for the given method.
3885///
3886/// struct objc_method {
3887/// SEL method_name;
3888/// char *method_types;
3889/// void *method;
3890/// };
3891void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3892 const ObjCMethodDecl *MD) {
3893 llvm::Function *fn = GetMethodDefinition(MD);
3894 assert(fn && "no definition registered for method")((fn && "no definition registered for method") ? static_cast
<void> (0) : __assert_fail ("fn && \"no definition registered for method\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 3894, __PRETTY_FUNCTION__))
;
3895
3896 auto method = builder.beginStruct(ObjCTypes.MethodTy);
3897 method.addBitCast(GetMethodVarName(MD->getSelector()),
3898 ObjCTypes.SelectorPtrTy);
3899 method.add(GetMethodVarType(MD));
3900 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3901 method.finishAndAddTo(builder);
3902}
3903
3904/// Build a struct objc_method_list or struct objc_method_description_list,
3905/// as appropriate.
3906///
3907/// struct objc_method_list {
3908/// struct objc_method_list *obsolete;
3909/// int count;
3910/// struct objc_method methods_list[count];
3911/// };
3912///
3913/// struct objc_method_description_list {
3914/// int count;
3915/// struct objc_method_description list[count];
3916/// };
3917llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3918 ArrayRef<const ObjCMethodDecl *> methods) {
3919 StringRef prefix;
3920 StringRef section;
3921 bool forProtocol = false;
3922 switch (MLT) {
3923 case MethodListType::CategoryInstanceMethods:
3924 prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3925 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3926 forProtocol = false;
3927 break;
3928 case MethodListType::CategoryClassMethods:
3929 prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3930 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3931 forProtocol = false;
3932 break;
3933 case MethodListType::InstanceMethods:
3934 prefix = "OBJC_INSTANCE_METHODS_";
3935 section = "__OBJC,__inst_meth,regular,no_dead_strip";
3936 forProtocol = false;
3937 break;
3938 case MethodListType::ClassMethods:
3939 prefix = "OBJC_CLASS_METHODS_";
3940 section = "__OBJC,__cls_meth,regular,no_dead_strip";
3941 forProtocol = false;
3942 break;
3943 case MethodListType::ProtocolInstanceMethods:
3944 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3945 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3946 forProtocol = true;
3947 break;
3948 case MethodListType::ProtocolClassMethods:
3949 prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3950 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3951 forProtocol = true;
3952 break;
3953 case MethodListType::OptionalProtocolInstanceMethods:
3954 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3955 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3956 forProtocol = true;
3957 break;
3958 case MethodListType::OptionalProtocolClassMethods:
3959 prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3960 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3961 forProtocol = true;
3962 break;
3963 }
3964
3965 // Return null for empty list.
3966 if (methods.empty())
3967 return llvm::Constant::getNullValue(forProtocol
3968 ? ObjCTypes.MethodDescriptionListPtrTy
3969 : ObjCTypes.MethodListPtrTy);
3970
3971 // For protocols, this is an objc_method_description_list, which has
3972 // a slightly different structure.
3973 if (forProtocol) {
3974 ConstantInitBuilder builder(CGM);
3975 auto values = builder.beginStruct();
3976 values.addInt(ObjCTypes.IntTy, methods.size());
3977 auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3978 for (auto MD : methods) {
3979 emitMethodDescriptionConstant(methodArray, MD);
3980 }
3981 methodArray.finishAndAddTo(values);
3982
3983 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3984 CGM.getPointerAlign(), true);
3985 return llvm::ConstantExpr::getBitCast(GV,
3986 ObjCTypes.MethodDescriptionListPtrTy);
3987 }
3988
3989 // Otherwise, it's an objc_method_list.
3990 ConstantInitBuilder builder(CGM);
3991 auto values = builder.beginStruct();
3992 values.addNullPointer(ObjCTypes.Int8PtrTy);
3993 values.addInt(ObjCTypes.IntTy, methods.size());
3994 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
3995 for (auto MD : methods) {
3996 if (!MD->isDirectMethod())
3997 emitMethodConstant(methodArray, MD);
3998 }
3999 methodArray.finishAndAddTo(values);
4000
4001 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
4002 CGM.getPointerAlign(), true);
4003 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
4004}
4005
4006llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
4007 const ObjCContainerDecl *CD) {
4008 llvm::Function *Method;
4009
4010 if (OMD->isDirectMethod()) {
4011 Method = GenerateDirectMethod(OMD, CD);
4012 } else {
4013 SmallString<256> Name;
4014 GetNameForMethod(OMD, CD, Name);
4015
4016 CodeGenTypes &Types = CGM.getTypes();
4017 llvm::FunctionType *MethodTy =
4018 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
4019 Method =
4020 llvm::Function::Create(MethodTy, llvm::GlobalValue::InternalLinkage,
4021 Name.str(), &CGM.getModule());
4022 }
4023
4024 MethodDefinitions.insert(std::make_pair(OMD, Method));
4025
4026 return Method;
4027}
4028
4029llvm::Function *
4030CGObjCCommonMac::GenerateDirectMethod(const ObjCMethodDecl *OMD,
4031 const ObjCContainerDecl *CD) {
4032 auto I = DirectMethodDefinitions.find(OMD->getCanonicalDecl());
4033 if (I != DirectMethodDefinitions.end())
4034 return I->second;
4035
4036 SmallString<256> Name;
4037 GetNameForMethod(OMD, CD, Name, /*ignoreCategoryNamespace*/true);
4038
4039 CodeGenTypes &Types = CGM.getTypes();
4040 llvm::FunctionType *MethodTy =
4041 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
4042 llvm::Function *Method =
4043 llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
4044 Name.str(), &CGM.getModule());
4045 DirectMethodDefinitions.insert(std::make_pair(OMD->getCanonicalDecl(), Method));
4046
4047 return Method;
4048}
4049
4050void CGObjCCommonMac::GenerateDirectMethodPrologue(
4051 CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD,
4052 const ObjCContainerDecl *CD) {
4053 auto &Builder = CGF.Builder;
4054 bool ReceiverCanBeNull = true;
4055 auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
4056 auto selfValue = Builder.CreateLoad(selfAddr);
4057
4058 // Generate:
4059 //
4060 // /* for class methods only to force class lazy initialization */
4061 // self = [self self];
4062 //
4063 // /* unless the receiver is never NULL */
4064 // if (self == nil) {
4065 // return (ReturnType){ };
4066 // }
4067 //
4068 // _cmd = @selector(...)
4069 // ...
4070
4071 if (OMD->isClassMethod()) {
4072 const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD);
4073 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-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4074, __PRETTY_FUNCTION__))
4074 "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-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4074, __PRETTY_FUNCTION__))
;
4075 Selector SelfSel = GetNullarySelector("self", CGM.getContext());
4076 auto ResultType = CGF.getContext().getObjCIdType();
4077 RValue result;
4078 CallArgList Args;
4079
4080 // TODO: If this method is inlined, the caller might know that `self` is
4081 // already initialized; for example, it might be an ordinary Objective-C
4082 // method which always receives an initialized `self`, or it might have just
4083 // forced initialization on its own.
4084 //
4085 // We should find a way to eliminate this unnecessary initialization in such
4086 // cases in LLVM.
4087 result = GeneratePossiblySpecializedMessageSend(
4088 CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID,
4089 nullptr, true);
4090 Builder.CreateStore(result.getScalarVal(), selfAddr);
4091
4092 // Nullable `Class` expressions cannot be messaged with a direct method
4093 // so the only reason why the receive can be null would be because
4094 // of weak linking.
4095 ReceiverCanBeNull = isWeakLinkedClass(OID);
4096 }
4097
4098 if (ReceiverCanBeNull) {
4099 llvm::BasicBlock *SelfIsNilBlock =
4100 CGF.createBasicBlock("objc_direct_method.self_is_nil");
4101 llvm::BasicBlock *ContBlock =
4102 CGF.createBasicBlock("objc_direct_method.cont");
4103
4104 // if (self == nil) {
4105 auto selfTy = cast<llvm::PointerType>(selfValue->getType());
4106 auto Zero = llvm::ConstantPointerNull::get(selfTy);
4107
4108 llvm::MDBuilder MDHelper(CGM.getLLVMContext());
4109 Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock,
4110 ContBlock, MDHelper.createBranchWeights(1, 1 << 20));
4111
4112 CGF.EmitBlock(SelfIsNilBlock);
4113
4114 // return (ReturnType){ };
4115 auto retTy = OMD->getReturnType();
4116 Builder.SetInsertPoint(SelfIsNilBlock);
4117 if (!retTy->isVoidType()) {
4118 CGF.EmitNullInitialization(CGF.ReturnValue, retTy);
4119 }
4120 CGF.EmitBranchThroughCleanup(CGF.ReturnBlock);
4121 // }
4122
4123 // rest of the body
4124 CGF.EmitBlock(ContBlock);
4125 Builder.SetInsertPoint(ContBlock);
4126 }
4127
4128 // only synthesize _cmd if it's referenced
4129 if (OMD->getCmdDecl()->isUsed()) {
4130 Builder.CreateStore(GetSelector(CGF, OMD),
4131 CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
4132 }
4133}
4134
4135llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4136 ConstantStructBuilder &Init,
4137 StringRef Section,
4138 CharUnits Align,
4139 bool AddToUsed) {
4140 llvm::GlobalValue::LinkageTypes LT =
4141 getLinkageTypeForObjCMetadata(CGM, Section);
4142 llvm::GlobalVariable *GV =
4143 Init.finishAndCreateGlobal(Name, Align, /*constant*/ false, LT);
4144 if (!Section.empty())
4145 GV->setSection(Section);
4146 if (AddToUsed)
4147 CGM.addCompilerUsedGlobal(GV);
4148 return GV;
4149}
4150
4151llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4152 llvm::Constant *Init,
4153 StringRef Section,
4154 CharUnits Align,
4155 bool AddToUsed) {
4156 llvm::Type *Ty = Init->getType();
4157 llvm::GlobalValue::LinkageTypes LT =
4158 getLinkageTypeForObjCMetadata(CGM, Section);
4159 llvm::GlobalVariable *GV =
4160 new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name);
4161 if (!Section.empty())
4162 GV->setSection(Section);
4163 GV->setAlignment(Align.getAsAlign());
4164 if (AddToUsed)
4165 CGM.addCompilerUsedGlobal(GV);
4166 return GV;
4167}
4168
4169llvm::GlobalVariable *
4170CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
4171 bool ForceNonFragileABI,
4172 bool NullTerminate) {
4173 StringRef Label;
4174 switch (Type) {
4175 case ObjCLabelType::ClassName: Label = "OBJC_CLASS_NAME_"; break;
4176 case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
4177 case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
4178 case ObjCLabelType::PropertyName: Label = "OBJC_PROP_NAME_ATTR_"; break;
4179 }
4180
4181 bool NonFragile = ForceNonFragileABI || isNonFragileABI();
4182
4183 StringRef Section;
4184 switch (Type) {
4185 case ObjCLabelType::ClassName:
4186 Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
4187 : "__TEXT,__cstring,cstring_literals";
4188 break;
4189 case ObjCLabelType::MethodVarName:
4190 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4191 : "__TEXT,__cstring,cstring_literals";
4192 break;
4193 case ObjCLabelType::MethodVarType:
4194 Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
4195 : "__TEXT,__cstring,cstring_literals";
4196 break;
4197 case ObjCLabelType::PropertyName:
4198 Section = "__TEXT,__cstring,cstring_literals";
4199 break;
4200 }
4201
4202 llvm::Constant *Value =
4203 llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
4204 llvm::GlobalVariable *GV =
4205 new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
4206 /*isConstant=*/true,
4207 llvm::GlobalValue::PrivateLinkage, Value, Label);
4208 if (CGM.getTriple().isOSBinFormatMachO())
4209 GV->setSection(Section);
4210 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4211 GV->setAlignment(CharUnits::One().getAsAlign());
4212 CGM.addCompilerUsedGlobal(GV);
4213
4214 return GV;
4215}
4216
4217llvm::Function *CGObjCMac::ModuleInitFunction() {
4218 // Abuse this interface function as a place to finalize.
4219 FinishModule();
4220 return nullptr;
4221}
4222
4223llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() {
4224 return ObjCTypes.getGetPropertyFn();
4225}
4226
4227llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() {
4228 return ObjCTypes.getSetPropertyFn();
4229}
4230
4231llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
4232 bool copy) {
4233 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
4234}
4235
4236llvm::FunctionCallee CGObjCMac::GetGetStructFunction() {
4237 return ObjCTypes.getCopyStructFn();
4238}
4239
4240llvm::FunctionCallee CGObjCMac::GetSetStructFunction() {
4241 return ObjCTypes.getCopyStructFn();
4242}
4243
4244llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() {
4245 return ObjCTypes.getCppAtomicObjectFunction();
4246}
4247
4248llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() {
4249 return ObjCTypes.getCppAtomicObjectFunction();
4250}
4251
4252llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() {
4253 return ObjCTypes.getEnumerationMutationFn();
4254}
4255
4256void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
4257 return EmitTryOrSynchronizedStmt(CGF, S);
4258}
4259
4260void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
4261 const ObjCAtSynchronizedStmt &S) {
4262 return EmitTryOrSynchronizedStmt(CGF, S);
4263}
4264
4265namespace {
4266 struct PerformFragileFinally final : EHScopeStack::Cleanup {
4267 const Stmt &S;
4268 Address SyncArgSlot;
4269 Address CallTryExitVar;
4270 Address ExceptionData;
4271 ObjCTypesHelper &ObjCTypes;
4272 PerformFragileFinally(const Stmt *S,
4273 Address SyncArgSlot,
4274 Address CallTryExitVar,
4275 Address ExceptionData,
4276 ObjCTypesHelper *ObjCTypes)
4277 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4278 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4279
4280 void Emit(CodeGenFunction &CGF, Flags flags) override {
4281 // Check whether we need to call objc_exception_try_exit.
4282 // In optimized code, this branch will always be folded.
4283 llvm::BasicBlock *FinallyCallExit =
4284 CGF.createBasicBlock("finally.call_exit");
4285 llvm::BasicBlock *FinallyNoCallExit =
4286 CGF.createBasicBlock("finally.no_call_exit");
4287 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4288 FinallyCallExit, FinallyNoCallExit);
4289
4290 CGF.EmitBlock(FinallyCallExit);
4291 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4292 ExceptionData.getPointer());
4293
4294 CGF.EmitBlock(FinallyNoCallExit);
4295
4296 if (isa<ObjCAtTryStmt>(S)) {
4297 if (const ObjCAtFinallyStmt* FinallyStmt =
4298 cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4299 // Don't try to do the @finally if this is an EH cleanup.
4300 if (flags.isForEHCleanup()) return;
4301
4302 // Save the current cleanup destination in case there's
4303 // control flow inside the finally statement.
4304 llvm::Value *CurCleanupDest =
4305 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
4306
4307 CGF.EmitStmt(FinallyStmt->getFinallyBody());
4308
4309 if (CGF.HaveInsertPoint()) {
4310 CGF.Builder.CreateStore(CurCleanupDest,
4311 CGF.getNormalCleanupDestSlot());
4312 } else {
4313 // Currently, the end of the cleanup must always exist.
4314 CGF.EnsureInsertPoint();
4315 }
4316 }
4317 } else {
4318 // Emit objc_sync_exit(expr); as finally's sole statement for
4319 // @synchronized.
4320 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4321 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4322 }
4323 }
4324 };
4325
4326 class FragileHazards {
4327 CodeGenFunction &CGF;
4328 SmallVector<llvm::Value*, 20> Locals;
4329 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4330
4331 llvm::InlineAsm *ReadHazard;
4332 llvm::InlineAsm *WriteHazard;
4333
4334 llvm::FunctionType *GetAsmFnType();
4335
4336 void collectLocals();
4337 void emitReadHazard(CGBuilderTy &Builder);
4338
4339 public:
4340 FragileHazards(CodeGenFunction &CGF);
4341
4342 void emitWriteHazard();
4343 void emitHazardsInNewBlocks();
4344 };
4345} // end anonymous namespace
4346
4347/// Create the fragile-ABI read and write hazards based on the current
4348/// state of the function, which is presumed to be immediately prior
4349/// to a @try block. These hazards are used to maintain correct
4350/// semantics in the face of optimization and the fragile ABI's
4351/// cavalier use of setjmp/longjmp.
4352FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4353 collectLocals();
4354
4355 if (Locals.empty()) return;
4356
4357 // Collect all the blocks in the function.
4358 for (llvm::Function::iterator
4359 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
4360 BlocksBeforeTry.insert(&*I);
4361
4362 llvm::FunctionType *AsmFnTy = GetAsmFnType();
4363
4364 // Create a read hazard for the allocas. This inhibits dead-store
4365 // optimizations and forces the values to memory. This hazard is
4366 // inserted before any 'throwing' calls in the protected scope to
4367 // reflect the possibility that the variables might be read from the
4368 // catch block if the call throws.
4369 {
4370 std::string Constraint;
4371 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4372 if (I) Constraint += ',';
4373 Constraint += "*m";
4374 }
4375
4376 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4377 }
4378
4379 // Create a write hazard for the allocas. This inhibits folding
4380 // loads across the hazard. This hazard is inserted at the
4381 // beginning of the catch path to reflect the possibility that the
4382 // variables might have been written within the protected scope.
4383 {
4384 std::string Constraint;
4385 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4386 if (I) Constraint += ',';
4387 Constraint += "=*m";
4388 }
4389
4390 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4391 }
4392}
4393
4394/// Emit a write hazard at the current location.
4395void FragileHazards::emitWriteHazard() {
4396 if (Locals.empty()) return;
4397
4398 CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4399}
4400
4401void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4402 assert(!Locals.empty())((!Locals.empty()) ? static_cast<void> (0) : __assert_fail
("!Locals.empty()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4402, __PRETTY_FUNCTION__))
;
4403 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4404 call->setDoesNotThrow();
4405 call->setCallingConv(CGF.getRuntimeCC());
4406}
4407
4408/// Emit read hazards in all the protected blocks, i.e. all the blocks
4409/// which have been inserted since the beginning of the try.
4410void FragileHazards::emitHazardsInNewBlocks() {
4411 if (Locals.empty()) return;
4412
4413 CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4414
4415 // Iterate through all blocks, skipping those prior to the try.
4416 for (llvm::Function::iterator
4417 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
4418 llvm::BasicBlock &BB = *FI;
4419 if (BlocksBeforeTry.count(&BB)) continue;
4420
4421 // Walk through all the calls in the block.
4422 for (llvm::BasicBlock::iterator
4423 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
4424 llvm::Instruction &I = *BI;
4425
4426 // Ignore instructions that aren't non-intrinsic calls.
4427 // These are the only calls that can possibly call longjmp.
4428 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I))
4429 continue;
4430 if (isa<llvm::IntrinsicInst>(I))
4431 continue;
4432
4433 // Ignore call sites marked nounwind. This may be questionable,
4434 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4435 if (cast<llvm::CallBase>(I).doesNotThrow())
4436 continue;
4437
4438 // Insert a read hazard before the call. This will ensure that
4439 // any writes to the locals are performed before making the
4440 // call. If the call throws, then this is sufficient to
4441 // guarantee correctness as long as it doesn't also write to any
4442 // locals.
4443 Builder.SetInsertPoint(&BB, BI);
4444 emitReadHazard(Builder);
4445 }
4446 }
4447}
4448
4449static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
4450 if (V.isValid()) S.insert(V.getPointer());
4451}
4452
4453void FragileHazards::collectLocals() {
4454 // Compute a set of allocas to ignore.
4455 llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4456 addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4457 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4458
4459 // Collect all the allocas currently in the function. This is
4460 // probably way too aggressive.
4461 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4462 for (llvm::BasicBlock::iterator
4463 I = Entry.begin(), E = Entry.end(); I != E; ++I)
4464 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
4465 Locals.push_back(&*I);
4466}
4467
4468llvm::FunctionType *FragileHazards::GetAsmFnType() {
4469 SmallVector<llvm::Type *, 16> tys(Locals.size());
4470 for (unsigned i = 0, e = Locals.size(); i != e; ++i)
4471 tys[i] = Locals[i]->getType();
4472 return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4473}
4474
4475/*
4476
4477 Objective-C setjmp-longjmp (sjlj) Exception Handling
4478 --
4479
4480 A catch buffer is a setjmp buffer plus:
4481 - a pointer to the exception that was caught
4482 - a pointer to the previous exception data buffer
4483 - two pointers of reserved storage
4484 Therefore catch buffers form a stack, with a pointer to the top
4485 of the stack kept in thread-local storage.
4486
4487 objc_exception_try_enter pushes a catch buffer onto the EH stack.
4488 objc_exception_try_exit pops the given catch buffer, which is
4489 required to be the top of the EH stack.
4490 objc_exception_throw pops the top of the EH stack, writes the
4491 thrown exception into the appropriate field, and longjmps
4492 to the setjmp buffer. It crashes the process (with a printf
4493 and an abort()) if there are no catch buffers on the stack.
4494 objc_exception_extract just reads the exception pointer out of the
4495 catch buffer.
4496
4497 There's no reason an implementation couldn't use a light-weight
4498 setjmp here --- something like __builtin_setjmp, but API-compatible
4499 with the heavyweight setjmp. This will be more important if we ever
4500 want to implement correct ObjC/C++ exception interactions for the
4501 fragile ABI.
4502
4503 Note that for this use of setjmp/longjmp to be correct, we may need
4504 to mark some local variables volatile: if a non-volatile local
4505 variable is modified between the setjmp and the longjmp, it has
4506 indeterminate value. For the purposes of LLVM IR, it may be
4507 sufficient to make loads and stores within the @try (to variables
4508 declared outside the @try) volatile. This is necessary for
4509 optimized correctness, but is not currently being done; this is
4510 being tracked as rdar://problem/8160285
4511
4512 The basic framework for a @try-catch-finally is as follows:
4513 {
4514 objc_exception_data d;
4515 id _rethrow = null;
4516 bool _call_try_exit = true;
4517
4518 objc_exception_try_enter(&d);
4519 if (!setjmp(d.jmp_buf)) {
4520 ... try body ...
4521 } else {
4522 // exception path
4523 id _caught = objc_exception_extract(&d);
4524
4525 // enter new try scope for handlers
4526 if (!setjmp(d.jmp_buf)) {
4527 ... match exception and execute catch blocks ...
4528
4529 // fell off end, rethrow.
4530 _rethrow = _caught;
4531 ... jump-through-finally to finally_rethrow ...
4532 } else {
4533 // exception in catch block
4534 _rethrow = objc_exception_extract(&d);
4535 _call_try_exit = false;
4536 ... jump-through-finally to finally_rethrow ...
4537 }
4538 }
4539 ... jump-through-finally to finally_end ...
4540
4541 finally:
4542 if (_call_try_exit)
4543 objc_exception_try_exit(&d);
4544
4545 ... finally block ....
4546 ... dispatch to finally destination ...
4547
4548 finally_rethrow:
4549 objc_exception_throw(_rethrow);
4550
4551 finally_end:
4552 }
4553
4554 This framework differs slightly from the one gcc uses, in that gcc
4555 uses _rethrow to determine if objc_exception_try_exit should be called
4556 and if the object should be rethrown. This breaks in the face of
4557 throwing nil and introduces unnecessary branches.
4558
4559 We specialize this framework for a few particular circumstances:
4560
4561 - If there are no catch blocks, then we avoid emitting the second
4562 exception handling context.
4563
4564 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4565 e)) we avoid emitting the code to rethrow an uncaught exception.
4566
4567 - FIXME: If there is no @finally block we can do a few more
4568 simplifications.
4569
4570 Rethrows and Jumps-Through-Finally
4571 --
4572
4573 '@throw;' is supported by pushing the currently-caught exception
4574 onto ObjCEHStack while the @catch blocks are emitted.
4575
4576 Branches through the @finally block are handled with an ordinary
4577 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
4578 exceptions are not compatible with C++ exceptions, and this is
4579 hardly the only place where this will go wrong.
4580
4581 @synchronized(expr) { stmt; } is emitted as if it were:
4582 id synch_value = expr;
4583 objc_sync_enter(synch_value);
4584 @try { stmt; } @finally { objc_sync_exit(synch_value); }
4585*/
4586
4587void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4588 const Stmt &S) {
4589 bool isTry = isa<ObjCAtTryStmt>(S);
4590
4591 // A destination for the fall-through edges of the catch handlers to
4592 // jump to.
4593 CodeGenFunction::JumpDest FinallyEnd =
4594 CGF.getJumpDestInCurrentScope("finally.end");
4595
4596 // A destination for the rethrow edge of the catch handlers to jump
4597 // to.
4598 CodeGenFunction::JumpDest FinallyRethrow =
4599 CGF.getJumpDestInCurrentScope("finally.rethrow");
4600
4601 // For @synchronized, call objc_sync_enter(sync.expr). The
4602 // evaluation of the expression must occur before we enter the
4603 // @synchronized. We can't avoid a temp here because we need the
4604 // value to be preserved. If the backend ever does liveness
4605 // correctly after setjmp, this will be unnecessary.
4606 Address SyncArgSlot = Address::invalid();
4607 if (!isTry) {
4608 llvm::Value *SyncArg =
4609 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4610 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4611 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4612
4613 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4614 CGF.getPointerAlign(), "sync.arg");
4615 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4616 }
4617
4618 // Allocate memory for the setjmp buffer. This needs to be kept
4619 // live throughout the try and catch blocks.
4620 Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4621 CGF.getPointerAlign(),
4622 "exceptiondata.ptr");
4623
4624 // Create the fragile hazards. Note that this will not capture any
4625 // of the allocas required for exception processing, but will
4626 // capture the current basic block (which extends all the way to the
4627 // setjmp call) as "before the @try".
4628 FragileHazards Hazards(CGF);
4629
4630 // Create a flag indicating whether the cleanup needs to call
4631 // objc_exception_try_exit. This is true except when
4632 // - no catches match and we're branching through the cleanup
4633 // just to rethrow the exception, or
4634 // - a catch matched and we're falling out of the catch handler.
4635 // The setjmp-safety rule here is that we should always store to this
4636 // variable in a place that dominates the branch through the cleanup
4637 // without passing through any setjmps.
4638 Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4639 CharUnits::One(),
4640 "_call_try_exit");
4641
4642 // A slot containing the exception to rethrow. Only needed when we
4643 // have both a @catch and a @finally.
4644 Address PropagatingExnVar = Address::invalid();
4645
4646 // Push a normal cleanup to leave the try scope.
4647 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4648 SyncArgSlot,
4649 CallTryExitVar,
4650 ExceptionData,
4651 &ObjCTypes);
4652
4653 // Enter a try block:
4654 // - Call objc_exception_try_enter to push ExceptionData on top of
4655 // the EH stack.
4656 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4657 ExceptionData.getPointer());
4658
4659 // - Call setjmp on the exception data buffer.
4660 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4661 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4662 llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4663 ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4664 "setjmp_buffer");
4665 llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4666 ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4667 SetJmpResult->setCanReturnTwice();
4668
4669 // If setjmp returned 0, enter the protected block; otherwise,
4670 // branch to the handler.
4671 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4672 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4673 llvm::Value *DidCatch =
4674 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4675 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4676
4677 // Emit the protected block.
4678 CGF.EmitBlock(TryBlock);
4679 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4680 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4681 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4682
4683 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4684
4685 // Emit the exception handler block.
4686 CGF.EmitBlock(TryHandler);
4687
4688 // Don't optimize loads of the in-scope locals across this point.
4689 Hazards.emitWriteHazard();
4690
4691 // For a @synchronized (or a @try with no catches), just branch
4692 // through the cleanup to the rethrow block.
4693 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4694 // Tell the cleanup not to re-pop the exit.
4695 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4696 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4697
4698 // Otherwise, we have to match against the caught exceptions.
4699 } else {
4700 // Retrieve the exception object. We may emit multiple blocks but
4701 // nothing can cross this so the value is already in SSA form.
4702 llvm::CallInst *Caught =
4703 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4704 ExceptionData.getPointer(), "caught");
4705
4706 // Push the exception to rethrow onto the EH value stack for the
4707 // benefit of any @throws in the handlers.
4708 CGF.ObjCEHValueStack.push_back(Caught);
4709
4710 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4711
4712 bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4713
4714 llvm::BasicBlock *CatchBlock = nullptr;
4715 llvm::BasicBlock *CatchHandler = nullptr;
4716 if (HasFinally) {
4717 // Save the currently-propagating exception before
4718 // objc_exception_try_enter clears the exception slot.
4719 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4720 CGF.getPointerAlign(),
4721 "propagating_exception");
4722 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4723
4724 // Enter a new exception try block (in case a @catch block
4725 // throws an exception).
4726 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4727 ExceptionData.getPointer());
4728
4729 llvm::CallInst *SetJmpResult =
4730 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4731 SetJmpBuffer, "setjmp.result");
4732 SetJmpResult->setCanReturnTwice();
4733
4734 llvm::Value *Threw =
4735 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4736
4737 CatchBlock = CGF.createBasicBlock("catch");
4738 CatchHandler = CGF.createBasicBlock("catch_for_catch");
4739 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4740
4741 CGF.EmitBlock(CatchBlock);
4742 }
4743
4744 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4745
4746 // Handle catch list. As a special case we check if everything is
4747 // matched and avoid generating code for falling off the end if
4748 // so.
4749 bool AllMatched = false;
4750 for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
4751 const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4752
4753 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4754 const ObjCObjectPointerType *OPT = nullptr;
4755
4756 // catch(...) always matches.
4757 if (!CatchParam) {
4758 AllMatched = true;
4759 } else {
4760 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4761
4762 // catch(id e) always matches under this ABI, since only
4763 // ObjC exceptions end up here in the first place.
4764 // FIXME: For the time being we also match id<X>; this should
4765 // be rejected by Sema instead.
4766 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4767 AllMatched = true;
4768 }
4769
4770 // If this is a catch-all, we don't need to test anything.
4771 if (AllMatched) {
4772 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4773
4774 if (CatchParam) {
4775 CGF.EmitAutoVarDecl(*CatchParam);
4776 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?")((CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"
) ? static_cast<void> (0) : __assert_fail ("CGF.HaveInsertPoint() && \"DeclStmt destroyed insert point?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4776, __PRETTY_FUNCTION__))
;
4777
4778 // These types work out because ConvertType(id) == i8*.
4779 EmitInitOfCatchParam(CGF, Caught, CatchParam);
4780 }
4781
4782 CGF.EmitStmt(CatchStmt->getCatchBody());
4783
4784 // The scope of the catch variable ends right here.
4785 CatchVarCleanups.ForceCleanup();
4786
4787 CGF.EmitBranchThroughCleanup(FinallyEnd);
4788 break;
4789 }
4790
4791 assert(OPT && "Unexpected non-object pointer type in @catch")((OPT && "Unexpected non-object pointer type in @catch"
) ? static_cast<void> (0) : __assert_fail ("OPT && \"Unexpected non-object pointer type in @catch\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4791, __PRETTY_FUNCTION__))
;
4792 const ObjCObjectType *ObjTy = OPT->getObjectType();
4793
4794 // FIXME: @catch (Class c) ?
4795 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4796 assert(IDecl && "Catch parameter must have Objective-C type!")((IDecl && "Catch parameter must have Objective-C type!"
) ? static_cast<void> (0) : __assert_fail ("IDecl && \"Catch parameter must have Objective-C type!\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4796, __PRETTY_FUNCTION__))
;
4797
4798 // Check if the @catch block matches the exception object.
4799 llvm::Value *Class = EmitClassRef(CGF, IDecl);
4800
4801 llvm::Value *matchArgs[] = { Class, Caught };
4802 llvm::CallInst *Match =
4803 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4804 matchArgs, "match");
4805
4806 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4807 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4808
4809 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4810 MatchedBlock, NextCatchBlock);
4811
4812 // Emit the @catch block.
4813 CGF.EmitBlock(MatchedBlock);
4814
4815 // Collect any cleanups for the catch variable. The scope lasts until
4816 // the end of the catch body.
4817 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4818
4819 CGF.EmitAutoVarDecl(*CatchParam);
4820 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?")((CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?"
) ? static_cast<void> (0) : __assert_fail ("CGF.HaveInsertPoint() && \"DeclStmt destroyed insert point?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4820, __PRETTY_FUNCTION__))
;
4821
4822 // Initialize the catch variable.
4823 llvm::Value *Tmp =
4824 CGF.Builder.CreateBitCast(Caught,
4825 CGF.ConvertType(CatchParam->getType()));
4826 EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4827
4828 CGF.EmitStmt(CatchStmt->getCatchBody());
4829
4830 // We're done with the catch variable.
4831 CatchVarCleanups.ForceCleanup();
4832
4833 CGF.EmitBranchThroughCleanup(FinallyEnd);
4834
4835 CGF.EmitBlock(NextCatchBlock);
4836 }
4837
4838 CGF.ObjCEHValueStack.pop_back();
4839
4840 // If nothing wanted anything to do with the caught exception,
4841 // kill the extract call.
4842 if (Caught->use_empty())
4843 Caught->eraseFromParent();
4844
4845 if (!AllMatched)
4846 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4847
4848 if (HasFinally) {
4849 // Emit the exception handler for the @catch blocks.
4850 CGF.EmitBlock(CatchHandler);
4851
4852 // In theory we might now need a write hazard, but actually it's
4853 // unnecessary because there's no local-accessing code between
4854 // the try's write hazard and here.
4855 //Hazards.emitWriteHazard();
4856
4857 // Extract the new exception and save it to the
4858 // propagating-exception slot.
4859 assert(PropagatingExnVar.isValid())((PropagatingExnVar.isValid()) ? static_cast<void> (0) :
__assert_fail ("PropagatingExnVar.isValid()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4859, __PRETTY_FUNCTION__))
;
4860 llvm::CallInst *NewCaught =
4861 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4862 ExceptionData.getPointer(), "caught");
4863 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4864
4865 // Don't pop the catch handler; the throw already did.
4866 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4867 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4868 }
4869 }
4870
4871 // Insert read hazards as required in the new blocks.
4872 Hazards.emitHazardsInNewBlocks();
4873
4874 // Pop the cleanup.
4875 CGF.Builder.restoreIP(TryFallthroughIP);
4876 if (CGF.HaveInsertPoint())
4877 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4878 CGF.PopCleanupBlock();
4879 CGF.EmitBlock(FinallyEnd.getBlock(), true);
4880
4881 // Emit the rethrow block.
4882 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4883 CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4884 if (CGF.HaveInsertPoint()) {
4885 // If we have a propagating-exception variable, check it.
4886 llvm::Value *PropagatingExn;
4887 if (PropagatingExnVar.isValid()) {
4888 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4889
4890 // Otherwise, just look in the buffer for the exception to throw.
4891 } else {
4892 llvm::CallInst *Caught =
4893 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4894 ExceptionData.getPointer());
4895 PropagatingExn = Caught;
4896 }
4897
4898 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4899 PropagatingExn);
4900 CGF.Builder.CreateUnreachable();
4901 }
4902
4903 CGF.Builder.restoreIP(SavedIP);
4904}
4905
4906void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4907 const ObjCAtThrowStmt &S,
4908 bool ClearInsertionPoint) {
4909 llvm::Value *ExceptionAsObject;
4910
4911 if (const Expr *ThrowExpr = S.getThrowExpr()) {
4912 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4913 ExceptionAsObject =
4914 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4915 } else {
4916 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&(((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack
.back()) && "Unexpected rethrow outside @catch block."
) ? static_cast<void> (0) : __assert_fail ("(!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && \"Unexpected rethrow outside @catch block.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4917, __PRETTY_FUNCTION__))
4917 "Unexpected rethrow outside @catch block.")(((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack
.back()) && "Unexpected rethrow outside @catch block."
) ? static_cast<void> (0) : __assert_fail ("(!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && \"Unexpected rethrow outside @catch block.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4917, __PRETTY_FUNCTION__))
;
4918 ExceptionAsObject = CGF.ObjCEHValueStack.back();
4919 }
4920
4921 CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4922 ->setDoesNotReturn();
4923 CGF.Builder.CreateUnreachable();
4924
4925 // Clear the insertion point to indicate we are in unreachable code.
4926 if (ClearInsertionPoint)
4927 CGF.Builder.ClearInsertionPoint();
4928}
4929
4930/// EmitObjCWeakRead - Code gen for loading value of a __weak
4931/// object: objc_read_weak (id *src)
4932///
4933llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4934 Address AddrWeakObj) {
4935 llvm::Type* DestTy = AddrWeakObj.getElementType();
4936 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4937 ObjCTypes.PtrObjectPtrTy);
4938 llvm::Value *read_weak =
4939 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4940 AddrWeakObj.getPointer(), "weakread");
4941 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4942 return read_weak;
4943}
4944
4945/// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4946/// objc_assign_weak (id src, id *dst)
4947///
4948void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4949 llvm::Value *src, Address dst) {
4950 llvm::Type * SrcTy = src->getType();
4951 if (!isa<llvm::PointerType>(SrcTy)) {
4952 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4953 assert(Size <= 8 && "does not support size > 8")((Size <= 8 && "does not support size > 8") ? static_cast
<void> (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4953, __PRETTY_FUNCTION__))
;
4954 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4955 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4956 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4957 }
4958 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4959 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4960 llvm::Value *args[] = { src, dst.getPointer() };
4961 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4962 args, "weakassign");
4963}
4964
4965/// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4966/// objc_assign_global (id src, id *dst)
4967///
4968void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4969 llvm::Value *src, Address dst,
4970 bool threadlocal) {
4971 llvm::Type * SrcTy = src->getType();
4972 if (!isa<llvm::PointerType>(SrcTy)) {
4973 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4974 assert(Size <= 8 && "does not support size > 8")((Size <= 8 && "does not support size > 8") ? static_cast
<void> (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4974, __PRETTY_FUNCTION__))
;
4975 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4976 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4977 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4978 }
4979 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4980 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4981 llvm::Value *args[] = { src, dst.getPointer() };
4982 if (!threadlocal)
4983 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4984 args, "globalassign");
4985 else
4986 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4987 args, "threadlocalassign");
4988}
4989
4990/// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4991/// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4992///
4993void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4994 llvm::Value *src, Address dst,
4995 llvm::Value *ivarOffset) {
4996 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL")((ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL"
) ? static_cast<void> (0) : __assert_fail ("ivarOffset && \"EmitObjCIvarAssign - ivarOffset is NULL\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 4996, __PRETTY_FUNCTION__))
;
4997 llvm::Type * SrcTy = src->getType();
4998 if (!isa<llvm::PointerType>(SrcTy)) {
4999 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5000 assert(Size <= 8 && "does not support size > 8")((Size <= 8 && "does not support size > 8") ? static_cast
<void> (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5000, __PRETTY_FUNCTION__))
;
5001 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5002 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5003 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5004 }
5005 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5006 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5007 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
5008 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
5009}
5010
5011/// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
5012/// objc_assign_strongCast (id src, id *dst)
5013///
5014void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
5015 llvm::Value *src, Address dst) {
5016 llvm::Type * SrcTy = src->getType();
5017 if (!isa<llvm::PointerType>(SrcTy)) {
5018 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5019 assert(Size <= 8 && "does not support size > 8")((Size <= 8 && "does not support size > 8") ? static_cast
<void> (0) : __assert_fail ("Size <= 8 && \"does not support size > 8\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5019, __PRETTY_FUNCTION__))
;
5020 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5021 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5022 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5023 }
5024 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5025 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5026 llvm::Value *args[] = { src, dst.getPointer() };
5027 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
5028 args, "strongassign");
5029}
5030
5031void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
5032 Address DestPtr,
5033 Address SrcPtr,
5034 llvm::Value *size) {
5035 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
5036 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
5037 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
5038 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
5039}
5040
5041/// EmitObjCValueForIvar - Code Gen for ivar reference.
5042///
5043LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
5044 QualType ObjectTy,
5045 llvm::Value *BaseValue,
5046 const ObjCIvarDecl *Ivar,
5047 unsigned CVRQualifiers) {
5048 const ObjCInterfaceDecl *ID =
5049 ObjectTy->castAs<ObjCObjectType>()->getInterface();
5050 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
5051 EmitIvarOffset(CGF, ID, Ivar));
5052}
5053
5054llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
5055 const ObjCInterfaceDecl *Interface,
5056 const ObjCIvarDecl *Ivar) {
5057 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
5058 return llvm::ConstantInt::get(
5059 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
5060 Offset);
5061}
5062
5063/* *** Private Interface *** */
5064
5065std::string CGObjCCommonMac::GetSectionName(StringRef Section,
5066 StringRef MachOAttributes) {
5067 switch (CGM.getTriple().getObjectFormat()) {
5068 case llvm::Triple::UnknownObjectFormat:
5069 llvm_unreachable("unexpected object file format")::llvm::llvm_unreachable_internal("unexpected object file format"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5069)
;
5070 case llvm::Triple::MachO: {
5071 if (MachOAttributes.empty())
5072 return ("__DATA," + Section).str();
5073 return ("__DATA," + Section + "," + MachOAttributes).str();
5074 }
5075 case llvm::Triple::ELF:
5076 assert(Section.substr(0, 2) == "__" &&((Section.substr(0, 2) == "__" && "expected the name to begin with __"
) ? static_cast<void> (0) : __assert_fail ("Section.substr(0, 2) == \"__\" && \"expected the name to begin with __\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5077, __PRETTY_FUNCTION__))
5077 "expected the name to begin with __")((Section.substr(0, 2) == "__" && "expected the name to begin with __"
) ? static_cast<void> (0) : __assert_fail ("Section.substr(0, 2) == \"__\" && \"expected the name to begin with __\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5077, __PRETTY_FUNCTION__))
;
5078 return Section.substr(2).str();
5079 case llvm::Triple::COFF:
5080 assert(Section.substr(0, 2) == "__" &&((Section.substr(0, 2) == "__" && "expected the name to begin with __"
) ? static_cast<void> (0) : __assert_fail ("Section.substr(0, 2) == \"__\" && \"expected the name to begin with __\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5081, __PRETTY_FUNCTION__))
5081 "expected the name to begin with __")((Section.substr(0, 2) == "__" && "expected the name to begin with __"
) ? static_cast<void> (0) : __assert_fail ("Section.substr(0, 2) == \"__\" && \"expected the name to begin with __\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5081, __PRETTY_FUNCTION__))
;
5082 return ("." + Section.substr(2) + "$B").str();
5083 case llvm::Triple::Wasm:
5084 case llvm::Triple::XCOFF:
5085 llvm::report_fatal_error(
5086 "Objective-C support is unimplemented for object file format.");
5087 }
5088
5089 llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum")::llvm::llvm_unreachable_internal("Unhandled llvm::Triple::ObjectFormatType enum"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5089)
;
5090}
5091
5092/// EmitImageInfo - Emit the image info marker used to encode some module
5093/// level information.
5094///
5095/// See: <rdr://4810609&4810587&4810587>
5096/// struct IMAGE_INFO {
5097/// unsigned version;
5098/// unsigned flags;
5099/// };
5100enum ImageInfoFlags {
5101 eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang.
5102 eImageInfo_GarbageCollected = (1 << 1),
5103 eImageInfo_GCOnly = (1 << 2),
5104 eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache.
5105
5106 // A flag indicating that the module has no instances of a @synthesize of a
5107 // superclass variable. <rdar://problem/6803242>
5108 eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
5109 eImageInfo_ImageIsSimulated = (1 << 5),
5110 eImageInfo_ClassProperties = (1 << 6)
5111};
5112
5113void CGObjCCommonMac::EmitImageInfo() {
5114 unsigned version = 0; // Version is unused?
5115 std::string Section =
5116 (ObjCABI == 1)
5117 ? "__OBJC,__image_info,regular"
5118 : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");
5119
5120 // Generate module-level named metadata to convey this information to the
5121 // linker and code-gen.
5122 llvm::Module &Mod = CGM.getModule();
5123
5124 // Add the ObjC ABI version to the module flags.
5125 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
5126 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
5127 version);
5128 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
5129 llvm::MDString::get(VMContext, Section));
5130
5131 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5132 // Non-GC overrides those files which specify GC.
5133 Mod.addModuleFlag(llvm::Module::Override,
5134 "Objective-C Garbage Collection", (uint32_t)0);
5135 } else {
5136 // Add the ObjC garbage collection value.
5137 Mod.addModuleFlag(llvm::Module::Error,
5138 "Objective-C Garbage Collection",
5139 eImageInfo_GarbageCollected);
5140
5141 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
5142 // Add the ObjC GC Only value.
5143 Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
5144 eImageInfo_GCOnly);
5145
5146 // Require that GC be specified and set to eImageInfo_GarbageCollected.
5147 llvm::Metadata *Ops[2] = {
5148 llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
5149 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
5150 llvm::Type::getInt32Ty(VMContext), eImageInfo_GarbageCollected))};
5151 Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
5152 llvm::MDNode::get(VMContext, Ops));
5153 }
5154 }
5155
5156 // Indicate whether we're compiling this to run on a simulator.
5157 if (CGM.getTarget().getTriple().isSimulatorEnvironment())
5158 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
5159 eImageInfo_ImageIsSimulated);
5160
5161 // Indicate whether we are generating class properties.
5162 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
5163 eImageInfo_ClassProperties);
5164}
5165
5166// struct objc_module {
5167// unsigned long version;
5168// unsigned long size;
5169// const char *name;
5170// Symtab symtab;
5171// };
5172
5173// FIXME: Get from somewhere
5174static const int ModuleVersion = 7;
5175
5176void CGObjCMac::EmitModuleInfo() {
5177 uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
5178
5179 ConstantInitBuilder builder(CGM);
5180 auto values = builder.beginStruct(ObjCTypes.ModuleTy);
5181 values.addInt(ObjCTypes.LongTy, ModuleVersion);
5182 values.addInt(ObjCTypes.LongTy, Size);
5183 // This used to be the filename, now it is unused. <rdr://4327263>
5184 values.add(GetClassName(StringRef("")));
5185 values.add(EmitModuleSymbols());
5186 CreateMetadataVar("OBJC_MODULES", values,
5187 "__OBJC,__module_info,regular,no_dead_strip",
5188 CGM.getPointerAlign(), true);
5189}
5190
5191llvm::Constant *CGObjCMac::EmitModuleSymbols() {
5192 unsigned NumClasses = DefinedClasses.size();
5193 unsigned NumCategories = DefinedCategories.size();
5194
5195 // Return null if no symbols were defined.
5196 if (!NumClasses && !NumCategories)
5197 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
5198
5199 ConstantInitBuilder builder(CGM);
5200 auto values = builder.beginStruct();
5201 values.addInt(ObjCTypes.LongTy, 0);
5202 values.addNullPointer(ObjCTypes.SelectorPtrTy);
5203 values.addInt(ObjCTypes.ShortTy, NumClasses);
5204 values.addInt(ObjCTypes.ShortTy, NumCategories);
5205
5206 // The runtime expects exactly the list of defined classes followed
5207 // by the list of defined categories, in a single array.
5208 auto array = values.beginArray(ObjCTypes.Int8PtrTy);
5209 for (unsigned i=0; i<NumClasses; i++) {
5210 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
5211 assert(ID)((ID) ? static_cast<void> (0) : __assert_fail ("ID", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5211, __PRETTY_FUNCTION__))
;
5212 if (ObjCImplementationDecl *IMP = ID->getImplementation())
5213 // We are implementing a weak imported interface. Give it external linkage
5214 if (ID->isWeakImported() && !IMP->isWeakImported())
5215 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5216
5217 array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy);
5218 }
5219 for (unsigned i=0; i<NumCategories; i++)
5220 array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy);
5221
5222 array.finishAndAddTo(values);
5223
5224 llvm::GlobalVariable *GV = CreateMetadataVar(
5225 "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip",
5226 CGM.getPointerAlign(), true);
5227 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
5228}
5229
5230llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
5231 IdentifierInfo *II) {
5232 LazySymbols.insert(II);
5233
5234 llvm::GlobalVariable *&Entry = ClassReferences[II];
5235
5236 if (!Entry) {
5237 llvm::Constant *Casted =
5238 llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
5239 ObjCTypes.ClassPtrTy);
5240 Entry = CreateMetadataVar(
5241 "OBJC_CLASS_REFERENCES_", Casted,
5242 "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
5243 CGM.getPointerAlign(), true);
5244 }
5245
5246 return CGF.Builder.CreateAlignedLoad(Entry, CGF.getPointerAlign());
5247}
5248
5249llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
5250 const ObjCInterfaceDecl *ID) {
5251 // If the class has the objc_runtime_visible attribute, we need to
5252 // use the Objective-C runtime to get the class.
5253 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
5254 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
5255
5256 IdentifierInfo *RuntimeName =
5257 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
5258 return EmitClassRefFromId(CGF, RuntimeName);
5259}
5260
5261llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
5262 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
5263 return EmitClassRefFromId(CGF, II);
5264}
5265
5266llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
5267 return CGF.Builder.CreateLoad(EmitSelectorAddr(Sel));
5268}
5269
5270Address CGObjCMac::EmitSelectorAddr(Selector Sel) {
5271 CharUnits Align = CGM.getPointerAlign();
5272
5273 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
5274 if (!Entry) {
5275 llvm::Constant *Casted =
5276 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5277 ObjCTypes.SelectorPtrTy);
5278 Entry = CreateMetadataVar(
5279 "OBJC_SELECTOR_REFERENCES_", Casted,
5280 "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
5281 Entry->setExternallyInitialized(true);
5282 }
5283
5284 return Address(Entry, Align);
5285}
5286
5287llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
5288 llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
5289 if (!Entry)
5290 Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
5291 return getConstantGEP(VMContext, Entry, 0, 0);
5292}
5293
5294llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
5295 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
5296 I = MethodDefinitions.find(MD);
5297 if (I != MethodDefinitions.end())
5298 return I->second;
5299
5300 return nullptr;
5301}
5302
5303/// GetIvarLayoutName - Returns a unique constant for the given
5304/// ivar layout bitmap.
5305llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
5306 const ObjCCommonTypesHelper &ObjCTypes) {
5307 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5308}
5309
5310void IvarLayoutBuilder::visitRecord(const RecordType *RT,
5311 CharUnits offset) {
5312 const RecordDecl *RD = RT->getDecl();
5313
5314 // If this is a union, remember that we had one, because it might mess
5315 // up the ordering of layout entries.
5316 if (RD->isUnion())
5317 IsDisordered = true;
5318
5319 const ASTRecordLayout *recLayout = nullptr;
5320 visitAggregate(RD->field_begin(), RD->field_end(), offset,
5321 [&](const FieldDecl *field) -> CharUnits {
5322 if (!recLayout)
5323 recLayout = &CGM.getContext().getASTRecordLayout(RD);
5324 auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
5325 return CGM.getContext().toCharUnitsFromBits(offsetInBits);
5326 });
5327}
5328
5329template <class Iterator, class GetOffsetFn>
5330void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
5331 CharUnits aggregateOffset,
5332 const GetOffsetFn &getOffset) {
5333 for (; begin != end; ++begin) {
5334 auto field = *begin;
5335
5336 // Skip over bitfields.
5337 if (field->isBitField()) {
5338 continue;
5339 }
5340
5341 // Compute the offset of the field within the aggregate.
5342 CharUnits fieldOffset = aggregateOffset + getOffset(field);
5343
5344 visitField(field, fieldOffset);
5345 }
5346}
5347
5348/// Collect layout information for the given fields into IvarsInfo.
5349void IvarLayoutBuilder::visitField(const FieldDecl *field,
5350 CharUnits fieldOffset) {
5351 QualType fieldType = field->getType();
5352
5353 // Drill down into arrays.
5354 uint64_t numElts = 1;
5355 if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) {
5356 numElts = 0;
5357 fieldType = arrayType->getElementType();
5358 }
5359 // Unlike incomplete arrays, constant arrays can be nested.
5360 while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
5361 numElts *= arrayType->getSize().getZExtValue();
5362 fieldType = arrayType->getElementType();
5363 }
5364
5365 assert(!fieldType->isArrayType() && "ivar of non-constant array type?")((!fieldType->isArrayType() && "ivar of non-constant array type?"
) ? static_cast<void> (0) : __assert_fail ("!fieldType->isArrayType() && \"ivar of non-constant array type?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5365, __PRETTY_FUNCTION__))
;
5366
5367 // If we ended up with a zero-sized array, we've done what we can do within
5368 // the limits of this layout encoding.
5369 if (numElts == 0) return;
5370
5371 // Recurse if the base element type is a record type.
5372 if (auto recType = fieldType->getAs<RecordType>()) {
5373 size_t oldEnd = IvarsInfo.size();
5374
5375 visitRecord(recType, fieldOffset);
5376
5377 // If we have an array, replicate the first entry's layout information.
5378 auto numEltEntries = IvarsInfo.size() - oldEnd;
5379 if (numElts != 1 && numEltEntries != 0) {
5380 CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5381 for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
5382 // Copy the last numEltEntries onto the end of the array, adjusting
5383 // each for the element size.
5384 for (size_t i = 0; i != numEltEntries; ++i) {
5385 auto firstEntry = IvarsInfo[oldEnd + i];
5386 IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
5387 firstEntry.SizeInWords));
5388 }
5389 }
5390 }
5391
5392 return;
5393 }
5394
5395 // Classify the element type.
5396 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
5397
5398 // If it matches what we're looking for, add an entry.
5399 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
5400 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
5401 assert(CGM.getContext().getTypeSizeInChars(fieldType)((CGM.getContext().getTypeSizeInChars(fieldType) == CGM.getPointerSize
()) ? static_cast<void> (0) : __assert_fail ("CGM.getContext().getTypeSizeInChars(fieldType) == CGM.getPointerSize()"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5402, __PRETTY_FUNCTION__))
5402 == CGM.getPointerSize())((CGM.getContext().getTypeSizeInChars(fieldType) == CGM.getPointerSize
()) ? static_cast<void> (0) : __assert_fail ("CGM.getContext().getTypeSizeInChars(fieldType) == CGM.getPointerSize()"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5402, __PRETTY_FUNCTION__))
;
5403 IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
5404 }
5405}
5406
5407/// buildBitmap - This routine does the horsework of taking the offsets of
5408/// strong/weak references and creating a bitmap. The bitmap is also
5409/// returned in the given buffer, suitable for being passed to \c dump().
5410llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
5411 llvm::SmallVectorImpl<unsigned char> &buffer) {
5412 // The bitmap is a series of skip/scan instructions, aligned to word
5413 // boundaries. The skip is performed first.
5414 const unsigned char MaxNibble = 0xF;
5415 const unsigned char SkipMask = 0xF0, SkipShift = 4;
5416 const unsigned char ScanMask = 0x0F, ScanShift = 0;
5417
5418 assert(!IvarsInfo.empty() && "generating bitmap for no data")((!IvarsInfo.empty() && "generating bitmap for no data"
) ? static_cast<void> (0) : __assert_fail ("!IvarsInfo.empty() && \"generating bitmap for no data\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5418, __PRETTY_FUNCTION__))
;
5419
5420 // Sort the ivar info on byte position in case we encounterred a
5421 // union nested in the ivar list.
5422 if (IsDisordered) {
5423 // This isn't a stable sort, but our algorithm should handle it fine.
5424 llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
5425 } else {
5426 assert(std::is_sorted(IvarsInfo.begin(), IvarsInfo.end()))((std::is_sorted(IvarsInfo.begin(), IvarsInfo.end())) ? static_cast
<void> (0) : __assert_fail ("std::is_sorted(IvarsInfo.begin(), IvarsInfo.end())"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5426, __PRETTY_FUNCTION__))
;
5427 }
5428 assert(IvarsInfo.back().Offset < InstanceEnd)((IvarsInfo.back().Offset < InstanceEnd) ? static_cast<
void> (0) : __assert_fail ("IvarsInfo.back().Offset < InstanceEnd"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5428, __PRETTY_FUNCTION__))
;
5429
5430 assert(buffer.empty())((buffer.empty()) ? static_cast<void> (0) : __assert_fail
("buffer.empty()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5430, __PRETTY_FUNCTION__))
;
5431
5432 // Skip the next N words.
5433 auto skip = [&](unsigned numWords) {
5434 assert(numWords > 0)((numWords > 0) ? static_cast<void> (0) : __assert_fail
("numWords > 0", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5434, __PRETTY_FUNCTION__))
;
5435
5436 // Try to merge into the previous byte. Since scans happen second, we
5437 // can't do this if it includes a scan.
5438 if (!buffer.empty() && !(buffer.back() & ScanMask)) {
5439 unsigned lastSkip = buffer.back() >> SkipShift;
5440 if (lastSkip < MaxNibble) {
5441 unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
5442 numWords -= claimed;
5443 lastSkip += claimed;
5444 buffer.back() = (lastSkip << SkipShift);
5445 }
5446 }
5447
5448 while (numWords >= MaxNibble) {
5449 buffer.push_back(MaxNibble << SkipShift);
5450 numWords -= MaxNibble;
5451 }
5452 if (numWords) {
5453 buffer.push_back(numWords << SkipShift);
5454 }
5455 };
5456
5457 // Scan the next N words.
5458 auto scan = [&](unsigned numWords) {
5459 assert(numWords > 0)((numWords > 0) ? static_cast<void> (0) : __assert_fail
("numWords > 0", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5459, __PRETTY_FUNCTION__))
;
5460
5461 // Try to merge into the previous byte. Since scans happen second, we can
5462 // do this even if it includes a skip.
5463 if (!buffer.empty()) {
5464 unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
5465 if (lastScan < MaxNibble) {
5466 unsigned claimed = std::min(MaxNibble - lastScan, numWords);
5467 numWords -= claimed;
5468 lastScan += claimed;
5469 buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
5470 }
5471 }
5472
5473 while (numWords >= MaxNibble) {
5474 buffer.push_back(MaxNibble << ScanShift);
5475 numWords -= MaxNibble;
5476 }
5477 if (numWords) {
5478 buffer.push_back(numWords << ScanShift);
5479 }
5480 };
5481
5482 // One past the end of the last scan.
5483 unsigned endOfLastScanInWords = 0;
5484 const CharUnits WordSize = CGM.getPointerSize();
5485
5486 // Consider all the scan requests.
5487 for (auto &request : IvarsInfo) {
5488 CharUnits beginOfScan = request.Offset - InstanceBegin;
5489
5490 // Ignore scan requests that don't start at an even multiple of the
5491 // word size. We can't encode them.
5492 if ((beginOfScan % WordSize) != 0) continue;
5493
5494 // Ignore scan requests that start before the instance start.
5495 // This assumes that scans never span that boundary. The boundary
5496 // isn't the true start of the ivars, because in the fragile-ARC case
5497 // it's rounded up to word alignment, but the test above should leave
5498 // us ignoring that possibility.
5499 if (beginOfScan.isNegative()) {
5500 assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin)((request.Offset + request.SizeInWords * WordSize <= InstanceBegin
) ? static_cast<void> (0) : __assert_fail ("request.Offset + request.SizeInWords * WordSize <= InstanceBegin"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5500, __PRETTY_FUNCTION__))
;
5501 continue;
5502 }
5503
5504 unsigned beginOfScanInWords = beginOfScan / WordSize;
5505 unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
5506
5507 // If the scan starts some number of words after the last one ended,
5508 // skip forward.
5509 if (beginOfScanInWords > endOfLastScanInWords) {
5510 skip(beginOfScanInWords - endOfLastScanInWords);
5511
5512 // Otherwise, start scanning where the last left off.
5513 } else {
5514 beginOfScanInWords = endOfLastScanInWords;
5515
5516 // If that leaves us with nothing to scan, ignore this request.
5517 if (beginOfScanInWords >= endOfScanInWords) continue;
5518 }
5519
5520 // Scan to the end of the request.
5521 assert(beginOfScanInWords < endOfScanInWords)((beginOfScanInWords < endOfScanInWords) ? static_cast<
void> (0) : __assert_fail ("beginOfScanInWords < endOfScanInWords"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5521, __PRETTY_FUNCTION__))
;
5522 scan(endOfScanInWords - beginOfScanInWords);
5523 endOfLastScanInWords = endOfScanInWords;
5524 }
5525
5526 if (buffer.empty())
5527 return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
5528
5529 // For GC layouts, emit a skip to the end of the allocation so that we
5530 // have precise information about the entire thing. This isn't useful
5531 // or necessary for the ARC-style layout strings.
5532 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5533 unsigned lastOffsetInWords =
5534 (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5535 if (lastOffsetInWords > endOfLastScanInWords) {
5536 skip(lastOffsetInWords - endOfLastScanInWords);
5537 }
5538 }
5539
5540 // Null terminate the string.
5541 buffer.push_back(0);
5542
5543 auto *Entry = CGObjC.CreateCStringLiteral(
5544 reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
5545 return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5546}
5547
5548/// BuildIvarLayout - Builds ivar layout bitmap for the class
5549/// implementation for the __strong or __weak case.
5550/// The layout map displays which words in ivar list must be skipped
5551/// and which must be scanned by GC (see below). String is built of bytes.
5552/// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5553/// of words to skip and right nibble is count of words to scan. So, each
5554/// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5555/// represented by a 0x00 byte which also ends the string.
5556/// 1. when ForStrongLayout is true, following ivars are scanned:
5557/// - id, Class
5558/// - object *
5559/// - __strong anything
5560///
5561/// 2. When ForStrongLayout is false, following ivars are scanned:
5562/// - __weak anything
5563///
5564llvm::Constant *
5565CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
5566 CharUnits beginOffset, CharUnits endOffset,
5567 bool ForStrongLayout, bool HasMRCWeakIvars) {
5568 // If this is MRC, and we're either building a strong layout or there
5569 // are no weak ivars, bail out early.
5570 llvm::Type *PtrTy = CGM.Int8PtrTy;
5571 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5572 !CGM.getLangOpts().ObjCAutoRefCount &&
5573 (ForStrongLayout || !HasMRCWeakIvars))
5574 return llvm::Constant::getNullValue(PtrTy);
5575
5576 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5577 SmallVector<const ObjCIvarDecl*, 32> ivars;
5578
5579 // GC layout strings include the complete object layout, possibly
5580 // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5581 // up.
5582 //
5583 // ARC layout strings only include the class's ivars. In non-fragile
5584 // runtimes, that means starting at InstanceStart, rounded up to word
5585 // alignment. In fragile runtimes, there's no InstanceStart, so it means
5586 // starting at the offset of the first ivar, rounded up to word alignment.
5587 //
5588 // MRC weak layout strings follow the ARC style.
5589 CharUnits baseOffset;
5590 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5591 for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5592 IVD; IVD = IVD->getNextIvar())
5593 ivars.push_back(IVD);
5594
5595 if (isNonFragileABI()) {
5596 baseOffset = beginOffset; // InstanceStart
5597 } else if (!ivars.empty()) {
5598 baseOffset =
5599 CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5600 } else {
5601 baseOffset = CharUnits::Zero();
5602 }
5603
5604 baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5605 }
5606 else {
5607 CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5608
5609 baseOffset = CharUnits::Zero();
5610 }
5611
5612 if (ivars.empty())
5613 return llvm::Constant::getNullValue(PtrTy);
5614
5615 IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5616
5617 builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5618 [&](const ObjCIvarDecl *ivar) -> CharUnits {
5619 return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5620 });
5621
5622 if (!builder.hasBitmapData())
5623 return llvm::Constant::getNullValue(PtrTy);
5624
5625 llvm::SmallVector<unsigned char, 4> buffer;
5626 llvm::Constant *C = builder.buildBitmap(*this, buffer);
5627
5628 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5629 printf("\n%s ivar layout for class '%s': ",
5630 ForStrongLayout ? "strong" : "weak",
5631 OMD->getClassInterface()->getName().str().c_str());
5632 builder.dump(buffer);
5633 }
5634 return C;
5635}
5636
5637llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5638 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5639 // FIXME: Avoid std::string in "Sel.getAsString()"
5640 if (!Entry)
5641 Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
5642 return getConstantGEP(VMContext, Entry, 0, 0);
5643}
5644
5645// FIXME: Merge into a single cstring creation function.
5646llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5647 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5648}
5649
5650llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5651 std::string TypeStr;
5652 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5653
5654 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5655 if (!Entry)
5656 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5657 return getConstantGEP(VMContext, Entry, 0, 0);
5658}
5659
5660llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5661 bool Extended) {
5662 std::string TypeStr =
5663 CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);
5664
5665 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5666 if (!Entry)
5667 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5668 return getConstantGEP(VMContext, Entry, 0, 0);
5669}
5670
5671// FIXME: Merge into a single cstring creation function.
5672llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5673 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5674 if (!Entry)
5675 Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
5676 return getConstantGEP(VMContext, Entry, 0, 0);
5677}
5678
5679// FIXME: Merge into a single cstring creation function.
5680// FIXME: This Decl should be more precise.
5681llvm::Constant *
5682CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5683 const Decl *Container) {
5684 std::string TypeStr =
5685 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
5686 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5687}
5688
5689void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
5690 const ObjCContainerDecl *CD,
5691 SmallVectorImpl<char> &Name,
5692 bool ignoreCategoryNamespace) {
5693 llvm::raw_svector_ostream OS(Name);
5694 assert (CD && "Missing container decl in GetNameForMethod")((CD && "Missing container decl in GetNameForMethod")
? static_cast<void> (0) : __assert_fail ("CD && \"Missing container decl in GetNameForMethod\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/CodeGen/CGObjCMac.cpp"
, 5694, __PRETTY_FUNCTION__))
;
5695 OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
5696 << '[' << CD->getName();
5697 if (!ignoreCategoryNamespace)
5698 if (const ObjCCategoryImplDecl *CID =
5699 dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
5700 OS << '(' << *CID << ')';
5701 OS << ' ' << D->getSelector().getAsString() << ']';
5702}
5703
5704void CGObjCMac::FinishModule() {
5705 EmitModuleInfo();
5706
5707 // Emit the dummy bodies for any protocols which were referenced but
5708 // never defined.
5709 for (auto &entry : Protocols) {
5710 llvm::GlobalVariable *global = entry.second;
5711 if (global->hasInitializer())
5712 continue;
5713
5714 ConstantInitBuilder builder(CGM);
5715 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
5716 values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
5717 values.add(GetClassName(entry.first->getName()));
5718 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
5719 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5720 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5721 values.finishAndSetAsInitializer(global);
5722 CGM.addCompilerUsedGlobal(global);
5723 }
5724
5725 // Add assembler directives to add lazy undefined symbol references
5726 // for classes which are referenced but not defined. This is
5727 // important for correct linker interaction.
5728 //
5729 // FIXME: It would be nice if we had an LLVM construct for this.
5730 if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
5731 CGM.getTriple().isOSBinFormatMachO()) {
5732 SmallString<256> Asm;
5733 Asm += CGM.getModule().getModuleInlineAsm();
5734 if (!Asm.empty() && Asm.back() != '\n')
5735 Asm += '\n';
5736
5737 llvm::raw_svector_ostream OS(Asm);
5738 for (const auto *Sym : DefinedSymbols)
5739 OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
5740 << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
5741 for (const auto *Sym : LazySymbols)
5742 OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
5743 for (const auto &Category : DefinedCategoryNames)
5744 OS << "\t.objc_category_name_" << Category << "=0\n"
5745 << "\t.globl .objc_category_name_" << Category << "\n";
5746
5747 CGM.getModule().setModuleInlineAsm(OS.str());
5748 }
5749}
5750
5751CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5752 : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
5753 ObjCEmptyVtableVar(nullptr) {
5754 ObjCABI = 2;
5755}
5756
5757/* *** */
5758
5759ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5760 : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5761{
5762 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5763 ASTContext &Ctx = CGM.getContext();
5764
5765 ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
5766 IntTy = CGM.IntTy;
5767 LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
5768 Int8PtrTy = CGM.Int8PtrTy;
5769 Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5770
5771 // arm64 targets use "int" ivar offset variables. All others,
5772 // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5773 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5774 IvarOffsetVarTy = IntTy;
5775 else
5776 IvarOffsetVarTy = LongTy;
5777
5778 ObjectPtrTy =
5779 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
5780 PtrObjectPtrTy =
5781 llvm::PointerType::getUnqual(ObjectPtrTy);
5782 SelectorPtrTy =
5783 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
5784
5785 // I'm not sure I like this. The implicit coordination is a bit
5786 // gross. We should solve this in a reasonable fashion because this
5787 // is a pretty common task (match some runtime data structure with
5788 // an LLVM data structure).
5789
5790 // FIXME: This is leaked.
5791 // FIXME: Merge with rewriter code?
5792
5793 // struct _objc_super {
5794 // id self;
5795 // Class cls;
5796 // }
5797 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5798 Ctx.getTranslationUnitDecl(),
5799 SourceLocation(), SourceLocation(),
5800 &Ctx.Idents.get("_objc_super"));
5801 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5802 nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5803 false, ICIS_NoInit));
5804 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5805 nullptr, Ctx.getObjCClassType(), nullptr,
5806 nullptr, false, ICIS_NoInit));
5807 RD->completeDefinition();
5808
5809 SuperCTy = Ctx.getTagDeclType(RD);
5810 SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5811
5812 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5813 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5814
5815 // struct _prop_t {
5816 // char *name;
5817 // char *attributes;
5818 // }
5819 PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy);
5820
5821 // struct _prop_list_t {
5822 // uint32_t entsize; // sizeof(struct _prop_t)
5823 // uint32_t count_of_properties;
5824 // struct _prop_t prop_list[count_of_properties];
5825 // }
5826 PropertyListTy = llvm::StructType::create(
5827 "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0));
5828 // struct _prop_list_t *
5829 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5830
5831 // struct _objc_method {
5832 // SEL _cmd;
5833 // char *method_type;
5834 // char *_imp;
5835 // }
5836 MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy,
5837 Int8PtrTy, Int8PtrTy);
5838
5839 // struct _objc_cache *
5840 CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5841 CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5842}
5843
5844ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5845 : ObjCCommonTypesHelper(cgm) {
5846 // struct _objc_method_description {
5847 // SEL name;
5848 // char *types;
5849 // }
5850 MethodDescriptionTy = llvm::StructType::create(
5851 "struct._objc_method_description", SelectorPtrTy, Int8PtrTy);
5852
5853 // struct _objc_method_description_list {
5854 // int count;
5855 // struct _objc_method_description[1];
5856 // }
5857 MethodDescriptionListTy =
5858 llvm::StructType::create("struct._objc_method_description_list", IntTy,
5859 llvm::ArrayType::get(MethodDescriptionTy, 0));
5860
5861 // struct _objc_method_description_list *
5862 MethodDescriptionListPtrTy =
5863 llvm::PointerType::getUnqual(MethodDescriptionListTy);
5864
5865 // Protocol description structures
5866
5867 // struct _objc_protocol_extension {
5868 // uint32_t size; // sizeof(struct _objc_protocol_extension)
5869 // struct _objc_method_description_list *optional_instance_methods;
5870 // struct _objc_method_description_list *optional_class_methods;
5871 // struct _objc_property_list *instance_properties;
5872 // const char ** extendedMethodTypes;
5873 // struct _objc_property_list *class_properties;
5874 // }
5875 ProtocolExtensionTy = llvm::StructType::create(
5876 "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy,
5877 MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy,
5878 PropertyListPtrTy);
5879
5880 // struct _objc_protocol_extension *
5881 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5882
5883 // Handle recursive construction of Protocol and ProtocolList types
5884
5885 ProtocolTy =
5886 llvm::StructType::create(VMContext, "struct._objc_protocol");
5887
5888 ProtocolListTy =
5889 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5890 ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy,
5891 llvm::ArrayType::get(ProtocolTy, 0));
5892
5893 // struct _objc_protocol {
5894 // struct _objc_protocol_extension *isa;
5895 // char *protocol_name;
5896 // struct _objc_protocol **_objc_protocol_list;
5897 // struct _objc_method_description_list *instance_methods;
5898 // struct _objc_method_description_list *class_methods;
5899 // }
5900 ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5901 llvm::PointerType::getUnqual(ProtocolListTy),
5902 MethodDescriptionListPtrTy, MethodDescriptionListPtrTy);
5903
5904 // struct _objc_protocol_list *
5905 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5906
5907 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5908
5909 // Class description structures
5910
5911 // struct _objc_ivar {
5912 // char *ivar_name;
5913 // char *ivar_type;
5914 // int ivar_offset;
5915 // }
5916 IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy,
5917 IntTy);
5918
5919 // struct _objc_ivar_list *
5920 IvarListTy =
5921 llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5922 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5923
5924 // struct _objc_method_list *
5925 MethodListTy =
5926 llvm::StructType::create(VMContext, "struct._objc_method_list");
5927 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5928
5929 // struct _objc_class_extension *
5930 ClassExtensionTy = llvm::StructType::create(
5931 "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy);
5932 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5933
5934 ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5935
5936 // struct _objc_class {
5937 // Class isa;
5938 // Class super_class;
5939 // char *name;
5940 // long version;
5941 // long info;
5942 // long instance_size;
5943 // struct _objc_ivar_list *ivars;
5944 // struct _objc_method_list *methods;
5945 // struct _objc_cache *cache;
5946 // struct _objc_protocol_list *protocols;
5947 // char *ivar_layout;
5948 // struct _objc_class_ext *ext;
5949 // };
5950 ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5951 llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy,
5952 LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy,
5953 ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy);
5954
5955 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5956
5957 // struct _objc_category {
5958 // char *category_name;
5959 // char *class_name;
5960 // struct _objc_method_list *instance_method;
5961 // struct _objc_method_list *class_method;
5962 // struct _objc_protocol_list *protocols;
5963 // uint32_t size; // sizeof(struct _objc_category)
5964 // struct _objc_property_list *instance_properties;// category's @property
5965 // struct _objc_property_list *class_properties;
5966 // }
5967 CategoryTy = llvm::StructType::create(
5968 "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5969 MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy,
5970 PropertyListPtrTy);
5971
5972 // Global metadata structures
5973
5974 // struct _objc_symtab {
5975 // long sel_ref_cnt;
5976 // SEL *refs;
5977 // short cls_def_cnt;
5978 // short cat_def_cnt;
5979 // char *defs[cls_def_cnt + cat_def_cnt];
5980 // }
5981 SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy,
5982 SelectorPtrTy, ShortTy, ShortTy,
5983 llvm::ArrayType::get(Int8PtrTy, 0));
5984 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
5985
5986 // struct _objc_module {
5987 // long version;
5988 // long size; // sizeof(struct _objc_module)
5989 // char *name;
5990 // struct _objc_symtab* symtab;
5991 // }
5992 ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy,
5993 Int8PtrTy, SymtabPtrTy);
5994
5995 // FIXME: This is the size of the setjmp buffer and should be target
5996 // specific. 18 is what's used on 32-bit X86.
5997 uint64_t SetJmpBufferSize = 18;
5998
5999 // Exceptions
6000 llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
6001
6002 ExceptionDataTy = llvm::StructType::create(
6003 "struct._objc_exception_data",
6004 llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy);
6005}
6006
6007ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
6008 : ObjCCommonTypesHelper(cgm) {
6009 // struct _method_list_t {
6010 // uint32_t entsize; // sizeof(struct _objc_method)
6011 // uint32_t method_count;
6012 // struct _objc_method method_list[method_count];
6013 // }
6014 MethodListnfABITy =
6015 llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
6016 llvm::ArrayType::get(MethodTy, 0));
6017 // struct method_list_t *
6018 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
6019
6020 // struct _protocol_t {
6021 // id isa; // NULL
6022 // const char * const protocol_name;
6023 // const struct _protocol_list_t * protocol_list; // super protocols
6024 // const struct method_list_t * const instance_methods;
6025 // const struct method_list_t * const class_methods;
6026 // const struct method_list_t *optionalInstanceMethods;
6027 // const struct method_list_t *optionalClassMethods;
6028 // const struct _prop_list_t * properties;
6029 // const uint32_t size; // sizeof(struct _protocol_t)
6030 // const uint32_t flags; // = 0
6031 // const char ** extendedMethodTypes;
6032 // const char *demangledName;
6033 // const struct _prop_list_t * class_properties;
6034 // }
6035
6036 // Holder for struct _protocol_list_t *
6037 ProtocolListnfABITy =
6038 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
6039
6040 ProtocolnfABITy = llvm::StructType::create(
6041 "struct._protocol_t", ObjectPtrTy, Int8PtrTy,
6042 llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy,
6043 MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy,
6044 PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy,
6045 PropertyListPtrTy);
6046
6047 // struct _protocol_t*
6048 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
6049
6050 // struct _protocol_list_t {
6051 // long protocol_count; // Note, this is 32/64 bit
6052 // struct _protocol_t *[protocol_count];
6053 // }
6054 ProtocolListnfABITy->setBody(LongTy,
6055 llvm::ArrayType::get(ProtocolnfABIPtrTy, 0));
6056
6057 // struct _objc_protocol_list*
6058 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
6059
6060 // struct _ivar_t {
6061 // unsigned [long] int *offset; // pointer to ivar offset location
6062 // char *name;
6063 // char *type;
6064 // uint32_t alignment;
6065 // uint32_t size;
6066 // }
6067 IvarnfABITy = llvm::StructType::create(
6068 "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
6069 Int8PtrTy, Int8PtrTy, IntTy, IntTy);
6070
6071 // struct _ivar_list_t {
6072 // uint32 entsize; // sizeof(struct _ivar_t)
6073 // uint32 count;
6074 // struct _iver_t list[count];
6075 // }
6076 IvarListnfABITy =
6077 llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
6078 llvm::ArrayType::get(IvarnfABITy, 0));
6079
6080 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
6081
6082 // struct _class_ro_t {
6083 // uint32_t const flags;
6084 // uint32_t const instanceStart;
6085 // uint32_t const instanceSize;
6086 // uint32_t const reserved; // only when building for 64bit targets
6087 // const uint8_t * const ivarLayout;
6088 // const char *const name;
6089 // const struct _method_list_t * const baseMethods;
6090 // const struct _objc_protocol_list *const baseProtocols;
6091 // const struct _ivar_list_t *const ivars;
6092 // const uint8_t * const weakIvarLayout;
6093 // const struct _prop_list_t * const properties;