Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name CGObjCMac.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/build-llvm -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/clang/include -I tools/clang/include -I include -I /build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-01-08-143526-16334-1 -x c++ /build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/clang/lib/CodeGen/CGObjCMac.cpp

/build/llvm-toolchain-snapshot-14~++20220108111521+9345ab3a4550/clang/lib/CodeGen/CGObjCMac.cpp

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