Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGObjCMac.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~svn374877/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~svn374877/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn374877/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~svn374877/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn374877=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-15-233810-7101-1 -x c++ /build/llvm-toolchain-snapshot-10~svn374877/tools/clang/lib/CodeGen/CGObjCMac.cpp

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