Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

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