Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

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