1 //===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This provides Objective-C code generation targeting the Apple runtime.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "CGBlocks.h"
15 #include "CGCleanup.h"
16 #include "CGObjCRuntime.h"
17 #include "CGRecordLayout.h"
18 #include "CodeGenFunction.h"
19 #include "CodeGenModule.h"
20 #include "clang/CodeGen/ConstantInitBuilder.h"
21 #include "clang/AST/ASTContext.h"
22 #include "clang/AST/Decl.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/AST/RecordLayout.h"
25 #include "clang/AST/StmtObjC.h"
26 #include "clang/Basic/LangOptions.h"
27 #include "clang/CodeGen/CGFunctionInfo.h"
28 #include "clang/Frontend/CodeGenOptions.h"
29 #include "llvm/ADT/CachedHashString.h"
30 #include "llvm/ADT/DenseSet.h"
31 #include "llvm/ADT/SetVector.h"
32 #include "llvm/ADT/SmallPtrSet.h"
33 #include "llvm/ADT/SmallString.h"
34 #include "llvm/IR/CallSite.h"
35 #include "llvm/IR/DataLayout.h"
36 #include "llvm/IR/InlineAsm.h"
37 #include "llvm/IR/IntrinsicInst.h"
38 #include "llvm/IR/LLVMContext.h"
39 #include "llvm/IR/Module.h"
40 #include "llvm/Support/raw_ostream.h"
41 #include <cstdio>
42
43 using namespace clang;
44 using namespace CodeGen;
45
46 namespace {
47
48 // FIXME: We should find a nicer way to make the labels for metadata, string
49 // concatenation is lame.
50
51 class ObjCCommonTypesHelper {
52 protected:
53 llvm::LLVMContext &VMContext;
54
55 private:
56 // The types of these functions don't really matter because we
57 // should always bitcast before calling them.
58
59 /// id objc_msgSend (id, SEL, ...)
60 ///
61 /// The default messenger, used for sends whose ABI is unchanged from
62 /// the all-integer/pointer case.
getMessageSendFn() const63 llvm::Constant *getMessageSendFn() const {
64 // Add the non-lazy-bind attribute, since objc_msgSend is likely to
65 // be called a lot.
66 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
67 return CGM.CreateRuntimeFunction(
68 llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend",
69 llvm::AttributeList::get(CGM.getLLVMContext(),
70 llvm::AttributeList::FunctionIndex,
71 llvm::Attribute::NonLazyBind));
72 }
73
74 /// void objc_msgSend_stret (id, SEL, ...)
75 ///
76 /// The messenger used when the return value is an aggregate returned
77 /// by indirect reference in the first argument, and therefore the
78 /// self and selector parameters are shifted over by one.
getMessageSendStretFn() const79 llvm::Constant *getMessageSendStretFn() const {
80 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
81 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
82 params, true),
83 "objc_msgSend_stret");
84
85 }
86
87 /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
88 ///
89 /// The messenger used when the return value is returned on the x87
90 /// floating-point stack; without a special entrypoint, the nil case
91 /// would be unbalanced.
getMessageSendFpretFn() const92 llvm::Constant *getMessageSendFpretFn() const {
93 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
94 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
95 params, true),
96 "objc_msgSend_fpret");
97
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.
getMessageSendFp2retFn() const105 llvm::Constant *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.
getMessageSendSuperFn() const121 llvm::Constant *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.
getMessageSendSuperFn2() const132 llvm::Constant *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.
getMessageSendSuperStretFn() const143 llvm::Constant *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.
getMessageSendSuperStretFn2() const154 llvm::Constant *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
getMessageSendSuperFpretFn() const161 llvm::Constant *getMessageSendSuperFpretFn() const {
162 // There is no objc_msgSendSuper_fpret? How can that work?
163 return getMessageSendSuperFn();
164 }
165
getMessageSendSuperFpretFn2() const166 llvm::Constant *getMessageSendSuperFpretFn2() const {
167 // There is no objc_msgSendSuper_fpret? How can that work?
168 return getMessageSendSuperFn2();
169 }
170
171 protected:
172 CodeGen::CodeGenModule &CGM;
173
174 public:
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
188 private:
189 /// ProtocolPtrTy - LLVM type for external protocol handles
190 /// (typeof(Protocol))
191 llvm::Type *ExternalProtocolPtrTy;
192
193 public:
getExternalProtocolPtrTy()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
getGetPropertyFn()235 llvm::Constant *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
getSetPropertyFn()250 llvm::Constant *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
getOptimizedSetPropertyFn(bool atomic,bool copy)269 llvm::Constant *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
getCopyStructFn()304 llvm::Constant *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));
getCppAtomicObjectFunction()324 llvm::Constant *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
getEnumerationMutationFn()338 llvm::Constant *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
getLookUpClassFn()350 llvm::Constant *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.
getGcReadWeakFn()365 llvm::Constant *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.
getGcAssignWeakFn()374 llvm::Constant *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.
getGcAssignGlobalFn()383 llvm::Constant *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.
getGcAssignThreadLocalFn()392 llvm::Constant *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.
getGcAssignIvarFn()401 llvm::Constant *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.
GcMemmoveCollectableFn()411 llvm::Constant *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.
getGcAssignStrongCastFn()419 llvm::Constant *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.
getExceptionThrowFn()428 llvm::Constant *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.
getExceptionRethrowFn()437 llvm::Constant *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.
getSyncEnterFn()444 llvm::Constant *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.
getSyncExitFn()453 llvm::Constant *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
getSendFn(bool IsSuper) const461 llvm::Constant *getSendFn(bool IsSuper) const {
462 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
463 }
464
getSendFn2(bool IsSuper) const465 llvm::Constant *getSendFn2(bool IsSuper) const {
466 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
467 }
468
getSendStretFn(bool IsSuper) const469 llvm::Constant *getSendStretFn(bool IsSuper) const {
470 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
471 }
472
getSendStretFn2(bool IsSuper) const473 llvm::Constant *getSendStretFn2(bool IsSuper) const {
474 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
475 }
476
getSendFpretFn(bool IsSuper) const477 llvm::Constant *getSendFpretFn(bool IsSuper) const {
478 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
479 }
480
getSendFpretFn2(bool IsSuper) const481 llvm::Constant *getSendFpretFn2(bool IsSuper) const {
482 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
483 }
484
getSendFp2retFn(bool IsSuper) const485 llvm::Constant *getSendFp2retFn(bool IsSuper) const {
486 return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
487 }
488
getSendFp2RetFn2(bool IsSuper) const489 llvm::Constant *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.
498 class ObjCTypesHelper : public ObjCCommonTypesHelper {
499 public:
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.
getExceptionTryEnterFn()555 llvm::Constant *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.
getExceptionTryExitFn()563 llvm::Constant *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.
getExceptionExtractFn()571 llvm::Constant *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.
getExceptionMatchFn()579 llvm::Constant *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.
getSetJmpFn()587 llvm::Constant *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
597 public:
598 ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
599 };
600
601 /// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
602 /// modern abi
603 class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
604 public:
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
getMessageSendFixupFn()673 llvm::Constant *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
getMessageSendFpretFixupFn()681 llvm::Constant *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
getMessageSendStretFixupFn()689 llvm::Constant *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
getMessageSendSuper2FixupFn()697 llvm::Constant *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
getMessageSendSuper2StretFixupFn()706 llvm::Constant *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
getObjCEndCatchFn()715 llvm::Constant *getObjCEndCatchFn() {
716 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
717 "objc_end_catch");
718
719 }
720
getObjCBeginCatchFn()721 llvm::Constant *getObjCBeginCatchFn() {
722 llvm::Type *params[] = { Int8PtrTy };
723 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
724 params, false),
725 "objc_begin_catch");
726 }
727
728 llvm::StructType *EHTypeTy;
729 llvm::Type *EHTypePtrTy;
730
731 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
732 };
733
734 enum class ObjCLabelType {
735 ClassName,
736 MethodVarName,
737 MethodVarType,
738 PropertyName,
739 };
740
741 class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
742 public:
743 class SKIP_SCAN {
744 public:
745 unsigned skip;
746 unsigned scan;
SKIP_SCAN(unsigned _skip=0,unsigned _scan=0)747 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
748 : skip(_skip), scan(_scan) {}
749 };
750
751 /// opcode for captured block variables layout 'instructions'.
752 /// In the following descriptions, 'I' is the value of the immediate field.
753 /// (field following the opcode).
754 ///
755 enum BLOCK_LAYOUT_OPCODE {
756 /// An operator which affects how the following layout should be
757 /// interpreted.
758 /// I == 0: Halt interpretation and treat everything else as
759 /// a non-pointer. Note that this instruction is equal
760 /// to '\0'.
761 /// I != 0: Currently unused.
762 BLOCK_LAYOUT_OPERATOR = 0,
763
764 /// The next I+1 bytes do not contain a value of object pointer type.
765 /// Note that this can leave the stream unaligned, meaning that
766 /// subsequent word-size instructions do not begin at a multiple of
767 /// the pointer size.
768 BLOCK_LAYOUT_NON_OBJECT_BYTES = 1,
769
770 /// The next I+1 words do not contain a value of object pointer type.
771 /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
772 /// when the required skip quantity is a multiple of the pointer size.
773 BLOCK_LAYOUT_NON_OBJECT_WORDS = 2,
774
775 /// The next I+1 words are __strong pointers to Objective-C
776 /// objects or blocks.
777 BLOCK_LAYOUT_STRONG = 3,
778
779 /// The next I+1 words are pointers to __block variables.
780 BLOCK_LAYOUT_BYREF = 4,
781
782 /// The next I+1 words are __weak pointers to Objective-C
783 /// objects or blocks.
784 BLOCK_LAYOUT_WEAK = 5,
785
786 /// The next I+1 words are __unsafe_unretained pointers to
787 /// Objective-C objects or blocks.
788 BLOCK_LAYOUT_UNRETAINED = 6
789
790 /// The next I+1 words are block or object pointers with some
791 /// as-yet-unspecified ownership semantics. If we add more
792 /// flavors of ownership semantics, values will be taken from
793 /// this range.
794 ///
795 /// This is included so that older tools can at least continue
796 /// processing the layout past such things.
797 //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
798
799 /// All other opcodes are reserved. Halt interpretation and
800 /// treat everything else as opaque.
801 };
802
803 class RUN_SKIP {
804 public:
805 enum BLOCK_LAYOUT_OPCODE opcode;
806 CharUnits block_var_bytepos;
807 CharUnits block_var_size;
RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode=BLOCK_LAYOUT_OPERATOR,CharUnits BytePos=CharUnits::Zero (),CharUnits Size=CharUnits::Zero ())808 RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
809 CharUnits BytePos = CharUnits::Zero(),
810 CharUnits Size = CharUnits::Zero())
811 : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {}
812
813 // Allow sorting based on byte pos.
operator <(const RUN_SKIP & b) const814 bool operator<(const RUN_SKIP &b) const {
815 return block_var_bytepos < b.block_var_bytepos;
816 }
817 };
818
819 protected:
820 llvm::LLVMContext &VMContext;
821 // FIXME! May not be needing this after all.
822 unsigned ObjCABI;
823
824 // arc/mrr layout of captured block literal variables.
825 SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
826
827 /// LazySymbols - Symbols to generate a lazy reference for. See
828 /// DefinedSymbols and FinishModule().
829 llvm::SetVector<IdentifierInfo*> LazySymbols;
830
831 /// DefinedSymbols - External symbols which are defined by this
832 /// module. The symbols in this list and LazySymbols are used to add
833 /// special linker symbols which ensure that Objective-C modules are
834 /// linked properly.
835 llvm::SetVector<IdentifierInfo*> DefinedSymbols;
836
837 /// ClassNames - uniqued class names.
838 llvm::StringMap<llvm::GlobalVariable*> ClassNames;
839
840 /// MethodVarNames - uniqued method variable names.
841 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
842
843 /// DefinedCategoryNames - list of category names in form Class_Category.
844 llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames;
845
846 /// MethodVarTypes - uniqued method type signatures. We have to use
847 /// a StringMap here because have no other unique reference.
848 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
849
850 /// MethodDefinitions - map of methods which have been defined in
851 /// this translation unit.
852 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
853
854 /// PropertyNames - uniqued method variable names.
855 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
856
857 /// ClassReferences - uniqued class references.
858 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
859
860 /// SelectorReferences - uniqued selector references.
861 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
862
863 /// Protocols - Protocols for which an objc_protocol structure has
864 /// been emitted. Forward declarations are handled by creating an
865 /// empty structure whose initializer is filled in when/if defined.
866 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
867
868 /// DefinedProtocols - Protocols which have actually been
869 /// defined. We should not need this, see FIXME in GenerateProtocol.
870 llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
871
872 /// DefinedClasses - List of defined classes.
873 SmallVector<llvm::GlobalValue*, 16> DefinedClasses;
874
875 /// ImplementedClasses - List of @implemented classes.
876 SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses;
877
878 /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
879 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
880
881 /// DefinedCategories - List of defined categories.
882 SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
883
884 /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
885 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
886
887 /// Cached reference to the class for constant strings. This value has type
888 /// int * but is actually an Obj-C class pointer.
889 llvm::WeakTrackingVH ConstantStringClassRef;
890
891 /// The LLVM type corresponding to NSConstantString.
892 llvm::StructType *NSConstantStringType = nullptr;
893
894 llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap;
895
896 /// GetNameForMethod - Return a name for the given method.
897 /// \param[out] NameOut - The return value.
898 void GetNameForMethod(const ObjCMethodDecl *OMD,
899 const ObjCContainerDecl *CD,
900 SmallVectorImpl<char> &NameOut);
901
902 /// GetMethodVarName - Return a unique constant for the given
903 /// selector's name. The return value has type char *.
904 llvm::Constant *GetMethodVarName(Selector Sel);
905 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
906
907 /// GetMethodVarType - Return a unique constant for the given
908 /// method's type encoding string. The return value has type char *.
909
910 // FIXME: This is a horrible name.
911 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
912 bool Extended = false);
913 llvm::Constant *GetMethodVarType(const FieldDecl *D);
914
915 /// GetPropertyName - Return a unique constant for the given
916 /// name. The return value has type char *.
917 llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
918
919 // FIXME: This can be dropped once string functions are unified.
920 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
921 const Decl *Container);
922
923 /// GetClassName - Return a unique constant for the given selector's
924 /// runtime name (which may change via use of objc_runtime_name attribute on
925 /// class or protocol definition. The return value has type char *.
926 llvm::Constant *GetClassName(StringRef RuntimeName);
927
928 llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
929
930 /// BuildIvarLayout - Builds ivar layout bitmap for the class
931 /// implementation for the __strong or __weak case.
932 ///
933 /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there
934 /// are any weak ivars defined directly in the class. Meaningless unless
935 /// building a weak layout. Does not guarantee that the layout will
936 /// actually have any entries, because the ivar might be under-aligned.
937 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
938 CharUnits beginOffset,
939 CharUnits endOffset,
940 bool forStrongLayout,
941 bool hasMRCWeakIvars);
942
BuildStrongIvarLayout(const ObjCImplementationDecl * OI,CharUnits beginOffset,CharUnits endOffset)943 llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,
944 CharUnits beginOffset,
945 CharUnits endOffset) {
946 return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
947 }
948
BuildWeakIvarLayout(const ObjCImplementationDecl * OI,CharUnits beginOffset,CharUnits endOffset,bool hasMRCWeakIvars)949 llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
950 CharUnits beginOffset,
951 CharUnits endOffset,
952 bool hasMRCWeakIvars) {
953 return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
954 }
955
956 Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
957
958 void UpdateRunSkipBlockVars(bool IsByref,
959 Qualifiers::ObjCLifetime LifeTime,
960 CharUnits FieldOffset,
961 CharUnits FieldSize);
962
963 void BuildRCBlockVarRecordLayout(const RecordType *RT,
964 CharUnits BytePos, bool &HasUnion,
965 bool ByrefLayout=false);
966
967 void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
968 const RecordDecl *RD,
969 ArrayRef<const FieldDecl*> RecFields,
970 CharUnits BytePos, bool &HasUnion,
971 bool ByrefLayout);
972
973 uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
974
975 llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
976
977 /// GetIvarLayoutName - Returns a unique constant for the given
978 /// ivar layout bitmap.
979 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
980 const ObjCCommonTypesHelper &ObjCTypes);
981
982 /// EmitPropertyList - Emit the given property list. The return
983 /// value has type PropertyListPtrTy.
984 llvm::Constant *EmitPropertyList(Twine Name,
985 const Decl *Container,
986 const ObjCContainerDecl *OCD,
987 const ObjCCommonTypesHelper &ObjCTypes,
988 bool IsClassProperty);
989
990 /// EmitProtocolMethodTypes - Generate the array of extended method type
991 /// strings. The return value has type Int8PtrPtrTy.
992 llvm::Constant *EmitProtocolMethodTypes(Twine Name,
993 ArrayRef<llvm::Constant*> MethodTypes,
994 const ObjCCommonTypesHelper &ObjCTypes);
995
996 /// GetProtocolRef - Return a reference to the internal protocol
997 /// description, creating an empty one if it has not been
998 /// defined. The return value has type ProtocolPtrTy.
999 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
1000
1001 /// Return a reference to the given Class using runtime calls rather than
1002 /// by a symbol reference.
1003 llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,
1004 const ObjCInterfaceDecl *ID,
1005 ObjCCommonTypesHelper &ObjCTypes);
1006
1007 std::string GetSectionName(StringRef Section, StringRef MachOAttributes);
1008
1009 public:
1010 /// CreateMetadataVar - Create a global variable with internal
1011 /// linkage for use by the Objective-C runtime.
1012 ///
1013 /// This is a convenience wrapper which not only creates the
1014 /// variable, but also sets the section and alignment and adds the
1015 /// global to the "llvm.used" list.
1016 ///
1017 /// \param Name - The variable name.
1018 /// \param Init - The variable initializer; this is also used to
1019 /// define the type of the variable.
1020 /// \param Section - The section the variable should go into, or empty.
1021 /// \param Align - The alignment for the variable, or 0.
1022 /// \param AddToUsed - Whether the variable should be added to
1023 /// "llvm.used".
1024 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1025 ConstantStructBuilder &Init,
1026 StringRef Section, CharUnits Align,
1027 bool AddToUsed);
1028 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1029 llvm::Constant *Init,
1030 StringRef Section, CharUnits Align,
1031 bool AddToUsed);
1032
1033 llvm::GlobalVariable *CreateCStringLiteral(StringRef Name,
1034 ObjCLabelType LabelType,
1035 bool ForceNonFragileABI = false,
1036 bool NullTerminate = true);
1037
1038 protected:
1039 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1040 ReturnValueSlot Return,
1041 QualType ResultType,
1042 llvm::Value *Sel,
1043 llvm::Value *Arg0,
1044 QualType Arg0Ty,
1045 bool IsSuper,
1046 const CallArgList &CallArgs,
1047 const ObjCMethodDecl *OMD,
1048 const ObjCInterfaceDecl *ClassReceiver,
1049 const ObjCCommonTypesHelper &ObjCTypes);
1050
1051 /// EmitImageInfo - Emit the image info marker used to encode some module
1052 /// level information.
1053 void EmitImageInfo();
1054
1055 public:
CGObjCCommonMac(CodeGen::CodeGenModule & cgm)1056 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) :
1057 CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) { }
1058
isNonFragileABI() const1059 bool isNonFragileABI() const {
1060 return ObjCABI == 2;
1061 }
1062
1063 ConstantAddress GenerateConstantString(const StringLiteral *SL) override;
1064 ConstantAddress GenerateConstantNSString(const StringLiteral *SL);
1065
1066 llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1067 const ObjCContainerDecl *CD=nullptr) override;
1068
1069 void GenerateProtocol(const ObjCProtocolDecl *PD) override;
1070
1071 /// GetOrEmitProtocol - Get the protocol object for the given
1072 /// declaration, emitting it if necessary. The return value has type
1073 /// ProtocolPtrTy.
1074 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
1075
1076 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1077 /// object for the given declaration, emitting it if needed. These
1078 /// forward references will be filled in with empty bodies if no
1079 /// definition is seen. The return value has type ProtocolPtrTy.
1080 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1081
1082 virtual llvm::Constant *getNSConstantStringClassRef() = 0;
1083
1084 llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1085 const CGBlockInfo &blockInfo) override;
1086 llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1087 const CGBlockInfo &blockInfo) override;
1088
1089 llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1090 QualType T) override;
1091 };
1092
1093 namespace {
1094
1095 enum class MethodListType {
1096 CategoryInstanceMethods,
1097 CategoryClassMethods,
1098 InstanceMethods,
1099 ClassMethods,
1100 ProtocolInstanceMethods,
1101 ProtocolClassMethods,
1102 OptionalProtocolInstanceMethods,
1103 OptionalProtocolClassMethods,
1104 };
1105
1106 /// A convenience class for splitting the methods of a protocol into
1107 /// the four interesting groups.
1108 class ProtocolMethodLists {
1109 public:
1110 enum Kind {
1111 RequiredInstanceMethods,
1112 RequiredClassMethods,
1113 OptionalInstanceMethods,
1114 OptionalClassMethods
1115 };
1116 enum {
1117 NumProtocolMethodLists = 4
1118 };
1119
getMethodListKind(Kind kind)1120 static MethodListType getMethodListKind(Kind kind) {
1121 switch (kind) {
1122 case RequiredInstanceMethods:
1123 return MethodListType::ProtocolInstanceMethods;
1124 case RequiredClassMethods:
1125 return MethodListType::ProtocolClassMethods;
1126 case OptionalInstanceMethods:
1127 return MethodListType::OptionalProtocolInstanceMethods;
1128 case OptionalClassMethods:
1129 return MethodListType::OptionalProtocolClassMethods;
1130 }
1131 llvm_unreachable("bad kind");
1132 }
1133
1134 SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists];
1135
get(const ObjCProtocolDecl * PD)1136 static ProtocolMethodLists get(const ObjCProtocolDecl *PD) {
1137 ProtocolMethodLists result;
1138
1139 for (auto MD : PD->methods()) {
1140 size_t index = (2 * size_t(MD->isOptional()))
1141 + (size_t(MD->isClassMethod()));
1142 result.Methods[index].push_back(MD);
1143 }
1144
1145 return result;
1146 }
1147
1148 template <class Self>
emitExtendedTypesArray(Self * self) const1149 SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const {
1150 // In both ABIs, the method types list is parallel with the
1151 // concatenation of the methods arrays in the following order:
1152 // instance methods
1153 // class methods
1154 // optional instance methods
1155 // optional class methods
1156 SmallVector<llvm::Constant*, 8> result;
1157
1158 // Methods is already in the correct order for both ABIs.
1159 for (auto &list : Methods) {
1160 for (auto MD : list) {
1161 result.push_back(self->GetMethodVarType(MD, true));
1162 }
1163 }
1164
1165 return result;
1166 }
1167
1168 template <class Self>
emitMethodList(Self * self,const ObjCProtocolDecl * PD,Kind kind) const1169 llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD,
1170 Kind kind) const {
1171 return self->emitMethodList(PD->getObjCRuntimeNameAsString(),
1172 getMethodListKind(kind), Methods[kind]);
1173 }
1174 };
1175
1176 } // end anonymous namespace
1177
1178 class CGObjCMac : public CGObjCCommonMac {
1179 private:
1180 friend ProtocolMethodLists;
1181
1182 ObjCTypesHelper ObjCTypes;
1183
1184 /// EmitModuleInfo - Another marker encoding module level
1185 /// information.
1186 void EmitModuleInfo();
1187
1188 /// EmitModuleSymols - Emit module symbols, the list of defined
1189 /// classes and categories. The result has type SymtabPtrTy.
1190 llvm::Constant *EmitModuleSymbols();
1191
1192 /// FinishModule - Write out global data structures at the end of
1193 /// processing a translation unit.
1194 void FinishModule();
1195
1196 /// EmitClassExtension - Generate the class extension structure used
1197 /// to store the weak ivar layout and properties. The return value
1198 /// has type ClassExtensionPtrTy.
1199 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID,
1200 CharUnits instanceSize,
1201 bool hasMRCWeakIvars,
1202 bool isMetaclass);
1203
1204 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1205 /// for the given class.
1206 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1207 const ObjCInterfaceDecl *ID);
1208
1209 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1210 IdentifierInfo *II);
1211
1212 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1213
1214 /// EmitSuperClassRef - Emits reference to class's main metadata class.
1215 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1216
1217 /// EmitIvarList - Emit the ivar list for the given
1218 /// implementation. If ForClass is true the list of class ivars
1219 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1220 /// interface ivars will be emitted. The return value has type
1221 /// IvarListPtrTy.
1222 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1223 bool ForClass);
1224
1225 /// EmitMetaClass - Emit a forward reference to the class structure
1226 /// for the metaclass of the given interface. The return value has
1227 /// type ClassPtrTy.
1228 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1229
1230 /// EmitMetaClass - Emit a class structure for the metaclass of the
1231 /// given implementation. The return value has type ClassPtrTy.
1232 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1233 llvm::Constant *Protocols,
1234 ArrayRef<const ObjCMethodDecl *> Methods);
1235
1236 void emitMethodConstant(ConstantArrayBuilder &builder,
1237 const ObjCMethodDecl *MD);
1238
1239 void emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
1240 const ObjCMethodDecl *MD);
1241
1242 /// EmitMethodList - Emit the method list for the given
1243 /// implementation. The return value has type MethodListPtrTy.
1244 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1245 ArrayRef<const ObjCMethodDecl *> Methods);
1246
1247 /// GetOrEmitProtocol - Get the protocol object for the given
1248 /// declaration, emitting it if necessary. The return value has type
1249 /// ProtocolPtrTy.
1250 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1251
1252 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1253 /// object for the given declaration, emitting it if needed. These
1254 /// forward references will be filled in with empty bodies if no
1255 /// definition is seen. The return value has type ProtocolPtrTy.
1256 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1257
1258 /// EmitProtocolExtension - Generate the protocol extension
1259 /// structure used to store optional instance and class methods, and
1260 /// protocol properties. The return value has type
1261 /// ProtocolExtensionPtrTy.
1262 llvm::Constant *
1263 EmitProtocolExtension(const ObjCProtocolDecl *PD,
1264 const ProtocolMethodLists &methodLists);
1265
1266 /// EmitProtocolList - Generate the list of referenced
1267 /// protocols. The return value has type ProtocolListPtrTy.
1268 llvm::Constant *EmitProtocolList(Twine Name,
1269 ObjCProtocolDecl::protocol_iterator begin,
1270 ObjCProtocolDecl::protocol_iterator end);
1271
1272 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1273 /// for the given selector.
1274 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1275 Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1276
1277 public:
1278 CGObjCMac(CodeGen::CodeGenModule &cgm);
1279
1280 llvm::Constant *getNSConstantStringClassRef() override;
1281
1282 llvm::Function *ModuleInitFunction() override;
1283
1284 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1285 ReturnValueSlot Return,
1286 QualType ResultType,
1287 Selector Sel, llvm::Value *Receiver,
1288 const CallArgList &CallArgs,
1289 const ObjCInterfaceDecl *Class,
1290 const ObjCMethodDecl *Method) override;
1291
1292 CodeGen::RValue
1293 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1294 ReturnValueSlot Return, QualType ResultType,
1295 Selector Sel, const ObjCInterfaceDecl *Class,
1296 bool isCategoryImpl, llvm::Value *Receiver,
1297 bool IsClassMessage, const CallArgList &CallArgs,
1298 const ObjCMethodDecl *Method) override;
1299
1300 llvm::Value *GetClass(CodeGenFunction &CGF,
1301 const ObjCInterfaceDecl *ID) override;
1302
1303 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
1304 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
1305
1306 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1307 /// untyped one.
1308 llvm::Value *GetSelector(CodeGenFunction &CGF,
1309 const ObjCMethodDecl *Method) override;
1310
1311 llvm::Constant *GetEHType(QualType T) override;
1312
1313 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1314
1315 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1316
RegisterAlias(const ObjCCompatibleAliasDecl * OAD)1317 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1318
1319 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1320 const ObjCProtocolDecl *PD) override;
1321
1322 llvm::Constant *GetPropertyGetFunction() override;
1323 llvm::Constant *GetPropertySetFunction() override;
1324 llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1325 bool copy) override;
1326 llvm::Constant *GetGetStructFunction() override;
1327 llvm::Constant *GetSetStructFunction() override;
1328 llvm::Constant *GetCppAtomicObjectGetFunction() override;
1329 llvm::Constant *GetCppAtomicObjectSetFunction() override;
1330 llvm::Constant *EnumerationMutationFunction() override;
1331
1332 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1333 const ObjCAtTryStmt &S) override;
1334 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1335 const ObjCAtSynchronizedStmt &S) override;
1336 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1337 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1338 bool ClearInsertionPoint=true) override;
1339 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1340 Address AddrWeakObj) override;
1341 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1342 llvm::Value *src, Address dst) override;
1343 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1344 llvm::Value *src, Address dest,
1345 bool threadlocal = false) override;
1346 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1347 llvm::Value *src, Address dest,
1348 llvm::Value *ivarOffset) override;
1349 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1350 llvm::Value *src, Address dest) override;
1351 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1352 Address dest, Address src,
1353 llvm::Value *size) override;
1354
1355 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1356 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1357 unsigned CVRQualifiers) override;
1358 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1359 const ObjCInterfaceDecl *Interface,
1360 const ObjCIvarDecl *Ivar) override;
1361 };
1362
1363 class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1364 private:
1365 friend ProtocolMethodLists;
1366 ObjCNonFragileABITypesHelper ObjCTypes;
1367 llvm::GlobalVariable* ObjCEmptyCacheVar;
1368 llvm::Constant* ObjCEmptyVtableVar;
1369
1370 /// SuperClassReferences - uniqued super class references.
1371 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1372
1373 /// MetaClassReferences - uniqued meta class references.
1374 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1375
1376 /// EHTypeReferences - uniqued class ehtype references.
1377 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1378
1379 /// VTableDispatchMethods - List of methods for which we generate
1380 /// vtable-based message dispatch.
1381 llvm::DenseSet<Selector> VTableDispatchMethods;
1382
1383 /// DefinedMetaClasses - List of defined meta-classes.
1384 std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1385
1386 /// isVTableDispatchedSelector - Returns true if SEL is a
1387 /// vtable-based selector.
1388 bool isVTableDispatchedSelector(Selector Sel);
1389
1390 /// FinishNonFragileABIModule - Write out global data structures at the end of
1391 /// processing a translation unit.
1392 void FinishNonFragileABIModule();
1393
1394 /// AddModuleClassList - Add the given list of class pointers to the
1395 /// module with the provided symbol and section names.
1396 void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container,
1397 StringRef SymbolName, StringRef SectionName);
1398
1399 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1400 unsigned InstanceStart,
1401 unsigned InstanceSize,
1402 const ObjCImplementationDecl *ID);
1403 llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI,
1404 bool isMetaclass,
1405 llvm::Constant *IsAGV,
1406 llvm::Constant *SuperClassGV,
1407 llvm::Constant *ClassRoGV,
1408 bool HiddenVisibility);
1409
1410 void emitMethodConstant(ConstantArrayBuilder &builder,
1411 const ObjCMethodDecl *MD,
1412 bool forProtocol);
1413
1414 /// Emit the method list for the given implementation. The return value
1415 /// has type MethodListnfABITy.
1416 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1417 ArrayRef<const ObjCMethodDecl *> Methods);
1418
1419 /// EmitIvarList - Emit the ivar list for the given
1420 /// implementation. If ForClass is true the list of class ivars
1421 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1422 /// interface ivars will be emitted. The return value has type
1423 /// IvarListnfABIPtrTy.
1424 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
1425
1426 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1427 const ObjCIvarDecl *Ivar,
1428 unsigned long int offset);
1429
1430 /// GetOrEmitProtocol - Get the protocol object for the given
1431 /// declaration, emitting it if necessary. The return value has type
1432 /// ProtocolPtrTy.
1433 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1434
1435 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1436 /// object for the given declaration, emitting it if needed. These
1437 /// forward references will be filled in with empty bodies if no
1438 /// definition is seen. The return value has type ProtocolPtrTy.
1439 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1440
1441 /// EmitProtocolList - Generate the list of referenced
1442 /// protocols. The return value has type ProtocolListPtrTy.
1443 llvm::Constant *EmitProtocolList(Twine Name,
1444 ObjCProtocolDecl::protocol_iterator begin,
1445 ObjCProtocolDecl::protocol_iterator end);
1446
1447 CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1448 ReturnValueSlot Return,
1449 QualType ResultType,
1450 Selector Sel,
1451 llvm::Value *Receiver,
1452 QualType Arg0Ty,
1453 bool IsSuper,
1454 const CallArgList &CallArgs,
1455 const ObjCMethodDecl *Method);
1456
1457 /// GetClassGlobal - Return the global variable for the Objective-C
1458 /// class of the given name.
1459 llvm::Constant *GetClassGlobal(StringRef Name,
1460 ForDefinition_t IsForDefinition,
1461 bool Weak = false, bool DLLImport = false);
1462 llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID,
1463 bool isMetaclass,
1464 ForDefinition_t isForDefinition);
1465
1466 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1467 /// for the given class reference.
1468 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1469 const ObjCInterfaceDecl *ID);
1470
1471 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1472 IdentifierInfo *II,
1473 const ObjCInterfaceDecl *ID);
1474
1475 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1476
1477 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1478 /// for the given super class reference.
1479 llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1480 const ObjCInterfaceDecl *ID);
1481
1482 /// EmitMetaClassRef - Return a Value * of the address of _class_t
1483 /// meta-data
1484 llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1485 const ObjCInterfaceDecl *ID, bool Weak);
1486
1487 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1488 /// the given ivar.
1489 ///
1490 llvm::GlobalVariable * ObjCIvarOffsetVariable(
1491 const ObjCInterfaceDecl *ID,
1492 const ObjCIvarDecl *Ivar);
1493
1494 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1495 /// for the given selector.
1496 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1497 Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1498
1499 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1500 /// interface. The return value has type EHTypePtrTy.
1501 llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1502 ForDefinition_t IsForDefinition);
1503
getMetaclassSymbolPrefix() const1504 StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }
1505
getClassSymbolPrefix() const1506 StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; }
1507
1508 void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1509 uint32_t &InstanceStart,
1510 uint32_t &InstanceSize);
1511
1512 // Shamelessly stolen from Analysis/CFRefCount.cpp
GetNullarySelector(const char * name) const1513 Selector GetNullarySelector(const char* name) const {
1514 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1515 return CGM.getContext().Selectors.getSelector(0, &II);
1516 }
1517
GetUnarySelector(const char * name) const1518 Selector GetUnarySelector(const char* name) const {
1519 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1520 return CGM.getContext().Selectors.getSelector(1, &II);
1521 }
1522
1523 /// ImplementationIsNonLazy - Check whether the given category or
1524 /// class implementation is "non-lazy".
1525 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1526
IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction & CGF,const ObjCIvarDecl * IV)1527 bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1528 const ObjCIvarDecl *IV) {
1529 // Annotate the load as an invariant load iff inside an instance method
1530 // and ivar belongs to instance method's class and one of its super class.
1531 // This check is needed because the ivar offset is a lazily
1532 // initialised value that may depend on objc_msgSend to perform a fixup on
1533 // the first message dispatch.
1534 //
1535 // An additional opportunity to mark the load as invariant arises when the
1536 // base of the ivar access is a parameter to an Objective C method.
1537 // However, because the parameters are not available in the current
1538 // interface, we cannot perform this check.
1539 if (const ObjCMethodDecl *MD =
1540 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1541 if (MD->isInstanceMethod())
1542 if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1543 return IV->getContainingInterface()->isSuperClassOf(ID);
1544 return false;
1545 }
1546
1547 public:
1548 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1549
1550 llvm::Constant *getNSConstantStringClassRef() override;
1551
1552 llvm::Function *ModuleInitFunction() override;
1553
1554 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1555 ReturnValueSlot Return,
1556 QualType ResultType, Selector Sel,
1557 llvm::Value *Receiver,
1558 const CallArgList &CallArgs,
1559 const ObjCInterfaceDecl *Class,
1560 const ObjCMethodDecl *Method) override;
1561
1562 CodeGen::RValue
1563 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1564 ReturnValueSlot Return, QualType ResultType,
1565 Selector Sel, const ObjCInterfaceDecl *Class,
1566 bool isCategoryImpl, llvm::Value *Receiver,
1567 bool IsClassMessage, const CallArgList &CallArgs,
1568 const ObjCMethodDecl *Method) override;
1569
1570 llvm::Value *GetClass(CodeGenFunction &CGF,
1571 const ObjCInterfaceDecl *ID) override;
1572
GetSelector(CodeGenFunction & CGF,Selector Sel)1573 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override
1574 { return EmitSelector(CGF, Sel); }
GetAddrOfSelector(CodeGenFunction & CGF,Selector Sel)1575 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
1576 { return EmitSelectorAddr(CGF, Sel); }
1577
1578 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1579 /// untyped one.
GetSelector(CodeGenFunction & CGF,const ObjCMethodDecl * Method)1580 llvm::Value *GetSelector(CodeGenFunction &CGF,
1581 const ObjCMethodDecl *Method) override
1582 { return EmitSelector(CGF, Method->getSelector()); }
1583
1584 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1585
1586 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1587
RegisterAlias(const ObjCCompatibleAliasDecl * OAD)1588 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1589
1590 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1591 const ObjCProtocolDecl *PD) override;
1592
1593 llvm::Constant *GetEHType(QualType T) override;
1594
GetPropertyGetFunction()1595 llvm::Constant *GetPropertyGetFunction() override {
1596 return ObjCTypes.getGetPropertyFn();
1597 }
GetPropertySetFunction()1598 llvm::Constant *GetPropertySetFunction() override {
1599 return ObjCTypes.getSetPropertyFn();
1600 }
1601
GetOptimizedPropertySetFunction(bool atomic,bool copy)1602 llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1603 bool copy) override {
1604 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1605 }
1606
GetSetStructFunction()1607 llvm::Constant *GetSetStructFunction() override {
1608 return ObjCTypes.getCopyStructFn();
1609 }
1610
GetGetStructFunction()1611 llvm::Constant *GetGetStructFunction() override {
1612 return ObjCTypes.getCopyStructFn();
1613 }
1614
GetCppAtomicObjectSetFunction()1615 llvm::Constant *GetCppAtomicObjectSetFunction() override {
1616 return ObjCTypes.getCppAtomicObjectFunction();
1617 }
1618
GetCppAtomicObjectGetFunction()1619 llvm::Constant *GetCppAtomicObjectGetFunction() override {
1620 return ObjCTypes.getCppAtomicObjectFunction();
1621 }
1622
EnumerationMutationFunction()1623 llvm::Constant *EnumerationMutationFunction() override {
1624 return ObjCTypes.getEnumerationMutationFn();
1625 }
1626
1627 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1628 const ObjCAtTryStmt &S) override;
1629 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1630 const ObjCAtSynchronizedStmt &S) override;
1631 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1632 bool ClearInsertionPoint=true) override;
1633 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1634 Address AddrWeakObj) override;
1635 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1636 llvm::Value *src, Address edst) override;
1637 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1638 llvm::Value *src, Address dest,
1639 bool threadlocal = false) override;
1640 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1641 llvm::Value *src, Address dest,
1642 llvm::Value *ivarOffset) override;
1643 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1644 llvm::Value *src, Address dest) override;
1645 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1646 Address dest, Address src,
1647 llvm::Value *size) override;
1648 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1649 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1650 unsigned CVRQualifiers) override;
1651 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1652 const ObjCInterfaceDecl *Interface,
1653 const ObjCIvarDecl *Ivar) override;
1654 };
1655
1656 /// A helper class for performing the null-initialization of a return
1657 /// value.
1658 struct NullReturnState {
1659 llvm::BasicBlock *NullBB;
NullReturnState__anon377f67430111::NullReturnState1660 NullReturnState() : NullBB(nullptr) {}
1661
1662 /// Perform a null-check of the given receiver.
init__anon377f67430111::NullReturnState1663 void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1664 // Make blocks for the null-receiver and call edges.
1665 NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1666 llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1667
1668 // Check for a null receiver and, if there is one, jump to the
1669 // null-receiver block. There's no point in trying to avoid it:
1670 // we're always going to put *something* there, because otherwise
1671 // we shouldn't have done this null-check in the first place.
1672 llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1673 CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1674
1675 // Otherwise, start performing the call.
1676 CGF.EmitBlock(callBB);
1677 }
1678
1679 /// Complete the null-return operation. It is valid to call this
1680 /// regardless of whether 'init' has been called.
complete__anon377f67430111::NullReturnState1681 RValue complete(CodeGenFunction &CGF,
1682 ReturnValueSlot returnSlot,
1683 RValue result,
1684 QualType resultType,
1685 const CallArgList &CallArgs,
1686 const ObjCMethodDecl *Method) {
1687 // If we never had to do a null-check, just use the raw result.
1688 if (!NullBB) return result;
1689
1690 // The continuation block. This will be left null if we don't have an
1691 // IP, which can happen if the method we're calling is marked noreturn.
1692 llvm::BasicBlock *contBB = nullptr;
1693
1694 // Finish the call path.
1695 llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1696 if (callBB) {
1697 contBB = CGF.createBasicBlock("msgSend.cont");
1698 CGF.Builder.CreateBr(contBB);
1699 }
1700
1701 // Okay, start emitting the null-receiver block.
1702 CGF.EmitBlock(NullBB);
1703
1704 // Release any consumed arguments we've got.
1705 if (Method) {
1706 CallArgList::const_iterator I = CallArgs.begin();
1707 for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
1708 e = Method->param_end(); i != e; ++i, ++I) {
1709 const ParmVarDecl *ParamDecl = (*i);
1710 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1711 RValue RV = I->getRValue(CGF);
1712 assert(RV.isScalar() &&
1713 "NullReturnState::complete - arg not on object");
1714 CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime);
1715 }
1716 }
1717 }
1718
1719 // The phi code below assumes that we haven't needed any control flow yet.
1720 assert(CGF.Builder.GetInsertBlock() == NullBB);
1721
1722 // If we've got a void return, just jump to the continuation block.
1723 if (result.isScalar() && resultType->isVoidType()) {
1724 // No jumps required if the message-send was noreturn.
1725 if (contBB) CGF.EmitBlock(contBB);
1726 return result;
1727 }
1728
1729 // If we've got a scalar return, build a phi.
1730 if (result.isScalar()) {
1731 // Derive the null-initialization value.
1732 llvm::Constant *null = CGF.CGM.EmitNullConstant(resultType);
1733
1734 // If no join is necessary, just flow out.
1735 if (!contBB) return RValue::get(null);
1736
1737 // Otherwise, build a phi.
1738 CGF.EmitBlock(contBB);
1739 llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1740 phi->addIncoming(result.getScalarVal(), callBB);
1741 phi->addIncoming(null, NullBB);
1742 return RValue::get(phi);
1743 }
1744
1745 // If we've got an aggregate return, null the buffer out.
1746 // FIXME: maybe we should be doing things differently for all the
1747 // cases where the ABI has us returning (1) non-agg values in
1748 // memory or (2) agg values in registers.
1749 if (result.isAggregate()) {
1750 assert(result.isAggregate() && "null init of non-aggregate result?");
1751 if (!returnSlot.isUnused())
1752 CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
1753 if (contBB) CGF.EmitBlock(contBB);
1754 return result;
1755 }
1756
1757 // Complex types.
1758 CGF.EmitBlock(contBB);
1759 CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1760
1761 // Find the scalar type and its zero value.
1762 llvm::Type *scalarTy = callResult.first->getType();
1763 llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1764
1765 // Build phis for both coordinates.
1766 llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1767 real->addIncoming(callResult.first, callBB);
1768 real->addIncoming(scalarZero, NullBB);
1769 llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1770 imag->addIncoming(callResult.second, callBB);
1771 imag->addIncoming(scalarZero, NullBB);
1772 return RValue::getComplex(real, imag);
1773 }
1774 };
1775
1776 } // end anonymous namespace
1777
1778 /* *** Helper Functions *** */
1779
1780 /// getConstantGEP() - Help routine to construct simple GEPs.
getConstantGEP(llvm::LLVMContext & VMContext,llvm::GlobalVariable * C,unsigned idx0,unsigned idx1)1781 static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1782 llvm::GlobalVariable *C, unsigned idx0,
1783 unsigned idx1) {
1784 llvm::Value *Idxs[] = {
1785 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1786 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1787 };
1788 return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1789 }
1790
1791 /// hasObjCExceptionAttribute - Return true if this class or any super
1792 /// class has the __objc_exception__ attribute.
hasObjCExceptionAttribute(ASTContext & Context,const ObjCInterfaceDecl * OID)1793 static bool hasObjCExceptionAttribute(ASTContext &Context,
1794 const ObjCInterfaceDecl *OID) {
1795 if (OID->hasAttr<ObjCExceptionAttr>())
1796 return true;
1797 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1798 return hasObjCExceptionAttribute(Context, Super);
1799 return false;
1800 }
1801
1802 /* *** CGObjCMac Public Interface *** */
1803
CGObjCMac(CodeGen::CodeGenModule & cgm)1804 CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1805 ObjCTypes(cgm) {
1806 ObjCABI = 1;
1807 EmitImageInfo();
1808 }
1809
1810 /// GetClass - Return a reference to the class for the given interface
1811 /// decl.
GetClass(CodeGenFunction & CGF,const ObjCInterfaceDecl * ID)1812 llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1813 const ObjCInterfaceDecl *ID) {
1814 return EmitClassRef(CGF, ID);
1815 }
1816
1817 /// GetSelector - Return the pointer to the unique'd string for this selector.
GetSelector(CodeGenFunction & CGF,Selector Sel)1818 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1819 return EmitSelector(CGF, Sel);
1820 }
GetAddrOfSelector(CodeGenFunction & CGF,Selector Sel)1821 Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1822 return EmitSelectorAddr(CGF, Sel);
1823 }
GetSelector(CodeGenFunction & CGF,const ObjCMethodDecl * Method)1824 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1825 *Method) {
1826 return EmitSelector(CGF, Method->getSelector());
1827 }
1828
GetEHType(QualType T)1829 llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1830 if (T->isObjCIdType() ||
1831 T->isObjCQualifiedIdType()) {
1832 return CGM.GetAddrOfRTTIDescriptor(
1833 CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1834 }
1835 if (T->isObjCClassType() ||
1836 T->isObjCQualifiedClassType()) {
1837 return CGM.GetAddrOfRTTIDescriptor(
1838 CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1839 }
1840 if (T->isObjCObjectPointerType())
1841 return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true);
1842
1843 llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1844 }
1845
1846 /// Generate a constant CFString object.
1847 /*
1848 struct __builtin_CFString {
1849 const int *isa; // point to __CFConstantStringClassReference
1850 int flags;
1851 const char *str;
1852 long length;
1853 };
1854 */
1855
1856 /// or Generate a constant NSString object.
1857 /*
1858 struct __builtin_NSString {
1859 const int *isa; // point to __NSConstantStringClassReference
1860 const char *str;
1861 unsigned int length;
1862 };
1863 */
1864
1865 ConstantAddress
GenerateConstantString(const StringLiteral * SL)1866 CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) {
1867 return (!CGM.getLangOpts().NoConstantCFStrings
1868 ? CGM.GetAddrOfConstantCFString(SL)
1869 : GenerateConstantNSString(SL));
1870 }
1871
1872 static llvm::StringMapEntry<llvm::GlobalVariable *> &
GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable * > & Map,const StringLiteral * Literal,unsigned & StringLength)1873 GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
1874 const StringLiteral *Literal, unsigned &StringLength) {
1875 StringRef String = Literal->getString();
1876 StringLength = String.size();
1877 return *Map.insert(std::make_pair(String, nullptr)).first;
1878 }
1879
getNSConstantStringClassRef()1880 llvm::Constant *CGObjCMac::getNSConstantStringClassRef() {
1881 if (llvm::Value *V = ConstantStringClassRef)
1882 return cast<llvm::Constant>(V);
1883
1884 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1885 std::string str =
1886 StringClass.empty() ? "_NSConstantStringClassReference"
1887 : "_" + StringClass + "ClassReference";
1888
1889 llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
1890 auto GV = CGM.CreateRuntimeVariable(PTy, str);
1891 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1892 ConstantStringClassRef = V;
1893 return V;
1894 }
1895
getNSConstantStringClassRef()1896 llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() {
1897 if (llvm::Value *V = ConstantStringClassRef)
1898 return cast<llvm::Constant>(V);
1899
1900 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1901 std::string str =
1902 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
1903 : "OBJC_CLASS_$_" + StringClass;
1904 auto GV = GetClassGlobal(str, NotForDefinition);
1905
1906 // Make sure the result is of the correct type.
1907 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1908
1909 ConstantStringClassRef = V;
1910 return V;
1911 }
1912
1913 ConstantAddress
GenerateConstantNSString(const StringLiteral * Literal)1914 CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) {
1915 unsigned StringLength = 0;
1916 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
1917 GetConstantStringEntry(NSConstantStringMap, Literal, StringLength);
1918
1919 if (auto *C = Entry.second)
1920 return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
1921
1922 // If we don't already have it, get _NSConstantStringClassReference.
1923 llvm::Constant *Class = getNSConstantStringClassRef();
1924
1925 // If we don't already have it, construct the type for a constant NSString.
1926 if (!NSConstantStringType) {
1927 NSConstantStringType =
1928 llvm::StructType::create({
1929 CGM.Int32Ty->getPointerTo(),
1930 CGM.Int8PtrTy,
1931 CGM.IntTy
1932 }, "struct.__builtin_NSString");
1933 }
1934
1935 ConstantInitBuilder Builder(CGM);
1936 auto Fields = Builder.beginStruct(NSConstantStringType);
1937
1938 // Class pointer.
1939 Fields.add(Class);
1940
1941 // String pointer.
1942 llvm::Constant *C =
1943 llvm::ConstantDataArray::getString(VMContext, Entry.first());
1944
1945 llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage;
1946 bool isConstant = !CGM.getLangOpts().WritableStrings;
1947
1948 auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant,
1949 Linkage, C, ".str");
1950 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1951 // Don't enforce the target's minimum global alignment, since the only use
1952 // of the string is via this class initializer.
1953 GV->setAlignment(1);
1954 Fields.addBitCast(GV, CGM.Int8PtrTy);
1955
1956 // String length.
1957 Fields.addInt(CGM.IntTy, StringLength);
1958
1959 // The struct.
1960 CharUnits Alignment = CGM.getPointerAlign();
1961 GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
1962 /*constant*/ true,
1963 llvm::GlobalVariable::PrivateLinkage);
1964 const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
1965 const char *NSStringNonFragileABISection =
1966 "__DATA,__objc_stringobj,regular,no_dead_strip";
1967 // FIXME. Fix section.
1968 GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
1969 ? NSStringNonFragileABISection
1970 : NSStringSection);
1971 Entry.second = GV;
1972
1973 return ConstantAddress(GV, Alignment);
1974 }
1975
1976 enum {
1977 kCFTaggedObjectID_Integer = (1 << 1) + 1
1978 };
1979
1980 /// Generates a message send where the super is the receiver. This is
1981 /// a message send to self with special delivery semantics indicating
1982 /// which class's method should be called.
1983 CodeGen::RValue
GenerateMessageSendSuper(CodeGen::CodeGenFunction & CGF,ReturnValueSlot Return,QualType ResultType,Selector Sel,const ObjCInterfaceDecl * Class,bool isCategoryImpl,llvm::Value * Receiver,bool IsClassMessage,const CodeGen::CallArgList & CallArgs,const ObjCMethodDecl * Method)1984 CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1985 ReturnValueSlot Return,
1986 QualType ResultType,
1987 Selector Sel,
1988 const ObjCInterfaceDecl *Class,
1989 bool isCategoryImpl,
1990 llvm::Value *Receiver,
1991 bool IsClassMessage,
1992 const CodeGen::CallArgList &CallArgs,
1993 const ObjCMethodDecl *Method) {
1994 // Create and init a super structure; this is a (receiver, class)
1995 // pair we will pass to objc_msgSendSuper.
1996 Address ObjCSuper =
1997 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
1998 "objc_super");
1999 llvm::Value *ReceiverAsObject =
2000 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
2001 CGF.Builder.CreateStore(
2002 ReceiverAsObject,
2003 CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
2004
2005 // If this is a class message the metaclass is passed as the target.
2006 llvm::Value *Target;
2007 if (IsClassMessage) {
2008 if (isCategoryImpl) {
2009 // Message sent to 'super' in a class method defined in a category
2010 // implementation requires an odd treatment.
2011 // If we are in a class method, we must retrieve the
2012 // _metaclass_ for the current class, pointed at by
2013 // the class's "isa" pointer. The following assumes that
2014 // isa" is the first ivar in a class (which it must be).
2015 Target = EmitClassRef(CGF, Class->getSuperClass());
2016 Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
2017 Target = CGF.Builder.CreateAlignedLoad(Target, CGF.getPointerAlign());
2018 } else {
2019 llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
2020 llvm::Value *SuperPtr =
2021 CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
2022 llvm::Value *Super =
2023 CGF.Builder.CreateAlignedLoad(SuperPtr, CGF.getPointerAlign());
2024 Target = Super;
2025 }
2026 } else if (isCategoryImpl)
2027 Target = EmitClassRef(CGF, Class->getSuperClass());
2028 else {
2029 llvm::Value *ClassPtr = EmitSuperClassRef(Class);
2030 ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
2031 Target = CGF.Builder.CreateAlignedLoad(ClassPtr, CGF.getPointerAlign());
2032 }
2033 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
2034 // ObjCTypes types.
2035 llvm::Type *ClassTy =
2036 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
2037 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
2038 CGF.Builder.CreateStore(Target,
2039 CGF.Builder.CreateStructGEP(ObjCSuper, 1, CGF.getPointerSize()));
2040 return EmitMessageSend(CGF, Return, ResultType,
2041 EmitSelector(CGF, Sel),
2042 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
2043 true, CallArgs, Method, Class, ObjCTypes);
2044 }
2045
2046 /// Generate code for a message send expression.
GenerateMessageSend(CodeGen::CodeGenFunction & CGF,ReturnValueSlot Return,QualType ResultType,Selector Sel,llvm::Value * Receiver,const CallArgList & CallArgs,const ObjCInterfaceDecl * Class,const ObjCMethodDecl * Method)2047 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
2048 ReturnValueSlot Return,
2049 QualType ResultType,
2050 Selector Sel,
2051 llvm::Value *Receiver,
2052 const CallArgList &CallArgs,
2053 const ObjCInterfaceDecl *Class,
2054 const ObjCMethodDecl *Method) {
2055 return EmitMessageSend(CGF, Return, ResultType,
2056 EmitSelector(CGF, Sel),
2057 Receiver, CGF.getContext().getObjCIdType(),
2058 false, CallArgs, Method, Class, ObjCTypes);
2059 }
2060
isWeakLinkedClass(const ObjCInterfaceDecl * ID)2061 static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
2062 do {
2063 if (ID->isWeakImported())
2064 return true;
2065 } while ((ID = ID->getSuperClass()));
2066
2067 return false;
2068 }
2069
2070 CodeGen::RValue
EmitMessageSend(CodeGen::CodeGenFunction & CGF,ReturnValueSlot Return,QualType ResultType,llvm::Value * Sel,llvm::Value * Arg0,QualType Arg0Ty,bool IsSuper,const CallArgList & CallArgs,const ObjCMethodDecl * Method,const ObjCInterfaceDecl * ClassReceiver,const ObjCCommonTypesHelper & ObjCTypes)2071 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
2072 ReturnValueSlot Return,
2073 QualType ResultType,
2074 llvm::Value *Sel,
2075 llvm::Value *Arg0,
2076 QualType Arg0Ty,
2077 bool IsSuper,
2078 const CallArgList &CallArgs,
2079 const ObjCMethodDecl *Method,
2080 const ObjCInterfaceDecl *ClassReceiver,
2081 const ObjCCommonTypesHelper &ObjCTypes) {
2082 CallArgList ActualArgs;
2083 if (!IsSuper)
2084 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
2085 ActualArgs.add(RValue::get(Arg0), Arg0Ty);
2086 ActualArgs.add(RValue::get(Sel), CGF.getContext().getObjCSelType());
2087 ActualArgs.addFrom(CallArgs);
2088
2089 // If we're calling a method, use the formal signature.
2090 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2091
2092 if (Method)
2093 assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==
2094 CGM.getContext().getCanonicalType(ResultType) &&
2095 "Result type mismatch!");
2096
2097 bool ReceiverCanBeNull = true;
2098
2099 // Super dispatch assumes that self is non-null; even the messenger
2100 // doesn't have a null check internally.
2101 if (IsSuper) {
2102 ReceiverCanBeNull = false;
2103
2104 // If this is a direct dispatch of a class method, check whether the class,
2105 // or anything in its hierarchy, was weak-linked.
2106 } else if (ClassReceiver && Method && Method->isClassMethod()) {
2107 ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);
2108
2109 // If we're emitting a method, and self is const (meaning just ARC, for now),
2110 // and the receiver is a load of self, then self is a valid object.
2111 } else if (auto CurMethod =
2112 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
2113 auto Self = CurMethod->getSelfDecl();
2114 if (Self->getType().isConstQualified()) {
2115 if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {
2116 llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer();
2117 if (SelfAddr == LI->getPointerOperand()) {
2118 ReceiverCanBeNull = false;
2119 }
2120 }
2121 }
2122 }
2123
2124 bool RequiresNullCheck = false;
2125
2126 llvm::Constant *Fn = nullptr;
2127 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
2128 if (ReceiverCanBeNull) RequiresNullCheck = true;
2129 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
2130 : ObjCTypes.getSendStretFn(IsSuper);
2131 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
2132 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
2133 : ObjCTypes.getSendFpretFn(IsSuper);
2134 } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
2135 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
2136 : ObjCTypes.getSendFp2retFn(IsSuper);
2137 } else {
2138 // arm64 uses objc_msgSend for stret methods and yet null receiver check
2139 // must be made for it.
2140 if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
2141 RequiresNullCheck = true;
2142 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
2143 : ObjCTypes.getSendFn(IsSuper);
2144 }
2145
2146 // We don't need to emit a null check to zero out an indirect result if the
2147 // result is ignored.
2148 if (Return.isUnused())
2149 RequiresNullCheck = false;
2150
2151 // Emit a null-check if there's a consumed argument other than the receiver.
2152 if (!RequiresNullCheck && CGM.getLangOpts().ObjCAutoRefCount && Method) {
2153 for (const auto *ParamDecl : Method->parameters()) {
2154 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
2155 RequiresNullCheck = true;
2156 break;
2157 }
2158 }
2159 }
2160
2161 NullReturnState nullReturn;
2162 if (RequiresNullCheck) {
2163 nullReturn.init(CGF, Arg0);
2164 }
2165
2166 llvm::Instruction *CallSite;
2167 Fn = llvm::ConstantExpr::getBitCast(Fn, MSI.MessengerType);
2168 CGCallee Callee = CGCallee::forDirect(Fn);
2169 RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
2170 &CallSite);
2171
2172 // Mark the call as noreturn if the method is marked noreturn and the
2173 // receiver cannot be null.
2174 if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) {
2175 llvm::CallSite(CallSite).setDoesNotReturn();
2176 }
2177
2178 return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs,
2179 RequiresNullCheck ? Method : nullptr);
2180 }
2181
GetGCAttrTypeForType(ASTContext & Ctx,QualType FQT,bool pointee=false)2182 static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT,
2183 bool pointee = false) {
2184 // Note that GC qualification applies recursively to C pointer types
2185 // that aren't otherwise decorated. This is weird, but it's probably
2186 // an intentional workaround to the unreliable placement of GC qualifiers.
2187 if (FQT.isObjCGCStrong())
2188 return Qualifiers::Strong;
2189
2190 if (FQT.isObjCGCWeak())
2191 return Qualifiers::Weak;
2192
2193 if (auto ownership = FQT.getObjCLifetime()) {
2194 // Ownership does not apply recursively to C pointer types.
2195 if (pointee) return Qualifiers::GCNone;
2196 switch (ownership) {
2197 case Qualifiers::OCL_Weak: return Qualifiers::Weak;
2198 case Qualifiers::OCL_Strong: return Qualifiers::Strong;
2199 case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone;
2200 case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?");
2201 case Qualifiers::OCL_None: llvm_unreachable("known nonzero");
2202 }
2203 llvm_unreachable("bad objc ownership");
2204 }
2205
2206 // Treat unqualified retainable pointers as strong.
2207 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2208 return Qualifiers::Strong;
2209
2210 // Walk into C pointer types, but only in GC.
2211 if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
2212 if (const PointerType *PT = FQT->getAs<PointerType>())
2213 return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
2214 }
2215
2216 return Qualifiers::GCNone;
2217 }
2218
2219 namespace {
2220 struct IvarInfo {
2221 CharUnits Offset;
2222 uint64_t SizeInWords;
IvarInfo__anon377f67430511::IvarInfo2223 IvarInfo(CharUnits offset, uint64_t sizeInWords)
2224 : Offset(offset), SizeInWords(sizeInWords) {}
2225
2226 // Allow sorting based on byte pos.
operator <__anon377f67430511::IvarInfo2227 bool operator<(const IvarInfo &other) const {
2228 return Offset < other.Offset;
2229 }
2230 };
2231
2232 /// A helper class for building GC layout strings.
2233 class IvarLayoutBuilder {
2234 CodeGenModule &CGM;
2235
2236 /// The start of the layout. Offsets will be relative to this value,
2237 /// and entries less than this value will be silently discarded.
2238 CharUnits InstanceBegin;
2239
2240 /// The end of the layout. Offsets will never exceed this value.
2241 CharUnits InstanceEnd;
2242
2243 /// Whether we're generating the strong layout or the weak layout.
2244 bool ForStrongLayout;
2245
2246 /// Whether the offsets in IvarsInfo might be out-of-order.
2247 bool IsDisordered = false;
2248
2249 llvm::SmallVector<IvarInfo, 8> IvarsInfo;
2250
2251 public:
IvarLayoutBuilder(CodeGenModule & CGM,CharUnits instanceBegin,CharUnits instanceEnd,bool forStrongLayout)2252 IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2253 CharUnits instanceEnd, bool forStrongLayout)
2254 : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
2255 ForStrongLayout(forStrongLayout) {
2256 }
2257
2258 void visitRecord(const RecordType *RT, CharUnits offset);
2259
2260 template <class Iterator, class GetOffsetFn>
2261 void visitAggregate(Iterator begin, Iterator end,
2262 CharUnits aggrOffset,
2263 const GetOffsetFn &getOffset);
2264
2265 void visitField(const FieldDecl *field, CharUnits offset);
2266
2267 /// Add the layout of a block implementation.
2268 void visitBlock(const CGBlockInfo &blockInfo);
2269
2270 /// Is there any information for an interesting bitmap?
hasBitmapData() const2271 bool hasBitmapData() const { return !IvarsInfo.empty(); }
2272
2273 llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
2274 llvm::SmallVectorImpl<unsigned char> &buffer);
2275
dump(ArrayRef<unsigned char> buffer)2276 static void dump(ArrayRef<unsigned char> buffer) {
2277 const unsigned char *s = buffer.data();
2278 for (unsigned i = 0, e = buffer.size(); i < e; i++)
2279 if (!(s[i] & 0xf0))
2280 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2281 else
2282 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
2283 printf("\n");
2284 }
2285 };
2286 } // end anonymous namespace
2287
BuildGCBlockLayout(CodeGenModule & CGM,const CGBlockInfo & blockInfo)2288 llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
2289 const CGBlockInfo &blockInfo) {
2290
2291 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2292 if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
2293 return nullPtr;
2294
2295 IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2296 /*for strong layout*/ true);
2297
2298 builder.visitBlock(blockInfo);
2299
2300 if (!builder.hasBitmapData())
2301 return nullPtr;
2302
2303 llvm::SmallVector<unsigned char, 32> buffer;
2304 llvm::Constant *C = builder.buildBitmap(*this, buffer);
2305 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
2306 printf("\n block variable layout for block: ");
2307 builder.dump(buffer);
2308 }
2309
2310 return C;
2311 }
2312
visitBlock(const CGBlockInfo & blockInfo)2313 void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
2314 // __isa is the first field in block descriptor and must assume by runtime's
2315 // convention that it is GC'able.
2316 IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2317
2318 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2319
2320 // Ignore the optional 'this' capture: C++ objects are not assumed
2321 // to be GC'ed.
2322
2323 CharUnits lastFieldOffset;
2324
2325 // Walk the captured variables.
2326 for (const auto &CI : blockDecl->captures()) {
2327 const VarDecl *variable = CI.getVariable();
2328 QualType type = variable->getType();
2329
2330 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2331
2332 // Ignore constant captures.
2333 if (capture.isConstant()) continue;
2334
2335 CharUnits fieldOffset = capture.getOffset();
2336
2337 // Block fields are not necessarily ordered; if we detect that we're
2338 // adding them out-of-order, make sure we sort later.
2339 if (fieldOffset < lastFieldOffset)
2340 IsDisordered = true;
2341 lastFieldOffset = fieldOffset;
2342
2343 // __block variables are passed by their descriptor address.
2344 if (CI.isByRef()) {
2345 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2346 continue;
2347 }
2348
2349 assert(!type->isArrayType() && "array variable should not be caught");
2350 if (const RecordType *record = type->getAs<RecordType>()) {
2351 visitRecord(record, fieldOffset);
2352 continue;
2353 }
2354
2355 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);
2356
2357 if (GCAttr == Qualifiers::Strong) {
2358 assert(CGM.getContext().getTypeSize(type)
2359 == CGM.getTarget().getPointerWidth(0));
2360 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2361 }
2362 }
2363 }
2364
2365 /// getBlockCaptureLifetime - This routine returns life time of the captured
2366 /// block variable for the purpose of block layout meta-data generation. FQT is
2367 /// the type of the variable captured in the block.
getBlockCaptureLifetime(QualType FQT,bool ByrefLayout)2368 Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2369 bool ByrefLayout) {
2370 // If it has an ownership qualifier, we're done.
2371 if (auto lifetime = FQT.getObjCLifetime())
2372 return lifetime;
2373
2374 // If it doesn't, and this is ARC, it has no ownership.
2375 if (CGM.getLangOpts().ObjCAutoRefCount)
2376 return Qualifiers::OCL_None;
2377
2378 // In MRC, retainable pointers are owned by non-__block variables.
2379 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2380 return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong;
2381
2382 return Qualifiers::OCL_None;
2383 }
2384
UpdateRunSkipBlockVars(bool IsByref,Qualifiers::ObjCLifetime LifeTime,CharUnits FieldOffset,CharUnits FieldSize)2385 void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2386 Qualifiers::ObjCLifetime LifeTime,
2387 CharUnits FieldOffset,
2388 CharUnits FieldSize) {
2389 // __block variables are passed by their descriptor address.
2390 if (IsByref)
2391 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2392 FieldSize));
2393 else if (LifeTime == Qualifiers::OCL_Strong)
2394 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2395 FieldSize));
2396 else if (LifeTime == Qualifiers::OCL_Weak)
2397 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2398 FieldSize));
2399 else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2400 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2401 FieldSize));
2402 else
2403 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2404 FieldOffset,
2405 FieldSize));
2406 }
2407
BuildRCRecordLayout(const llvm::StructLayout * RecLayout,const RecordDecl * RD,ArrayRef<const FieldDecl * > RecFields,CharUnits BytePos,bool & HasUnion,bool ByrefLayout)2408 void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2409 const RecordDecl *RD,
2410 ArrayRef<const FieldDecl*> RecFields,
2411 CharUnits BytePos, bool &HasUnion,
2412 bool ByrefLayout) {
2413 bool IsUnion = (RD && RD->isUnion());
2414 CharUnits MaxUnionSize = CharUnits::Zero();
2415 const FieldDecl *MaxField = nullptr;
2416 const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2417 CharUnits MaxFieldOffset = CharUnits::Zero();
2418 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2419
2420 if (RecFields.empty())
2421 return;
2422 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2423
2424 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
2425 const FieldDecl *Field = RecFields[i];
2426 // Note that 'i' here is actually the field index inside RD of Field,
2427 // although this dependency is hidden.
2428 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2429 CharUnits FieldOffset =
2430 CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i));
2431
2432 // Skip over unnamed or bitfields
2433 if (!Field->getIdentifier() || Field->isBitField()) {
2434 LastFieldBitfieldOrUnnamed = Field;
2435 LastBitfieldOrUnnamedOffset = FieldOffset;
2436 continue;
2437 }
2438
2439 LastFieldBitfieldOrUnnamed = nullptr;
2440 QualType FQT = Field->getType();
2441 if (FQT->isRecordType() || FQT->isUnionType()) {
2442 if (FQT->isUnionType())
2443 HasUnion = true;
2444
2445 BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
2446 BytePos + FieldOffset, HasUnion);
2447 continue;
2448 }
2449
2450 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2451 const ConstantArrayType *CArray =
2452 dyn_cast_or_null<ConstantArrayType>(Array);
2453 uint64_t ElCount = CArray->getSize().getZExtValue();
2454 assert(CArray && "only array with known element size is supported");
2455 FQT = CArray->getElementType();
2456 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2457 const ConstantArrayType *CArray =
2458 dyn_cast_or_null<ConstantArrayType>(Array);
2459 ElCount *= CArray->getSize().getZExtValue();
2460 FQT = CArray->getElementType();
2461 }
2462 if (FQT->isRecordType() && ElCount) {
2463 int OldIndex = RunSkipBlockVars.size() - 1;
2464 const RecordType *RT = FQT->getAs<RecordType>();
2465 BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset,
2466 HasUnion);
2467
2468 // Replicate layout information for each array element. Note that
2469 // one element is already done.
2470 uint64_t ElIx = 1;
2471 for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2472 CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2473 for (int i = OldIndex+1; i <= FirstIndex; ++i)
2474 RunSkipBlockVars.push_back(
2475 RUN_SKIP(RunSkipBlockVars[i].opcode,
2476 RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2477 RunSkipBlockVars[i].block_var_size));
2478 }
2479 continue;
2480 }
2481 }
2482 CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2483 if (IsUnion) {
2484 CharUnits UnionIvarSize = FieldSize;
2485 if (UnionIvarSize > MaxUnionSize) {
2486 MaxUnionSize = UnionIvarSize;
2487 MaxField = Field;
2488 MaxFieldOffset = FieldOffset;
2489 }
2490 } else {
2491 UpdateRunSkipBlockVars(false,
2492 getBlockCaptureLifetime(FQT, ByrefLayout),
2493 BytePos + FieldOffset,
2494 FieldSize);
2495 }
2496 }
2497
2498 if (LastFieldBitfieldOrUnnamed) {
2499 if (LastFieldBitfieldOrUnnamed->isBitField()) {
2500 // Last field was a bitfield. Must update the info.
2501 uint64_t BitFieldSize
2502 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2503 unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2504 ((BitFieldSize % ByteSizeInBits) != 0);
2505 CharUnits Size = CharUnits::fromQuantity(UnsSize);
2506 Size += LastBitfieldOrUnnamedOffset;
2507 UpdateRunSkipBlockVars(false,
2508 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2509 ByrefLayout),
2510 BytePos + LastBitfieldOrUnnamedOffset,
2511 Size);
2512 } else {
2513 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2514 // Last field was unnamed. Must update skip info.
2515 CharUnits FieldSize
2516 = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2517 UpdateRunSkipBlockVars(false,
2518 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2519 ByrefLayout),
2520 BytePos + LastBitfieldOrUnnamedOffset,
2521 FieldSize);
2522 }
2523 }
2524
2525 if (MaxField)
2526 UpdateRunSkipBlockVars(false,
2527 getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2528 BytePos + MaxFieldOffset,
2529 MaxUnionSize);
2530 }
2531
BuildRCBlockVarRecordLayout(const RecordType * RT,CharUnits BytePos,bool & HasUnion,bool ByrefLayout)2532 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2533 CharUnits BytePos,
2534 bool &HasUnion,
2535 bool ByrefLayout) {
2536 const RecordDecl *RD = RT->getDecl();
2537 SmallVector<const FieldDecl*, 16> Fields(RD->fields());
2538 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2539 const llvm::StructLayout *RecLayout =
2540 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2541
2542 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2543 }
2544
2545 /// InlineLayoutInstruction - This routine produce an inline instruction for the
2546 /// block variable layout if it can. If not, it returns 0. Rules are as follow:
2547 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2548 /// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2549 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2550 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2551 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2552 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2553 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
InlineLayoutInstruction(SmallVectorImpl<unsigned char> & Layout)2554 uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2555 SmallVectorImpl<unsigned char> &Layout) {
2556 uint64_t Result = 0;
2557 if (Layout.size() <= 3) {
2558 unsigned size = Layout.size();
2559 unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2560 unsigned char inst;
2561 enum BLOCK_LAYOUT_OPCODE opcode ;
2562 switch (size) {
2563 case 3:
2564 inst = Layout[0];
2565 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2566 if (opcode == BLOCK_LAYOUT_STRONG)
2567 strong_word_count = (inst & 0xF)+1;
2568 else
2569 return 0;
2570 inst = Layout[1];
2571 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2572 if (opcode == BLOCK_LAYOUT_BYREF)
2573 byref_word_count = (inst & 0xF)+1;
2574 else
2575 return 0;
2576 inst = Layout[2];
2577 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2578 if (opcode == BLOCK_LAYOUT_WEAK)
2579 weak_word_count = (inst & 0xF)+1;
2580 else
2581 return 0;
2582 break;
2583
2584 case 2:
2585 inst = Layout[0];
2586 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2587 if (opcode == BLOCK_LAYOUT_STRONG) {
2588 strong_word_count = (inst & 0xF)+1;
2589 inst = Layout[1];
2590 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2591 if (opcode == BLOCK_LAYOUT_BYREF)
2592 byref_word_count = (inst & 0xF)+1;
2593 else if (opcode == BLOCK_LAYOUT_WEAK)
2594 weak_word_count = (inst & 0xF)+1;
2595 else
2596 return 0;
2597 }
2598 else if (opcode == BLOCK_LAYOUT_BYREF) {
2599 byref_word_count = (inst & 0xF)+1;
2600 inst = Layout[1];
2601 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2602 if (opcode == BLOCK_LAYOUT_WEAK)
2603 weak_word_count = (inst & 0xF)+1;
2604 else
2605 return 0;
2606 }
2607 else
2608 return 0;
2609 break;
2610
2611 case 1:
2612 inst = Layout[0];
2613 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2614 if (opcode == BLOCK_LAYOUT_STRONG)
2615 strong_word_count = (inst & 0xF)+1;
2616 else if (opcode == BLOCK_LAYOUT_BYREF)
2617 byref_word_count = (inst & 0xF)+1;
2618 else if (opcode == BLOCK_LAYOUT_WEAK)
2619 weak_word_count = (inst & 0xF)+1;
2620 else
2621 return 0;
2622 break;
2623
2624 default:
2625 return 0;
2626 }
2627
2628 // Cannot inline when any of the word counts is 15. Because this is one less
2629 // than the actual work count (so 15 means 16 actual word counts),
2630 // and we can only display 0 thru 15 word counts.
2631 if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2632 return 0;
2633
2634 unsigned count =
2635 (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2636
2637 if (size == count) {
2638 if (strong_word_count)
2639 Result = strong_word_count;
2640 Result <<= 4;
2641 if (byref_word_count)
2642 Result += byref_word_count;
2643 Result <<= 4;
2644 if (weak_word_count)
2645 Result += weak_word_count;
2646 }
2647 }
2648 return Result;
2649 }
2650
getBitmapBlockLayout(bool ComputeByrefLayout)2651 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2652 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2653 if (RunSkipBlockVars.empty())
2654 return nullPtr;
2655 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2656 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2657 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2658
2659 // Sort on byte position; captures might not be allocated in order,
2660 // and unions can do funny things.
2661 llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2662 SmallVector<unsigned char, 16> Layout;
2663
2664 unsigned size = RunSkipBlockVars.size();
2665 for (unsigned i = 0; i < size; i++) {
2666 enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2667 CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2668 CharUnits end_byte_pos = start_byte_pos;
2669 unsigned j = i+1;
2670 while (j < size) {
2671 if (opcode == RunSkipBlockVars[j].opcode) {
2672 end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2673 i++;
2674 }
2675 else
2676 break;
2677 }
2678 CharUnits size_in_bytes =
2679 end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2680 if (j < size) {
2681 CharUnits gap =
2682 RunSkipBlockVars[j].block_var_bytepos -
2683 RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2684 size_in_bytes += gap;
2685 }
2686 CharUnits residue_in_bytes = CharUnits::Zero();
2687 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2688 residue_in_bytes = size_in_bytes % WordSizeInBytes;
2689 size_in_bytes -= residue_in_bytes;
2690 opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2691 }
2692
2693 unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2694 while (size_in_words >= 16) {
2695 // Note that value in imm. is one less that the actual
2696 // value. So, 0xf means 16 words follow!
2697 unsigned char inst = (opcode << 4) | 0xf;
2698 Layout.push_back(inst);
2699 size_in_words -= 16;
2700 }
2701 if (size_in_words > 0) {
2702 // Note that value in imm. is one less that the actual
2703 // value. So, we subtract 1 away!
2704 unsigned char inst = (opcode << 4) | (size_in_words-1);
2705 Layout.push_back(inst);
2706 }
2707 if (residue_in_bytes > CharUnits::Zero()) {
2708 unsigned char inst =
2709 (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2710 Layout.push_back(inst);
2711 }
2712 }
2713
2714 while (!Layout.empty()) {
2715 unsigned char inst = Layout.back();
2716 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2717 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2718 Layout.pop_back();
2719 else
2720 break;
2721 }
2722
2723 uint64_t Result = InlineLayoutInstruction(Layout);
2724 if (Result != 0) {
2725 // Block variable layout instruction has been inlined.
2726 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2727 if (ComputeByrefLayout)
2728 printf("\n Inline BYREF variable layout: ");
2729 else
2730 printf("\n Inline block variable layout: ");
2731 printf("0x0%" PRIx64 "", Result);
2732 if (auto numStrong = (Result & 0xF00) >> 8)
2733 printf(", BL_STRONG:%d", (int) numStrong);
2734 if (auto numByref = (Result & 0x0F0) >> 4)
2735 printf(", BL_BYREF:%d", (int) numByref);
2736 if (auto numWeak = (Result & 0x00F) >> 0)
2737 printf(", BL_WEAK:%d", (int) numWeak);
2738 printf(", BL_OPERATOR:0\n");
2739 }
2740 return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2741 }
2742
2743 unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2744 Layout.push_back(inst);
2745 std::string BitMap;
2746 for (unsigned i = 0, e = Layout.size(); i != e; i++)
2747 BitMap += Layout[i];
2748
2749 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2750 if (ComputeByrefLayout)
2751 printf("\n Byref variable layout: ");
2752 else
2753 printf("\n Block variable layout: ");
2754 for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2755 unsigned char inst = BitMap[i];
2756 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2757 unsigned delta = 1;
2758 switch (opcode) {
2759 case BLOCK_LAYOUT_OPERATOR:
2760 printf("BL_OPERATOR:");
2761 delta = 0;
2762 break;
2763 case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2764 printf("BL_NON_OBJECT_BYTES:");
2765 break;
2766 case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2767 printf("BL_NON_OBJECT_WORD:");
2768 break;
2769 case BLOCK_LAYOUT_STRONG:
2770 printf("BL_STRONG:");
2771 break;
2772 case BLOCK_LAYOUT_BYREF:
2773 printf("BL_BYREF:");
2774 break;
2775 case BLOCK_LAYOUT_WEAK:
2776 printf("BL_WEAK:");
2777 break;
2778 case BLOCK_LAYOUT_UNRETAINED:
2779 printf("BL_UNRETAINED:");
2780 break;
2781 }
2782 // Actual value of word count is one more that what is in the imm.
2783 // field of the instruction
2784 printf("%d", (inst & 0xf) + delta);
2785 if (i < e-1)
2786 printf(", ");
2787 else
2788 printf("\n");
2789 }
2790 }
2791
2792 auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
2793 /*ForceNonFragileABI=*/true,
2794 /*NullTerminate=*/false);
2795 return getConstantGEP(VMContext, Entry, 0, 0);
2796 }
2797
BuildRCBlockLayout(CodeGenModule & CGM,const CGBlockInfo & blockInfo)2798 llvm::Constant *CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2799 const CGBlockInfo &blockInfo) {
2800 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2801
2802 RunSkipBlockVars.clear();
2803 bool hasUnion = false;
2804
2805 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2806 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2807 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2808
2809 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2810
2811 // Calculate the basic layout of the block structure.
2812 const llvm::StructLayout *layout =
2813 CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2814
2815 // Ignore the optional 'this' capture: C++ objects are not assumed
2816 // to be GC'ed.
2817 if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2818 UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2819 blockInfo.BlockHeaderForcedGapOffset,
2820 blockInfo.BlockHeaderForcedGapSize);
2821 // Walk the captured variables.
2822 for (const auto &CI : blockDecl->captures()) {
2823 const VarDecl *variable = CI.getVariable();
2824 QualType type = variable->getType();
2825
2826 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2827
2828 // Ignore constant captures.
2829 if (capture.isConstant()) continue;
2830
2831 CharUnits fieldOffset =
2832 CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2833
2834 assert(!type->isArrayType() && "array variable should not be caught");
2835 if (!CI.isByRef())
2836 if (const RecordType *record = type->getAs<RecordType>()) {
2837 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2838 continue;
2839 }
2840 CharUnits fieldSize;
2841 if (CI.isByRef())
2842 fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2843 else
2844 fieldSize = CGM.getContext().getTypeSizeInChars(type);
2845 UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2846 fieldOffset, fieldSize);
2847 }
2848 return getBitmapBlockLayout(false);
2849 }
2850
BuildByrefLayout(CodeGen::CodeGenModule & CGM,QualType T)2851 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
2852 QualType T) {
2853 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2854 assert(!T->isArrayType() && "__block array variable should not be caught");
2855 CharUnits fieldOffset;
2856 RunSkipBlockVars.clear();
2857 bool hasUnion = false;
2858 if (const RecordType *record = T->getAs<RecordType>()) {
2859 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
2860 llvm::Constant *Result = getBitmapBlockLayout(true);
2861 if (isa<llvm::ConstantInt>(Result))
2862 Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
2863 return Result;
2864 }
2865 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2866 return nullPtr;
2867 }
2868
GenerateProtocolRef(CodeGenFunction & CGF,const ObjCProtocolDecl * PD)2869 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
2870 const ObjCProtocolDecl *PD) {
2871 // FIXME: I don't understand why gcc generates this, or where it is
2872 // resolved. Investigate. Its also wasteful to look this up over and over.
2873 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2874
2875 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
2876 ObjCTypes.getExternalProtocolPtrTy());
2877 }
2878
GenerateProtocol(const ObjCProtocolDecl * PD)2879 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
2880 // FIXME: We shouldn't need this, the protocol decl should contain enough
2881 // information to tell us whether this was a declaration or a definition.
2882 DefinedProtocols.insert(PD->getIdentifier());
2883
2884 // If we have generated a forward reference to this protocol, emit
2885 // it now. Otherwise do nothing, the protocol objects are lazily
2886 // emitted.
2887 if (Protocols.count(PD->getIdentifier()))
2888 GetOrEmitProtocol(PD);
2889 }
2890
GetProtocolRef(const ObjCProtocolDecl * PD)2891 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
2892 if (DefinedProtocols.count(PD->getIdentifier()))
2893 return GetOrEmitProtocol(PD);
2894
2895 return GetOrEmitProtocolRef(PD);
2896 }
2897
EmitClassRefViaRuntime(CodeGenFunction & CGF,const ObjCInterfaceDecl * ID,ObjCCommonTypesHelper & ObjCTypes)2898 llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
2899 CodeGenFunction &CGF,
2900 const ObjCInterfaceDecl *ID,
2901 ObjCCommonTypesHelper &ObjCTypes) {
2902 llvm::Constant *lookUpClassFn = ObjCTypes.getLookUpClassFn();
2903
2904 llvm::Value *className =
2905 CGF.CGM.GetAddrOfConstantCString(ID->getObjCRuntimeNameAsString())
2906 .getPointer();
2907 ASTContext &ctx = CGF.CGM.getContext();
2908 className =
2909 CGF.Builder.CreateBitCast(className,
2910 CGF.ConvertType(
2911 ctx.getPointerType(ctx.CharTy.withConst())));
2912 llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
2913 call->setDoesNotThrow();
2914 return call;
2915 }
2916
2917 /*
2918 // Objective-C 1.0 extensions
2919 struct _objc_protocol {
2920 struct _objc_protocol_extension *isa;
2921 char *protocol_name;
2922 struct _objc_protocol_list *protocol_list;
2923 struct _objc__method_prototype_list *instance_methods;
2924 struct _objc__method_prototype_list *class_methods
2925 };
2926
2927 See EmitProtocolExtension().
2928 */
GetOrEmitProtocol(const ObjCProtocolDecl * PD)2929 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
2930 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
2931
2932 // Early exit if a defining object has already been generated.
2933 if (Entry && Entry->hasInitializer())
2934 return Entry;
2935
2936 // Use the protocol definition, if there is one.
2937 if (const ObjCProtocolDecl *Def = PD->getDefinition())
2938 PD = Def;
2939
2940 // FIXME: I don't understand why gcc generates this, or where it is
2941 // resolved. Investigate. Its also wasteful to look this up over and over.
2942 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2943
2944 // Construct method lists.
2945 auto methodLists = ProtocolMethodLists::get(PD);
2946
2947 ConstantInitBuilder builder(CGM);
2948 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
2949 values.add(EmitProtocolExtension(PD, methodLists));
2950 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
2951 values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
2952 PD->protocol_begin(), PD->protocol_end()));
2953 values.add(methodLists.emitMethodList(this, PD,
2954 ProtocolMethodLists::RequiredInstanceMethods));
2955 values.add(methodLists.emitMethodList(this, PD,
2956 ProtocolMethodLists::RequiredClassMethods));
2957
2958 if (Entry) {
2959 // Already created, update the initializer.
2960 assert(Entry->hasPrivateLinkage());
2961 values.finishAndSetAsInitializer(Entry);
2962 } else {
2963 Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
2964 CGM.getPointerAlign(),
2965 /*constant*/ false,
2966 llvm::GlobalValue::PrivateLinkage);
2967 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
2968
2969 Protocols[PD->getIdentifier()] = Entry;
2970 }
2971 CGM.addCompilerUsedGlobal(Entry);
2972
2973 return Entry;
2974 }
2975
GetOrEmitProtocolRef(const ObjCProtocolDecl * PD)2976 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
2977 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
2978
2979 if (!Entry) {
2980 // We use the initializer as a marker of whether this is a forward
2981 // reference or not. At module finalization we add the empty
2982 // contents for protocols which were referenced but never defined.
2983 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
2984 false, llvm::GlobalValue::PrivateLinkage,
2985 nullptr, "OBJC_PROTOCOL_" + PD->getName());
2986 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
2987 // FIXME: Is this necessary? Why only for protocol?
2988 Entry->setAlignment(4);
2989 }
2990
2991 return Entry;
2992 }
2993
2994 /*
2995 struct _objc_protocol_extension {
2996 uint32_t size;
2997 struct objc_method_description_list *optional_instance_methods;
2998 struct objc_method_description_list *optional_class_methods;
2999 struct objc_property_list *instance_properties;
3000 const char ** extendedMethodTypes;
3001 struct objc_property_list *class_properties;
3002 };
3003 */
3004 llvm::Constant *
EmitProtocolExtension(const ObjCProtocolDecl * PD,const ProtocolMethodLists & methodLists)3005 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
3006 const ProtocolMethodLists &methodLists) {
3007 auto optInstanceMethods =
3008 methodLists.emitMethodList(this, PD,
3009 ProtocolMethodLists::OptionalInstanceMethods);
3010 auto optClassMethods =
3011 methodLists.emitMethodList(this, PD,
3012 ProtocolMethodLists::OptionalClassMethods);
3013
3014 auto extendedMethodTypes =
3015 EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3016 methodLists.emitExtendedTypesArray(this),
3017 ObjCTypes);
3018
3019 auto instanceProperties =
3020 EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3021 ObjCTypes, false);
3022 auto classProperties =
3023 EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3024 PD, ObjCTypes, true);
3025
3026 // Return null if no extension bits are used.
3027 if (optInstanceMethods->isNullValue() &&
3028 optClassMethods->isNullValue() &&
3029 extendedMethodTypes->isNullValue() &&
3030 instanceProperties->isNullValue() &&
3031 classProperties->isNullValue()) {
3032 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3033 }
3034
3035 uint64_t size =
3036 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3037
3038 ConstantInitBuilder builder(CGM);
3039 auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3040 values.addInt(ObjCTypes.IntTy, size);
3041 values.add(optInstanceMethods);
3042 values.add(optClassMethods);
3043 values.add(instanceProperties);
3044 values.add(extendedMethodTypes);
3045 values.add(classProperties);
3046
3047 // No special section, but goes in llvm.used
3048 return CreateMetadataVar("\01l_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3049 StringRef(), CGM.getPointerAlign(), true);
3050 }
3051
3052 /*
3053 struct objc_protocol_list {
3054 struct objc_protocol_list *next;
3055 long count;
3056 Protocol *list[];
3057 };
3058 */
3059 llvm::Constant *
EmitProtocolList(Twine name,ObjCProtocolDecl::protocol_iterator begin,ObjCProtocolDecl::protocol_iterator end)3060 CGObjCMac::EmitProtocolList(Twine name,
3061 ObjCProtocolDecl::protocol_iterator begin,
3062 ObjCProtocolDecl::protocol_iterator end) {
3063 // Just return null for empty protocol lists
3064 if (begin == end)
3065 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3066
3067 ConstantInitBuilder builder(CGM);
3068 auto values = builder.beginStruct();
3069
3070 // This field is only used by the runtime.
3071 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3072
3073 // Reserve a slot for the count.
3074 auto countSlot = values.addPlaceholder();
3075
3076 auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3077 for (; begin != end; ++begin) {
3078 refsArray.add(GetProtocolRef(*begin));
3079 }
3080 auto count = refsArray.size();
3081
3082 // This list is null terminated.
3083 refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3084
3085 refsArray.finishAndAddTo(values);
3086 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3087
3088 StringRef section;
3089 if (CGM.getTriple().isOSBinFormatMachO())
3090 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3091
3092 llvm::GlobalVariable *GV =
3093 CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3094 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3095 }
3096
3097 static void
PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo *,16> & PropertySet,SmallVectorImpl<const ObjCPropertyDecl * > & Properties,const ObjCProtocolDecl * Proto,bool IsClassProperty)3098 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
3099 SmallVectorImpl<const ObjCPropertyDecl *> &Properties,
3100 const ObjCProtocolDecl *Proto,
3101 bool IsClassProperty) {
3102 for (const auto *P : Proto->protocols())
3103 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3104
3105 for (const auto *PD : Proto->properties()) {
3106 if (IsClassProperty != PD->isClassProperty())
3107 continue;
3108 if (!PropertySet.insert(PD->getIdentifier()).second)
3109 continue;
3110 Properties.push_back(PD);
3111 }
3112 }
3113
3114 /*
3115 struct _objc_property {
3116 const char * const name;
3117 const char * const attributes;
3118 };
3119
3120 struct _objc_property_list {
3121 uint32_t entsize; // sizeof (struct _objc_property)
3122 uint32_t prop_count;
3123 struct _objc_property[prop_count];
3124 };
3125 */
EmitPropertyList(Twine Name,const Decl * Container,const ObjCContainerDecl * OCD,const ObjCCommonTypesHelper & ObjCTypes,bool IsClassProperty)3126 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3127 const Decl *Container,
3128 const ObjCContainerDecl *OCD,
3129 const ObjCCommonTypesHelper &ObjCTypes,
3130 bool IsClassProperty) {
3131 if (IsClassProperty) {
3132 // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3133 // with deployment target < 9.0.
3134 const llvm::Triple &Triple = CGM.getTarget().getTriple();
3135 if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
3136 (Triple.isiOS() && Triple.isOSVersionLT(9)))
3137 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3138 }
3139
3140 SmallVector<const ObjCPropertyDecl *, 16> Properties;
3141 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3142
3143 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3144 for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3145 for (auto *PD : ClassExt->properties()) {
3146 if (IsClassProperty != PD->isClassProperty())
3147 continue;
3148 PropertySet.insert(PD->getIdentifier());
3149 Properties.push_back(PD);
3150 }
3151
3152 for (const auto *PD : OCD->properties()) {
3153 if (IsClassProperty != PD->isClassProperty())
3154 continue;
3155 // Don't emit duplicate metadata for properties that were already in a
3156 // class extension.
3157 if (!PropertySet.insert(PD->getIdentifier()).second)
3158 continue;
3159 Properties.push_back(PD);
3160 }
3161
3162 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3163 for (const auto *P : OID->all_referenced_protocols())
3164 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3165 }
3166 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3167 for (const auto *P : CD->protocols())
3168 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3169 }
3170
3171 // Return null for empty list.
3172 if (Properties.empty())
3173 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3174
3175 unsigned propertySize =
3176 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3177
3178 ConstantInitBuilder builder(CGM);
3179 auto values = builder.beginStruct();
3180 values.addInt(ObjCTypes.IntTy, propertySize);
3181 values.addInt(ObjCTypes.IntTy, Properties.size());
3182 auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3183 for (auto PD : Properties) {
3184 auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3185 property.add(GetPropertyName(PD->getIdentifier()));
3186 property.add(GetPropertyTypeString(PD, Container));
3187 property.finishAndAddTo(propertiesArray);
3188 }
3189 propertiesArray.finishAndAddTo(values);
3190
3191 StringRef Section;
3192 if (CGM.getTriple().isOSBinFormatMachO())
3193 Section = (ObjCABI == 2) ? "__DATA, __objc_const"
3194 : "__OBJC,__property,regular,no_dead_strip";
3195
3196 llvm::GlobalVariable *GV =
3197 CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3198 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3199 }
3200
3201 llvm::Constant *
EmitProtocolMethodTypes(Twine Name,ArrayRef<llvm::Constant * > MethodTypes,const ObjCCommonTypesHelper & ObjCTypes)3202 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3203 ArrayRef<llvm::Constant*> MethodTypes,
3204 const ObjCCommonTypesHelper &ObjCTypes) {
3205 // Return null for empty list.
3206 if (MethodTypes.empty())
3207 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3208
3209 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3210 MethodTypes.size());
3211 llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3212
3213 StringRef Section;
3214 if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
3215 Section = "__DATA, __objc_const";
3216
3217 llvm::GlobalVariable *GV =
3218 CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3219 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3220 }
3221
3222 /*
3223 struct _objc_category {
3224 char *category_name;
3225 char *class_name;
3226 struct _objc_method_list *instance_methods;
3227 struct _objc_method_list *class_methods;
3228 struct _objc_protocol_list *protocols;
3229 uint32_t size; // <rdar://4585769>
3230 struct _objc_property_list *instance_properties;
3231 struct _objc_property_list *class_properties;
3232 };
3233 */
GenerateCategory(const ObjCCategoryImplDecl * OCD)3234 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3235 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3236
3237 // FIXME: This is poor design, the OCD should have a pointer to the category
3238 // decl. Additionally, note that Category can be null for the @implementation
3239 // w/o an @interface case. Sema should just create one for us as it does for
3240 // @implementation so everyone else can live life under a clear blue sky.
3241 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3242 const ObjCCategoryDecl *Category =
3243 Interface->FindCategoryDeclaration(OCD->getIdentifier());
3244
3245 SmallString<256> ExtName;
3246 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3247 << OCD->getName();
3248
3249 ConstantInitBuilder Builder(CGM);
3250 auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3251
3252 enum {
3253 InstanceMethods,
3254 ClassMethods,
3255 NumMethodLists
3256 };
3257 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3258 for (const auto *MD : OCD->methods()) {
3259 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3260 }
3261
3262 Values.add(GetClassName(OCD->getName()));
3263 Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3264 LazySymbols.insert(Interface->getIdentifier());
3265
3266 Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3267 Methods[InstanceMethods]));
3268 Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3269 Methods[ClassMethods]));
3270 if (Category) {
3271 Values.add(
3272 EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3273 Category->protocol_begin(), Category->protocol_end()));
3274 } else {
3275 Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3276 }
3277 Values.addInt(ObjCTypes.IntTy, Size);
3278
3279 // If there is no category @interface then there can be no properties.
3280 if (Category) {
3281 Values.add(EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
3282 OCD, Category, ObjCTypes, false));
3283 Values.add(EmitPropertyList("\01l_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3284 OCD, Category, ObjCTypes, true));
3285 } else {
3286 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3287 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3288 }
3289
3290 llvm::GlobalVariable *GV =
3291 CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3292 "__OBJC,__category,regular,no_dead_strip",
3293 CGM.getPointerAlign(), true);
3294 DefinedCategories.push_back(GV);
3295 DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3296 // method definition entries must be clear for next implementation.
3297 MethodDefinitions.clear();
3298 }
3299
3300 enum FragileClassFlags {
3301 /// Apparently: is not a meta-class.
3302 FragileABI_Class_Factory = 0x00001,
3303
3304 /// Is a meta-class.
3305 FragileABI_Class_Meta = 0x00002,
3306
3307 /// Has a non-trivial constructor or destructor.
3308 FragileABI_Class_HasCXXStructors = 0x02000,
3309
3310 /// Has hidden visibility.
3311 FragileABI_Class_Hidden = 0x20000,
3312
3313 /// Class implementation was compiled under ARC.
3314 FragileABI_Class_CompiledByARC = 0x04000000,
3315
3316 /// Class implementation was compiled under MRC and has MRC weak ivars.
3317 /// Exclusive with CompiledByARC.
3318 FragileABI_Class_HasMRCWeakIvars = 0x08000000,
3319 };
3320
3321 enum NonFragileClassFlags {
3322 /// Is a meta-class.
3323 NonFragileABI_Class_Meta = 0x00001,
3324
3325 /// Is a root class.
3326 NonFragileABI_Class_Root = 0x00002,
3327
3328 /// Has a non-trivial constructor or destructor.
3329 NonFragileABI_Class_HasCXXStructors = 0x00004,
3330
3331 /// Has hidden visibility.
3332 NonFragileABI_Class_Hidden = 0x00010,
3333
3334 /// Has the exception attribute.
3335 NonFragileABI_Class_Exception = 0x00020,
3336
3337 /// (Obsolete) ARC-specific: this class has a .release_ivars method
3338 NonFragileABI_Class_HasIvarReleaser = 0x00040,
3339
3340 /// Class implementation was compiled under ARC.
3341 NonFragileABI_Class_CompiledByARC = 0x00080,
3342
3343 /// Class has non-trivial destructors, but zero-initialization is okay.
3344 NonFragileABI_Class_HasCXXDestructorOnly = 0x00100,
3345
3346 /// Class implementation was compiled under MRC and has MRC weak ivars.
3347 /// Exclusive with CompiledByARC.
3348 NonFragileABI_Class_HasMRCWeakIvars = 0x00200,
3349 };
3350
hasWeakMember(QualType type)3351 static bool hasWeakMember(QualType type) {
3352 if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3353 return true;
3354 }
3355
3356 if (auto recType = type->getAs<RecordType>()) {
3357 for (auto field : recType->getDecl()->fields()) {
3358 if (hasWeakMember(field->getType()))
3359 return true;
3360 }
3361 }
3362
3363 return false;
3364 }
3365
3366 /// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3367 /// (and actually fill in a layout string) if we really do have any
3368 /// __weak ivars.
hasMRCWeakIvars(CodeGenModule & CGM,const ObjCImplementationDecl * ID)3369 static bool hasMRCWeakIvars(CodeGenModule &CGM,
3370 const ObjCImplementationDecl *ID) {
3371 if (!CGM.getLangOpts().ObjCWeak) return false;
3372 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3373
3374 for (const ObjCIvarDecl *ivar =
3375 ID->getClassInterface()->all_declared_ivar_begin();
3376 ivar; ivar = ivar->getNextIvar()) {
3377 if (hasWeakMember(ivar->getType()))
3378 return true;
3379 }
3380
3381 return false;
3382 }
3383
3384 /*
3385 struct _objc_class {
3386 Class isa;
3387 Class super_class;
3388 const char *name;
3389 long version;
3390 long info;
3391 long instance_size;
3392 struct _objc_ivar_list *ivars;
3393 struct _objc_method_list *methods;
3394 struct _objc_cache *cache;
3395 struct _objc_protocol_list *protocols;
3396 // Objective-C 1.0 extensions (<rdr://4585769>)
3397 const char *ivar_layout;
3398 struct _objc_class_ext *ext;
3399 };
3400
3401 See EmitClassExtension();
3402 */
GenerateClass(const ObjCImplementationDecl * ID)3403 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3404 IdentifierInfo *RuntimeName =
3405 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
3406 DefinedSymbols.insert(RuntimeName);
3407
3408 std::string ClassName = ID->getNameAsString();
3409 // FIXME: Gross
3410 ObjCInterfaceDecl *Interface =
3411 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3412 llvm::Constant *Protocols =
3413 EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3414 Interface->all_referenced_protocol_begin(),
3415 Interface->all_referenced_protocol_end());
3416 unsigned Flags = FragileABI_Class_Factory;
3417 if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3418 Flags |= FragileABI_Class_HasCXXStructors;
3419
3420 bool hasMRCWeak = false;
3421
3422 if (CGM.getLangOpts().ObjCAutoRefCount)
3423 Flags |= FragileABI_Class_CompiledByARC;
3424 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3425 Flags |= FragileABI_Class_HasMRCWeakIvars;
3426
3427 CharUnits Size =
3428 CGM.getContext().getASTObjCImplementationLayout(ID).getSize();
3429
3430 // FIXME: Set CXX-structors flag.
3431 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3432 Flags |= FragileABI_Class_Hidden;
3433
3434 enum {
3435 InstanceMethods,
3436 ClassMethods,
3437 NumMethodLists
3438 };
3439 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3440 for (const auto *MD : ID->methods()) {
3441 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3442 }
3443
3444 for (const auto *PID : ID->property_impls()) {
3445 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3446 ObjCPropertyDecl *PD = PID->getPropertyDecl();
3447
3448 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
3449 if (GetMethodDefinition(MD))
3450 Methods[InstanceMethods].push_back(MD);
3451 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
3452 if (GetMethodDefinition(MD))
3453 Methods[InstanceMethods].push_back(MD);
3454 }
3455 }
3456
3457 ConstantInitBuilder builder(CGM);
3458 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3459 values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3460 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3461 // Record a reference to the super class.
3462 LazySymbols.insert(Super->getIdentifier());
3463
3464 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3465 ObjCTypes.ClassPtrTy);
3466 } else {
3467 values.addNullPointer(ObjCTypes.ClassPtrTy);
3468 }
3469 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3470 // Version is always 0.
3471 values.addInt(ObjCTypes.LongTy, 0);
3472 values.addInt(ObjCTypes.LongTy, Flags);
3473 values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3474 values.add(EmitIvarList(ID, false));
3475 values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3476 Methods[InstanceMethods]));
3477 // cache is always NULL.
3478 values.addNullPointer(ObjCTypes.CachePtrTy);
3479 values.add(Protocols);
3480 values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3481 values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3482 /*isMetaclass*/ false));
3483
3484 std::string Name("OBJC_CLASS_");
3485 Name += ClassName;
3486 const char *Section = "__OBJC,__class,regular,no_dead_strip";
3487 // Check for a forward reference.
3488 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3489 if (GV) {
3490 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3491 "Forward metaclass reference has incorrect type.");
3492 values.finishAndSetAsInitializer(GV);
3493 GV->setSection(Section);
3494 GV->setAlignment(CGM.getPointerAlign().getQuantity());
3495 CGM.addCompilerUsedGlobal(GV);
3496 } else
3497 GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3498 DefinedClasses.push_back(GV);
3499 ImplementedClasses.push_back(Interface);
3500 // method definition entries must be clear for next implementation.
3501 MethodDefinitions.clear();
3502 }
3503
EmitMetaClass(const ObjCImplementationDecl * ID,llvm::Constant * Protocols,ArrayRef<const ObjCMethodDecl * > Methods)3504 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3505 llvm::Constant *Protocols,
3506 ArrayRef<const ObjCMethodDecl*> Methods) {
3507 unsigned Flags = FragileABI_Class_Meta;
3508 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3509
3510 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3511 Flags |= FragileABI_Class_Hidden;
3512
3513 ConstantInitBuilder builder(CGM);
3514 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3515 // The isa for the metaclass is the root of the hierarchy.
3516 const ObjCInterfaceDecl *Root = ID->getClassInterface();
3517 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3518 Root = Super;
3519 values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3520 ObjCTypes.ClassPtrTy);
3521 // The super class for the metaclass is emitted as the name of the
3522 // super class. The runtime fixes this up to point to the
3523 // *metaclass* for the super class.
3524 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3525 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3526 ObjCTypes.ClassPtrTy);
3527 } else {
3528 values.addNullPointer(ObjCTypes.ClassPtrTy);
3529 }
3530 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3531 // Version is always 0.
3532 values.addInt(ObjCTypes.LongTy, 0);
3533 values.addInt(ObjCTypes.LongTy, Flags);
3534 values.addInt(ObjCTypes.LongTy, Size);
3535 values.add(EmitIvarList(ID, true));
3536 values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3537 Methods));
3538 // cache is always NULL.
3539 values.addNullPointer(ObjCTypes.CachePtrTy);
3540 values.add(Protocols);
3541 // ivar_layout for metaclass is always NULL.
3542 values.addNullPointer(ObjCTypes.Int8PtrTy);
3543 // The class extension is used to store class properties for metaclasses.
3544 values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3545 /*isMetaclass*/true));
3546
3547 std::string Name("OBJC_METACLASS_");
3548 Name += ID->getName();
3549
3550 // Check for a forward reference.
3551 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3552 if (GV) {
3553 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3554 "Forward metaclass reference has incorrect type.");
3555 values.finishAndSetAsInitializer(GV);
3556 } else {
3557 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3558 /*constant*/ false,
3559 llvm::GlobalValue::PrivateLinkage);
3560 }
3561 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3562 CGM.addCompilerUsedGlobal(GV);
3563
3564 return GV;
3565 }
3566
EmitMetaClassRef(const ObjCInterfaceDecl * ID)3567 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3568 std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3569
3570 // FIXME: Should we look these up somewhere other than the module. Its a bit
3571 // silly since we only generate these while processing an implementation, so
3572 // exactly one pointer would work if know when we entered/exitted an
3573 // implementation block.
3574
3575 // Check for an existing forward reference.
3576 // Previously, metaclass with internal linkage may have been defined.
3577 // pass 'true' as 2nd argument so it is returned.
3578 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3579 if (!GV)
3580 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3581 llvm::GlobalValue::PrivateLinkage, nullptr,
3582 Name);
3583
3584 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3585 "Forward metaclass reference has incorrect type.");
3586 return GV;
3587 }
3588
EmitSuperClassRef(const ObjCInterfaceDecl * ID)3589 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3590 std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3591 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3592
3593 if (!GV)
3594 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3595 llvm::GlobalValue::PrivateLinkage, nullptr,
3596 Name);
3597
3598 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3599 "Forward class metadata reference has incorrect type.");
3600 return GV;
3601 }
3602
3603 /*
3604 Emit a "class extension", which in this specific context means extra
3605 data that doesn't fit in the normal fragile-ABI class structure, and
3606 has nothing to do with the language concept of a class extension.
3607
3608 struct objc_class_ext {
3609 uint32_t size;
3610 const char *weak_ivar_layout;
3611 struct _objc_property_list *properties;
3612 };
3613 */
3614 llvm::Constant *
EmitClassExtension(const ObjCImplementationDecl * ID,CharUnits InstanceSize,bool hasMRCWeakIvars,bool isMetaclass)3615 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3616 CharUnits InstanceSize, bool hasMRCWeakIvars,
3617 bool isMetaclass) {
3618 // Weak ivar layout.
3619 llvm::Constant *layout;
3620 if (isMetaclass) {
3621 layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3622 } else {
3623 layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3624 hasMRCWeakIvars);
3625 }
3626
3627 // Properties.
3628 llvm::Constant *propertyList =
3629 EmitPropertyList((isMetaclass ? Twine("\01l_OBJC_$_CLASS_PROP_LIST_")
3630 : Twine("\01l_OBJC_$_PROP_LIST_"))
3631 + ID->getName(),
3632 ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3633
3634 // Return null if no extension bits are used.
3635 if (layout->isNullValue() && propertyList->isNullValue()) {
3636 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3637 }
3638
3639 uint64_t size =
3640 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3641
3642 ConstantInitBuilder builder(CGM);
3643 auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3644 values.addInt(ObjCTypes.IntTy, size);
3645 values.add(layout);
3646 values.add(propertyList);
3647
3648 return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3649 "__OBJC,__class_ext,regular,no_dead_strip",
3650 CGM.getPointerAlign(), true);
3651 }
3652
3653 /*
3654 struct objc_ivar {
3655 char *ivar_name;
3656 char *ivar_type;
3657 int ivar_offset;
3658 };
3659
3660 struct objc_ivar_list {
3661 int ivar_count;
3662 struct objc_ivar list[count];
3663 };
3664 */
EmitIvarList(const ObjCImplementationDecl * ID,bool ForClass)3665 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3666 bool ForClass) {
3667 // When emitting the root class GCC emits ivar entries for the
3668 // actual class structure. It is not clear if we need to follow this
3669 // behavior; for now lets try and get away with not doing it. If so,
3670 // the cleanest solution would be to make up an ObjCInterfaceDecl
3671 // for the class.
3672 if (ForClass)
3673 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3674
3675 const ObjCInterfaceDecl *OID = ID->getClassInterface();
3676
3677 ConstantInitBuilder builder(CGM);
3678 auto ivarList = builder.beginStruct();
3679 auto countSlot = ivarList.addPlaceholder();
3680 auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3681
3682 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3683 IVD; IVD = IVD->getNextIvar()) {
3684 // Ignore unnamed bit-fields.
3685 if (!IVD->getDeclName())
3686 continue;
3687
3688 auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3689 ivar.add(GetMethodVarName(IVD->getIdentifier()));
3690 ivar.add(GetMethodVarType(IVD));
3691 ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3692 ivar.finishAndAddTo(ivars);
3693 }
3694
3695 // Return null for empty list.
3696 auto count = ivars.size();
3697 if (count == 0) {
3698 ivars.abandon();
3699 ivarList.abandon();
3700 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3701 }
3702
3703 ivars.finishAndAddTo(ivarList);
3704 ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3705
3706 llvm::GlobalVariable *GV;
3707 if (ForClass)
3708 GV =
3709 CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3710 "__OBJC,__class_vars,regular,no_dead_strip",
3711 CGM.getPointerAlign(), true);
3712 else
3713 GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3714 "__OBJC,__instance_vars,regular,no_dead_strip",
3715 CGM.getPointerAlign(), true);
3716 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3717 }
3718
3719 /// Build a struct objc_method_description constant for the given method.
3720 ///
3721 /// struct objc_method_description {
3722 /// SEL method_name;
3723 /// char *method_types;
3724 /// };
emitMethodDescriptionConstant(ConstantArrayBuilder & builder,const ObjCMethodDecl * MD)3725 void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3726 const ObjCMethodDecl *MD) {
3727 auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3728 description.addBitCast(GetMethodVarName(MD->getSelector()),
3729 ObjCTypes.SelectorPtrTy);
3730 description.add(GetMethodVarType(MD));
3731 description.finishAndAddTo(builder);
3732 }
3733
3734 /// Build a struct objc_method constant for the given method.
3735 ///
3736 /// struct objc_method {
3737 /// SEL method_name;
3738 /// char *method_types;
3739 /// void *method;
3740 /// };
emitMethodConstant(ConstantArrayBuilder & builder,const ObjCMethodDecl * MD)3741 void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3742 const ObjCMethodDecl *MD) {
3743 llvm::Function *fn = GetMethodDefinition(MD);
3744 assert(fn && "no definition registered for method");
3745
3746 auto method = builder.beginStruct(ObjCTypes.MethodTy);
3747 method.addBitCast(GetMethodVarName(MD->getSelector()),
3748 ObjCTypes.SelectorPtrTy);
3749 method.add(GetMethodVarType(MD));
3750 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3751 method.finishAndAddTo(builder);
3752 }
3753
3754 /// Build a struct objc_method_list or struct objc_method_description_list,
3755 /// as appropriate.
3756 ///
3757 /// struct objc_method_list {
3758 /// struct objc_method_list *obsolete;
3759 /// int count;
3760 /// struct objc_method methods_list[count];
3761 /// };
3762 ///
3763 /// struct objc_method_description_list {
3764 /// int count;
3765 /// struct objc_method_description list[count];
3766 /// };
emitMethodList(Twine name,MethodListType MLT,ArrayRef<const ObjCMethodDecl * > methods)3767 llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3768 ArrayRef<const ObjCMethodDecl *> methods) {
3769 StringRef prefix;
3770 StringRef section;
3771 bool forProtocol = false;
3772 switch (MLT) {
3773 case MethodListType::CategoryInstanceMethods:
3774 prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3775 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3776 forProtocol = false;
3777 break;
3778 case MethodListType::CategoryClassMethods:
3779 prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3780 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3781 forProtocol = false;
3782 break;
3783 case MethodListType::InstanceMethods:
3784 prefix = "OBJC_INSTANCE_METHODS_";
3785 section = "__OBJC,__inst_meth,regular,no_dead_strip";
3786 forProtocol = false;
3787 break;
3788 case MethodListType::ClassMethods:
3789 prefix = "OBJC_CLASS_METHODS_";
3790 section = "__OBJC,__cls_meth,regular,no_dead_strip";
3791 forProtocol = false;
3792 break;
3793 case MethodListType::ProtocolInstanceMethods:
3794 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3795 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3796 forProtocol = true;
3797 break;
3798 case MethodListType::ProtocolClassMethods:
3799 prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3800 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3801 forProtocol = true;
3802 break;
3803 case MethodListType::OptionalProtocolInstanceMethods:
3804 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3805 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3806 forProtocol = true;
3807 break;
3808 case MethodListType::OptionalProtocolClassMethods:
3809 prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3810 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3811 forProtocol = true;
3812 break;
3813 }
3814
3815 // Return null for empty list.
3816 if (methods.empty())
3817 return llvm::Constant::getNullValue(forProtocol
3818 ? ObjCTypes.MethodDescriptionListPtrTy
3819 : ObjCTypes.MethodListPtrTy);
3820
3821 // For protocols, this is an objc_method_description_list, which has
3822 // a slightly different structure.
3823 if (forProtocol) {
3824 ConstantInitBuilder builder(CGM);
3825 auto values = builder.beginStruct();
3826 values.addInt(ObjCTypes.IntTy, methods.size());
3827 auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3828 for (auto MD : methods) {
3829 emitMethodDescriptionConstant(methodArray, MD);
3830 }
3831 methodArray.finishAndAddTo(values);
3832
3833 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3834 CGM.getPointerAlign(), true);
3835 return llvm::ConstantExpr::getBitCast(GV,
3836 ObjCTypes.MethodDescriptionListPtrTy);
3837 }
3838
3839 // Otherwise, it's an objc_method_list.
3840 ConstantInitBuilder builder(CGM);
3841 auto values = builder.beginStruct();
3842 values.addNullPointer(ObjCTypes.Int8PtrTy);
3843 values.addInt(ObjCTypes.IntTy, methods.size());
3844 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
3845 for (auto MD : methods) {
3846 emitMethodConstant(methodArray, MD);
3847 }
3848 methodArray.finishAndAddTo(values);
3849
3850 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3851 CGM.getPointerAlign(), true);
3852 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
3853 }
3854
GenerateMethod(const ObjCMethodDecl * OMD,const ObjCContainerDecl * CD)3855 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
3856 const ObjCContainerDecl *CD) {
3857 SmallString<256> Name;
3858 GetNameForMethod(OMD, CD, Name);
3859
3860 CodeGenTypes &Types = CGM.getTypes();
3861 llvm::FunctionType *MethodTy =
3862 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
3863 llvm::Function *Method =
3864 llvm::Function::Create(MethodTy,
3865 llvm::GlobalValue::InternalLinkage,
3866 Name.str(),
3867 &CGM.getModule());
3868 MethodDefinitions.insert(std::make_pair(OMD, Method));
3869
3870 return Method;
3871 }
3872
CreateMetadataVar(Twine Name,ConstantStructBuilder & Init,StringRef Section,CharUnits Align,bool AddToUsed)3873 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3874 ConstantStructBuilder &Init,
3875 StringRef Section,
3876 CharUnits Align,
3877 bool AddToUsed) {
3878 llvm::GlobalVariable *GV =
3879 Init.finishAndCreateGlobal(Name, Align, /*constant*/ false,
3880 llvm::GlobalValue::PrivateLinkage);
3881 if (!Section.empty())
3882 GV->setSection(Section);
3883 if (AddToUsed)
3884 CGM.addCompilerUsedGlobal(GV);
3885 return GV;
3886 }
3887
CreateMetadataVar(Twine Name,llvm::Constant * Init,StringRef Section,CharUnits Align,bool AddToUsed)3888 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3889 llvm::Constant *Init,
3890 StringRef Section,
3891 CharUnits Align,
3892 bool AddToUsed) {
3893 llvm::Type *Ty = Init->getType();
3894 llvm::GlobalVariable *GV =
3895 new llvm::GlobalVariable(CGM.getModule(), Ty, false,
3896 llvm::GlobalValue::PrivateLinkage, Init, Name);
3897 if (!Section.empty())
3898 GV->setSection(Section);
3899 GV->setAlignment(Align.getQuantity());
3900 if (AddToUsed)
3901 CGM.addCompilerUsedGlobal(GV);
3902 return GV;
3903 }
3904
3905 llvm::GlobalVariable *
CreateCStringLiteral(StringRef Name,ObjCLabelType Type,bool ForceNonFragileABI,bool NullTerminate)3906 CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
3907 bool ForceNonFragileABI,
3908 bool NullTerminate) {
3909 StringRef Label;
3910 switch (Type) {
3911 case ObjCLabelType::ClassName: Label = "OBJC_CLASS_NAME_"; break;
3912 case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
3913 case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
3914 case ObjCLabelType::PropertyName: Label = "OBJC_PROP_NAME_ATTR_"; break;
3915 }
3916
3917 bool NonFragile = ForceNonFragileABI || isNonFragileABI();
3918
3919 StringRef Section;
3920 switch (Type) {
3921 case ObjCLabelType::ClassName:
3922 Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
3923 : "__TEXT,__cstring,cstring_literals";
3924 break;
3925 case ObjCLabelType::MethodVarName:
3926 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
3927 : "__TEXT,__cstring,cstring_literals";
3928 break;
3929 case ObjCLabelType::MethodVarType:
3930 Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
3931 : "__TEXT,__cstring,cstring_literals";
3932 break;
3933 case ObjCLabelType::PropertyName:
3934 Section = "__TEXT,__cstring,cstring_literals";
3935 break;
3936 }
3937
3938 llvm::Constant *Value =
3939 llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
3940 llvm::GlobalVariable *GV =
3941 new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
3942 /*isConstant=*/true,
3943 llvm::GlobalValue::PrivateLinkage, Value, Label);
3944 if (CGM.getTriple().isOSBinFormatMachO())
3945 GV->setSection(Section);
3946 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3947 GV->setAlignment(CharUnits::One().getQuantity());
3948 CGM.addCompilerUsedGlobal(GV);
3949
3950 return GV;
3951 }
3952
ModuleInitFunction()3953 llvm::Function *CGObjCMac::ModuleInitFunction() {
3954 // Abuse this interface function as a place to finalize.
3955 FinishModule();
3956 return nullptr;
3957 }
3958
GetPropertyGetFunction()3959 llvm::Constant *CGObjCMac::GetPropertyGetFunction() {
3960 return ObjCTypes.getGetPropertyFn();
3961 }
3962
GetPropertySetFunction()3963 llvm::Constant *CGObjCMac::GetPropertySetFunction() {
3964 return ObjCTypes.getSetPropertyFn();
3965 }
3966
GetOptimizedPropertySetFunction(bool atomic,bool copy)3967 llvm::Constant *CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
3968 bool copy) {
3969 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
3970 }
3971
GetGetStructFunction()3972 llvm::Constant *CGObjCMac::GetGetStructFunction() {
3973 return ObjCTypes.getCopyStructFn();
3974 }
3975
GetSetStructFunction()3976 llvm::Constant *CGObjCMac::GetSetStructFunction() {
3977 return ObjCTypes.getCopyStructFn();
3978 }
3979
GetCppAtomicObjectGetFunction()3980 llvm::Constant *CGObjCMac::GetCppAtomicObjectGetFunction() {
3981 return ObjCTypes.getCppAtomicObjectFunction();
3982 }
3983
GetCppAtomicObjectSetFunction()3984 llvm::Constant *CGObjCMac::GetCppAtomicObjectSetFunction() {
3985 return ObjCTypes.getCppAtomicObjectFunction();
3986 }
3987
EnumerationMutationFunction()3988 llvm::Constant *CGObjCMac::EnumerationMutationFunction() {
3989 return ObjCTypes.getEnumerationMutationFn();
3990 }
3991
EmitTryStmt(CodeGenFunction & CGF,const ObjCAtTryStmt & S)3992 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
3993 return EmitTryOrSynchronizedStmt(CGF, S);
3994 }
3995
EmitSynchronizedStmt(CodeGenFunction & CGF,const ObjCAtSynchronizedStmt & S)3996 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
3997 const ObjCAtSynchronizedStmt &S) {
3998 return EmitTryOrSynchronizedStmt(CGF, S);
3999 }
4000
4001 namespace {
4002 struct PerformFragileFinally final : EHScopeStack::Cleanup {
4003 const Stmt &S;
4004 Address SyncArgSlot;
4005 Address CallTryExitVar;
4006 Address ExceptionData;
4007 ObjCTypesHelper &ObjCTypes;
PerformFragileFinally__anon377f67430811::PerformFragileFinally4008 PerformFragileFinally(const Stmt *S,
4009 Address SyncArgSlot,
4010 Address CallTryExitVar,
4011 Address ExceptionData,
4012 ObjCTypesHelper *ObjCTypes)
4013 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4014 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4015
Emit__anon377f67430811::PerformFragileFinally4016 void Emit(CodeGenFunction &CGF, Flags flags) override {
4017 // Check whether we need to call objc_exception_try_exit.
4018 // In optimized code, this branch will always be folded.
4019 llvm::BasicBlock *FinallyCallExit =
4020 CGF.createBasicBlock("finally.call_exit");
4021 llvm::BasicBlock *FinallyNoCallExit =
4022 CGF.createBasicBlock("finally.no_call_exit");
4023 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4024 FinallyCallExit, FinallyNoCallExit);
4025
4026 CGF.EmitBlock(FinallyCallExit);
4027 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4028 ExceptionData.getPointer());
4029
4030 CGF.EmitBlock(FinallyNoCallExit);
4031
4032 if (isa<ObjCAtTryStmt>(S)) {
4033 if (const ObjCAtFinallyStmt* FinallyStmt =
4034 cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4035 // Don't try to do the @finally if this is an EH cleanup.
4036 if (flags.isForEHCleanup()) return;
4037
4038 // Save the current cleanup destination in case there's
4039 // control flow inside the finally statement.
4040 llvm::Value *CurCleanupDest =
4041 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
4042
4043 CGF.EmitStmt(FinallyStmt->getFinallyBody());
4044
4045 if (CGF.HaveInsertPoint()) {
4046 CGF.Builder.CreateStore(CurCleanupDest,
4047 CGF.getNormalCleanupDestSlot());
4048 } else {
4049 // Currently, the end of the cleanup must always exist.
4050 CGF.EnsureInsertPoint();
4051 }
4052 }
4053 } else {
4054 // Emit objc_sync_exit(expr); as finally's sole statement for
4055 // @synchronized.
4056 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4057 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4058 }
4059 }
4060 };
4061
4062 class FragileHazards {
4063 CodeGenFunction &CGF;
4064 SmallVector<llvm::Value*, 20> Locals;
4065 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4066
4067 llvm::InlineAsm *ReadHazard;
4068 llvm::InlineAsm *WriteHazard;
4069
4070 llvm::FunctionType *GetAsmFnType();
4071
4072 void collectLocals();
4073 void emitReadHazard(CGBuilderTy &Builder);
4074
4075 public:
4076 FragileHazards(CodeGenFunction &CGF);
4077
4078 void emitWriteHazard();
4079 void emitHazardsInNewBlocks();
4080 };
4081 } // end anonymous namespace
4082
4083 /// Create the fragile-ABI read and write hazards based on the current
4084 /// state of the function, which is presumed to be immediately prior
4085 /// to a @try block. These hazards are used to maintain correct
4086 /// semantics in the face of optimization and the fragile ABI's
4087 /// cavalier use of setjmp/longjmp.
FragileHazards(CodeGenFunction & CGF)4088 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4089 collectLocals();
4090
4091 if (Locals.empty()) return;
4092
4093 // Collect all the blocks in the function.
4094 for (llvm::Function::iterator
4095 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
4096 BlocksBeforeTry.insert(&*I);
4097
4098 llvm::FunctionType *AsmFnTy = GetAsmFnType();
4099
4100 // Create a read hazard for the allocas. This inhibits dead-store
4101 // optimizations and forces the values to memory. This hazard is
4102 // inserted before any 'throwing' calls in the protected scope to
4103 // reflect the possibility that the variables might be read from the
4104 // catch block if the call throws.
4105 {
4106 std::string Constraint;
4107 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4108 if (I) Constraint += ',';
4109 Constraint += "*m";
4110 }
4111
4112 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4113 }
4114
4115 // Create a write hazard for the allocas. This inhibits folding
4116 // loads across the hazard. This hazard is inserted at the
4117 // beginning of the catch path to reflect the possibility that the
4118 // variables might have been written within the protected scope.
4119 {
4120 std::string Constraint;
4121 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4122 if (I) Constraint += ',';
4123 Constraint += "=*m";
4124 }
4125
4126 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4127 }
4128 }
4129
4130 /// Emit a write hazard at the current location.
emitWriteHazard()4131 void FragileHazards::emitWriteHazard() {
4132 if (Locals.empty()) return;
4133
4134 CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4135 }
4136
emitReadHazard(CGBuilderTy & Builder)4137 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4138 assert(!Locals.empty());
4139 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4140 call->setDoesNotThrow();
4141 call->setCallingConv(CGF.getRuntimeCC());
4142 }
4143
4144 /// Emit read hazards in all the protected blocks, i.e. all the blocks
4145 /// which have been inserted since the beginning of the try.
emitHazardsInNewBlocks()4146 void FragileHazards::emitHazardsInNewBlocks() {
4147 if (Locals.empty()) return;
4148
4149 CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4150
4151 // Iterate through all blocks, skipping those prior to the try.
4152 for (llvm::Function::iterator
4153 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
4154 llvm::BasicBlock &BB = *FI;
4155 if (BlocksBeforeTry.count(&BB)) continue;
4156
4157 // Walk through all the calls in the block.
4158 for (llvm::BasicBlock::iterator
4159 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
4160 llvm::Instruction &I = *BI;
4161
4162 // Ignore instructions that aren't non-intrinsic calls.
4163 // These are the only calls that can possibly call longjmp.
4164 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) continue;
4165 if (isa<llvm::IntrinsicInst>(I))
4166 continue;
4167
4168 // Ignore call sites marked nounwind. This may be questionable,
4169 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4170 llvm::CallSite CS(&I);
4171 if (CS.doesNotThrow()) continue;
4172
4173 // Insert a read hazard before the call. This will ensure that
4174 // any writes to the locals are performed before making the
4175 // call. If the call throws, then this is sufficient to
4176 // guarantee correctness as long as it doesn't also write to any
4177 // locals.
4178 Builder.SetInsertPoint(&BB, BI);
4179 emitReadHazard(Builder);
4180 }
4181 }
4182 }
4183
addIfPresent(llvm::DenseSet<llvm::Value * > & S,Address V)4184 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
4185 if (V.isValid()) S.insert(V.getPointer());
4186 }
4187
collectLocals()4188 void FragileHazards::collectLocals() {
4189 // Compute a set of allocas to ignore.
4190 llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4191 addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4192 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4193
4194 // Collect all the allocas currently in the function. This is
4195 // probably way too aggressive.
4196 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4197 for (llvm::BasicBlock::iterator
4198 I = Entry.begin(), E = Entry.end(); I != E; ++I)
4199 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
4200 Locals.push_back(&*I);
4201 }
4202
GetAsmFnType()4203 llvm::FunctionType *FragileHazards::GetAsmFnType() {
4204 SmallVector<llvm::Type *, 16> tys(Locals.size());
4205 for (unsigned i = 0, e = Locals.size(); i != e; ++i)
4206 tys[i] = Locals[i]->getType();
4207 return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4208 }
4209
4210 /*
4211
4212 Objective-C setjmp-longjmp (sjlj) Exception Handling
4213 --
4214
4215 A catch buffer is a setjmp buffer plus:
4216 - a pointer to the exception that was caught
4217 - a pointer to the previous exception data buffer
4218 - two pointers of reserved storage
4219 Therefore catch buffers form a stack, with a pointer to the top
4220 of the stack kept in thread-local storage.
4221
4222 objc_exception_try_enter pushes a catch buffer onto the EH stack.
4223 objc_exception_try_exit pops the given catch buffer, which is
4224 required to be the top of the EH stack.
4225 objc_exception_throw pops the top of the EH stack, writes the
4226 thrown exception into the appropriate field, and longjmps
4227 to the setjmp buffer. It crashes the process (with a printf
4228 and an abort()) if there are no catch buffers on the stack.
4229 objc_exception_extract just reads the exception pointer out of the
4230 catch buffer.
4231
4232 There's no reason an implementation couldn't use a light-weight
4233 setjmp here --- something like __builtin_setjmp, but API-compatible
4234 with the heavyweight setjmp. This will be more important if we ever
4235 want to implement correct ObjC/C++ exception interactions for the
4236 fragile ABI.
4237
4238 Note that for this use of setjmp/longjmp to be correct, we may need
4239 to mark some local variables volatile: if a non-volatile local
4240 variable is modified between the setjmp and the longjmp, it has
4241 indeterminate value. For the purposes of LLVM IR, it may be
4242 sufficient to make loads and stores within the @try (to variables
4243 declared outside the @try) volatile. This is necessary for
4244 optimized correctness, but is not currently being done; this is
4245 being tracked as rdar://problem/8160285
4246
4247 The basic framework for a @try-catch-finally is as follows:
4248 {
4249 objc_exception_data d;
4250 id _rethrow = null;
4251 bool _call_try_exit = true;
4252
4253 objc_exception_try_enter(&d);
4254 if (!setjmp(d.jmp_buf)) {
4255 ... try body ...
4256 } else {
4257 // exception path
4258 id _caught = objc_exception_extract(&d);
4259
4260 // enter new try scope for handlers
4261 if (!setjmp(d.jmp_buf)) {
4262 ... match exception and execute catch blocks ...
4263
4264 // fell off end, rethrow.
4265 _rethrow = _caught;
4266 ... jump-through-finally to finally_rethrow ...
4267 } else {
4268 // exception in catch block
4269 _rethrow = objc_exception_extract(&d);
4270 _call_try_exit = false;
4271 ... jump-through-finally to finally_rethrow ...
4272 }
4273 }
4274 ... jump-through-finally to finally_end ...
4275
4276 finally:
4277 if (_call_try_exit)
4278 objc_exception_try_exit(&d);
4279
4280 ... finally block ....
4281 ... dispatch to finally destination ...
4282
4283 finally_rethrow:
4284 objc_exception_throw(_rethrow);
4285
4286 finally_end:
4287 }
4288
4289 This framework differs slightly from the one gcc uses, in that gcc
4290 uses _rethrow to determine if objc_exception_try_exit should be called
4291 and if the object should be rethrown. This breaks in the face of
4292 throwing nil and introduces unnecessary branches.
4293
4294 We specialize this framework for a few particular circumstances:
4295
4296 - If there are no catch blocks, then we avoid emitting the second
4297 exception handling context.
4298
4299 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4300 e)) we avoid emitting the code to rethrow an uncaught exception.
4301
4302 - FIXME: If there is no @finally block we can do a few more
4303 simplifications.
4304
4305 Rethrows and Jumps-Through-Finally
4306 --
4307
4308 '@throw;' is supported by pushing the currently-caught exception
4309 onto ObjCEHStack while the @catch blocks are emitted.
4310
4311 Branches through the @finally block are handled with an ordinary
4312 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
4313 exceptions are not compatible with C++ exceptions, and this is
4314 hardly the only place where this will go wrong.
4315
4316 @synchronized(expr) { stmt; } is emitted as if it were:
4317 id synch_value = expr;
4318 objc_sync_enter(synch_value);
4319 @try { stmt; } @finally { objc_sync_exit(synch_value); }
4320 */
4321
EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction & CGF,const Stmt & S)4322 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4323 const Stmt &S) {
4324 bool isTry = isa<ObjCAtTryStmt>(S);
4325
4326 // A destination for the fall-through edges of the catch handlers to
4327 // jump to.
4328 CodeGenFunction::JumpDest FinallyEnd =
4329 CGF.getJumpDestInCurrentScope("finally.end");
4330
4331 // A destination for the rethrow edge of the catch handlers to jump
4332 // to.
4333 CodeGenFunction::JumpDest FinallyRethrow =
4334 CGF.getJumpDestInCurrentScope("finally.rethrow");
4335
4336 // For @synchronized, call objc_sync_enter(sync.expr). The
4337 // evaluation of the expression must occur before we enter the
4338 // @synchronized. We can't avoid a temp here because we need the
4339 // value to be preserved. If the backend ever does liveness
4340 // correctly after setjmp, this will be unnecessary.
4341 Address SyncArgSlot = Address::invalid();
4342 if (!isTry) {
4343 llvm::Value *SyncArg =
4344 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4345 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4346 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4347
4348 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4349 CGF.getPointerAlign(), "sync.arg");
4350 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4351 }
4352
4353 // Allocate memory for the setjmp buffer. This needs to be kept
4354 // live throughout the try and catch blocks.
4355 Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4356 CGF.getPointerAlign(),
4357 "exceptiondata.ptr");
4358
4359 // Create the fragile hazards. Note that this will not capture any
4360 // of the allocas required for exception processing, but will
4361 // capture the current basic block (which extends all the way to the
4362 // setjmp call) as "before the @try".
4363 FragileHazards Hazards(CGF);
4364
4365 // Create a flag indicating whether the cleanup needs to call
4366 // objc_exception_try_exit. This is true except when
4367 // - no catches match and we're branching through the cleanup
4368 // just to rethrow the exception, or
4369 // - a catch matched and we're falling out of the catch handler.
4370 // The setjmp-safety rule here is that we should always store to this
4371 // variable in a place that dominates the branch through the cleanup
4372 // without passing through any setjmps.
4373 Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4374 CharUnits::One(),
4375 "_call_try_exit");
4376
4377 // A slot containing the exception to rethrow. Only needed when we
4378 // have both a @catch and a @finally.
4379 Address PropagatingExnVar = Address::invalid();
4380
4381 // Push a normal cleanup to leave the try scope.
4382 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4383 SyncArgSlot,
4384 CallTryExitVar,
4385 ExceptionData,
4386 &ObjCTypes);
4387
4388 // Enter a try block:
4389 // - Call objc_exception_try_enter to push ExceptionData on top of
4390 // the EH stack.
4391 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4392 ExceptionData.getPointer());
4393
4394 // - Call setjmp on the exception data buffer.
4395 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4396 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4397 llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4398 ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4399 "setjmp_buffer");
4400 llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4401 ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4402 SetJmpResult->setCanReturnTwice();
4403
4404 // If setjmp returned 0, enter the protected block; otherwise,
4405 // branch to the handler.
4406 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4407 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4408 llvm::Value *DidCatch =
4409 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4410 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4411
4412 // Emit the protected block.
4413 CGF.EmitBlock(TryBlock);
4414 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4415 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4416 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4417
4418 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4419
4420 // Emit the exception handler block.
4421 CGF.EmitBlock(TryHandler);
4422
4423 // Don't optimize loads of the in-scope locals across this point.
4424 Hazards.emitWriteHazard();
4425
4426 // For a @synchronized (or a @try with no catches), just branch
4427 // through the cleanup to the rethrow block.
4428 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4429 // Tell the cleanup not to re-pop the exit.
4430 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4431 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4432
4433 // Otherwise, we have to match against the caught exceptions.
4434 } else {
4435 // Retrieve the exception object. We may emit multiple blocks but
4436 // nothing can cross this so the value is already in SSA form.
4437 llvm::CallInst *Caught =
4438 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4439 ExceptionData.getPointer(), "caught");
4440
4441 // Push the exception to rethrow onto the EH value stack for the
4442 // benefit of any @throws in the handlers.
4443 CGF.ObjCEHValueStack.push_back(Caught);
4444
4445 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4446
4447 bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4448
4449 llvm::BasicBlock *CatchBlock = nullptr;
4450 llvm::BasicBlock *CatchHandler = nullptr;
4451 if (HasFinally) {
4452 // Save the currently-propagating exception before
4453 // objc_exception_try_enter clears the exception slot.
4454 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4455 CGF.getPointerAlign(),
4456 "propagating_exception");
4457 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4458
4459 // Enter a new exception try block (in case a @catch block
4460 // throws an exception).
4461 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4462 ExceptionData.getPointer());
4463
4464 llvm::CallInst *SetJmpResult =
4465 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4466 SetJmpBuffer, "setjmp.result");
4467 SetJmpResult->setCanReturnTwice();
4468
4469 llvm::Value *Threw =
4470 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4471
4472 CatchBlock = CGF.createBasicBlock("catch");
4473 CatchHandler = CGF.createBasicBlock("catch_for_catch");
4474 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4475
4476 CGF.EmitBlock(CatchBlock);
4477 }
4478
4479 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4480
4481 // Handle catch list. As a special case we check if everything is
4482 // matched and avoid generating code for falling off the end if
4483 // so.
4484 bool AllMatched = false;
4485 for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
4486 const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4487
4488 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4489 const ObjCObjectPointerType *OPT = nullptr;
4490
4491 // catch(...) always matches.
4492 if (!CatchParam) {
4493 AllMatched = true;
4494 } else {
4495 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4496
4497 // catch(id e) always matches under this ABI, since only
4498 // ObjC exceptions end up here in the first place.
4499 // FIXME: For the time being we also match id<X>; this should
4500 // be rejected by Sema instead.
4501 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4502 AllMatched = true;
4503 }
4504
4505 // If this is a catch-all, we don't need to test anything.
4506 if (AllMatched) {
4507 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4508
4509 if (CatchParam) {
4510 CGF.EmitAutoVarDecl(*CatchParam);
4511 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4512
4513 // These types work out because ConvertType(id) == i8*.
4514 EmitInitOfCatchParam(CGF, Caught, CatchParam);
4515 }
4516
4517 CGF.EmitStmt(CatchStmt->getCatchBody());
4518
4519 // The scope of the catch variable ends right here.
4520 CatchVarCleanups.ForceCleanup();
4521
4522 CGF.EmitBranchThroughCleanup(FinallyEnd);
4523 break;
4524 }
4525
4526 assert(OPT && "Unexpected non-object pointer type in @catch");
4527 const ObjCObjectType *ObjTy = OPT->getObjectType();
4528
4529 // FIXME: @catch (Class c) ?
4530 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4531 assert(IDecl && "Catch parameter must have Objective-C type!");
4532
4533 // Check if the @catch block matches the exception object.
4534 llvm::Value *Class = EmitClassRef(CGF, IDecl);
4535
4536 llvm::Value *matchArgs[] = { Class, Caught };
4537 llvm::CallInst *Match =
4538 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4539 matchArgs, "match");
4540
4541 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4542 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4543
4544 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4545 MatchedBlock, NextCatchBlock);
4546
4547 // Emit the @catch block.
4548 CGF.EmitBlock(MatchedBlock);
4549
4550 // Collect any cleanups for the catch variable. The scope lasts until
4551 // the end of the catch body.
4552 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4553
4554 CGF.EmitAutoVarDecl(*CatchParam);
4555 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4556
4557 // Initialize the catch variable.
4558 llvm::Value *Tmp =
4559 CGF.Builder.CreateBitCast(Caught,
4560 CGF.ConvertType(CatchParam->getType()));
4561 EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4562
4563 CGF.EmitStmt(CatchStmt->getCatchBody());
4564
4565 // We're done with the catch variable.
4566 CatchVarCleanups.ForceCleanup();
4567
4568 CGF.EmitBranchThroughCleanup(FinallyEnd);
4569
4570 CGF.EmitBlock(NextCatchBlock);
4571 }
4572
4573 CGF.ObjCEHValueStack.pop_back();
4574
4575 // If nothing wanted anything to do with the caught exception,
4576 // kill the extract call.
4577 if (Caught->use_empty())
4578 Caught->eraseFromParent();
4579
4580 if (!AllMatched)
4581 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4582
4583 if (HasFinally) {
4584 // Emit the exception handler for the @catch blocks.
4585 CGF.EmitBlock(CatchHandler);
4586
4587 // In theory we might now need a write hazard, but actually it's
4588 // unnecessary because there's no local-accessing code between
4589 // the try's write hazard and here.
4590 //Hazards.emitWriteHazard();
4591
4592 // Extract the new exception and save it to the
4593 // propagating-exception slot.
4594 assert(PropagatingExnVar.isValid());
4595 llvm::CallInst *NewCaught =
4596 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4597 ExceptionData.getPointer(), "caught");
4598 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4599
4600 // Don't pop the catch handler; the throw already did.
4601 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4602 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4603 }
4604 }
4605
4606 // Insert read hazards as required in the new blocks.
4607 Hazards.emitHazardsInNewBlocks();
4608
4609 // Pop the cleanup.
4610 CGF.Builder.restoreIP(TryFallthroughIP);
4611 if (CGF.HaveInsertPoint())
4612 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4613 CGF.PopCleanupBlock();
4614 CGF.EmitBlock(FinallyEnd.getBlock(), true);
4615
4616 // Emit the rethrow block.
4617 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4618 CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4619 if (CGF.HaveInsertPoint()) {
4620 // If we have a propagating-exception variable, check it.
4621 llvm::Value *PropagatingExn;
4622 if (PropagatingExnVar.isValid()) {
4623 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4624
4625 // Otherwise, just look in the buffer for the exception to throw.
4626 } else {
4627 llvm::CallInst *Caught =
4628 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4629 ExceptionData.getPointer());
4630 PropagatingExn = Caught;
4631 }
4632
4633 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4634 PropagatingExn);
4635 CGF.Builder.CreateUnreachable();
4636 }
4637
4638 CGF.Builder.restoreIP(SavedIP);
4639 }
4640
EmitThrowStmt(CodeGen::CodeGenFunction & CGF,const ObjCAtThrowStmt & S,bool ClearInsertionPoint)4641 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4642 const ObjCAtThrowStmt &S,
4643 bool ClearInsertionPoint) {
4644 llvm::Value *ExceptionAsObject;
4645
4646 if (const Expr *ThrowExpr = S.getThrowExpr()) {
4647 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4648 ExceptionAsObject =
4649 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4650 } else {
4651 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4652 "Unexpected rethrow outside @catch block.");
4653 ExceptionAsObject = CGF.ObjCEHValueStack.back();
4654 }
4655
4656 CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4657 ->setDoesNotReturn();
4658 CGF.Builder.CreateUnreachable();
4659
4660 // Clear the insertion point to indicate we are in unreachable code.
4661 if (ClearInsertionPoint)
4662 CGF.Builder.ClearInsertionPoint();
4663 }
4664
4665 /// EmitObjCWeakRead - Code gen for loading value of a __weak
4666 /// object: objc_read_weak (id *src)
4667 ///
EmitObjCWeakRead(CodeGen::CodeGenFunction & CGF,Address AddrWeakObj)4668 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4669 Address AddrWeakObj) {
4670 llvm::Type* DestTy = AddrWeakObj.getElementType();
4671 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4672 ObjCTypes.PtrObjectPtrTy);
4673 llvm::Value *read_weak =
4674 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4675 AddrWeakObj.getPointer(), "weakread");
4676 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4677 return read_weak;
4678 }
4679
4680 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4681 /// objc_assign_weak (id src, id *dst)
4682 ///
EmitObjCWeakAssign(CodeGen::CodeGenFunction & CGF,llvm::Value * src,Address dst)4683 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4684 llvm::Value *src, Address dst) {
4685 llvm::Type * SrcTy = src->getType();
4686 if (!isa<llvm::PointerType>(SrcTy)) {
4687 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4688 assert(Size <= 8 && "does not support size > 8");
4689 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4690 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4691 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4692 }
4693 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4694 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4695 llvm::Value *args[] = { src, dst.getPointer() };
4696 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4697 args, "weakassign");
4698 }
4699
4700 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4701 /// objc_assign_global (id src, id *dst)
4702 ///
EmitObjCGlobalAssign(CodeGen::CodeGenFunction & CGF,llvm::Value * src,Address dst,bool threadlocal)4703 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4704 llvm::Value *src, Address dst,
4705 bool threadlocal) {
4706 llvm::Type * SrcTy = src->getType();
4707 if (!isa<llvm::PointerType>(SrcTy)) {
4708 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4709 assert(Size <= 8 && "does not support size > 8");
4710 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4711 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4712 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4713 }
4714 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4715 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4716 llvm::Value *args[] = { src, dst.getPointer() };
4717 if (!threadlocal)
4718 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4719 args, "globalassign");
4720 else
4721 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4722 args, "threadlocalassign");
4723 }
4724
4725 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4726 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4727 ///
EmitObjCIvarAssign(CodeGen::CodeGenFunction & CGF,llvm::Value * src,Address dst,llvm::Value * ivarOffset)4728 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4729 llvm::Value *src, Address dst,
4730 llvm::Value *ivarOffset) {
4731 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
4732 llvm::Type * SrcTy = src->getType();
4733 if (!isa<llvm::PointerType>(SrcTy)) {
4734 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4735 assert(Size <= 8 && "does not support size > 8");
4736 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4737 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4738 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4739 }
4740 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4741 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4742 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
4743 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
4744 }
4745
4746 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
4747 /// objc_assign_strongCast (id src, id *dst)
4748 ///
EmitObjCStrongCastAssign(CodeGen::CodeGenFunction & CGF,llvm::Value * src,Address dst)4749 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
4750 llvm::Value *src, Address dst) {
4751 llvm::Type * SrcTy = src->getType();
4752 if (!isa<llvm::PointerType>(SrcTy)) {
4753 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4754 assert(Size <= 8 && "does not support size > 8");
4755 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4756 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4757 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4758 }
4759 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4760 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4761 llvm::Value *args[] = { src, dst.getPointer() };
4762 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
4763 args, "strongassign");
4764 }
4765
EmitGCMemmoveCollectable(CodeGen::CodeGenFunction & CGF,Address DestPtr,Address SrcPtr,llvm::Value * size)4766 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
4767 Address DestPtr,
4768 Address SrcPtr,
4769 llvm::Value *size) {
4770 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
4771 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
4772 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
4773 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
4774 }
4775
4776 /// EmitObjCValueForIvar - Code Gen for ivar reference.
4777 ///
EmitObjCValueForIvar(CodeGen::CodeGenFunction & CGF,QualType ObjectTy,llvm::Value * BaseValue,const ObjCIvarDecl * Ivar,unsigned CVRQualifiers)4778 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
4779 QualType ObjectTy,
4780 llvm::Value *BaseValue,
4781 const ObjCIvarDecl *Ivar,
4782 unsigned CVRQualifiers) {
4783 const ObjCInterfaceDecl *ID =
4784 ObjectTy->getAs<ObjCObjectType>()->getInterface();
4785 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
4786 EmitIvarOffset(CGF, ID, Ivar));
4787 }
4788
EmitIvarOffset(CodeGen::CodeGenFunction & CGF,const ObjCInterfaceDecl * Interface,const ObjCIvarDecl * Ivar)4789 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
4790 const ObjCInterfaceDecl *Interface,
4791 const ObjCIvarDecl *Ivar) {
4792 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
4793 return llvm::ConstantInt::get(
4794 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
4795 Offset);
4796 }
4797
4798 /* *** Private Interface *** */
4799
GetSectionName(StringRef Section,StringRef MachOAttributes)4800 std::string CGObjCCommonMac::GetSectionName(StringRef Section,
4801 StringRef MachOAttributes) {
4802 switch (CGM.getTriple().getObjectFormat()) {
4803 default:
4804 llvm_unreachable("unexpected object file format");
4805 case llvm::Triple::MachO: {
4806 if (MachOAttributes.empty())
4807 return ("__DATA," + Section).str();
4808 return ("__DATA," + Section + "," + MachOAttributes).str();
4809 }
4810 case llvm::Triple::ELF:
4811 assert(Section.substr(0, 2) == "__" &&
4812 "expected the name to begin with __");
4813 return Section.substr(2).str();
4814 case llvm::Triple::COFF:
4815 assert(Section.substr(0, 2) == "__" &&
4816 "expected the name to begin with __");
4817 return ("." + Section.substr(2) + "$B").str();
4818 }
4819 }
4820
4821 /// EmitImageInfo - Emit the image info marker used to encode some module
4822 /// level information.
4823 ///
4824 /// See: <rdr://4810609&4810587&4810587>
4825 /// struct IMAGE_INFO {
4826 /// unsigned version;
4827 /// unsigned flags;
4828 /// };
4829 enum ImageInfoFlags {
4830 eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang.
4831 eImageInfo_GarbageCollected = (1 << 1),
4832 eImageInfo_GCOnly = (1 << 2),
4833 eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache.
4834
4835 // A flag indicating that the module has no instances of a @synthesize of a
4836 // superclass variable. <rdar://problem/6803242>
4837 eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
4838 eImageInfo_ImageIsSimulated = (1 << 5),
4839 eImageInfo_ClassProperties = (1 << 6)
4840 };
4841
EmitImageInfo()4842 void CGObjCCommonMac::EmitImageInfo() {
4843 unsigned version = 0; // Version is unused?
4844 std::string Section =
4845 (ObjCABI == 1)
4846 ? "__OBJC,__image_info,regular"
4847 : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");
4848
4849 // Generate module-level named metadata to convey this information to the
4850 // linker and code-gen.
4851 llvm::Module &Mod = CGM.getModule();
4852
4853 // Add the ObjC ABI version to the module flags.
4854 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
4855 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
4856 version);
4857 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
4858 llvm::MDString::get(VMContext, Section));
4859
4860 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
4861 // Non-GC overrides those files which specify GC.
4862 Mod.addModuleFlag(llvm::Module::Override,
4863 "Objective-C Garbage Collection", (uint32_t)0);
4864 } else {
4865 // Add the ObjC garbage collection value.
4866 Mod.addModuleFlag(llvm::Module::Error,
4867 "Objective-C Garbage Collection",
4868 eImageInfo_GarbageCollected);
4869
4870 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
4871 // Add the ObjC GC Only value.
4872 Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
4873 eImageInfo_GCOnly);
4874
4875 // Require that GC be specified and set to eImageInfo_GarbageCollected.
4876 llvm::Metadata *Ops[2] = {
4877 llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
4878 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
4879 llvm::Type::getInt32Ty(VMContext), eImageInfo_GarbageCollected))};
4880 Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
4881 llvm::MDNode::get(VMContext, Ops));
4882 }
4883 }
4884
4885 // Indicate whether we're compiling this to run on a simulator.
4886 if (CGM.getTarget().getTriple().isSimulatorEnvironment())
4887 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
4888 eImageInfo_ImageIsSimulated);
4889
4890 // Indicate whether we are generating class properties.
4891 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
4892 eImageInfo_ClassProperties);
4893 }
4894
4895 // struct objc_module {
4896 // unsigned long version;
4897 // unsigned long size;
4898 // const char *name;
4899 // Symtab symtab;
4900 // };
4901
4902 // FIXME: Get from somewhere
4903 static const int ModuleVersion = 7;
4904
EmitModuleInfo()4905 void CGObjCMac::EmitModuleInfo() {
4906 uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
4907
4908 ConstantInitBuilder builder(CGM);
4909 auto values = builder.beginStruct(ObjCTypes.ModuleTy);
4910 values.addInt(ObjCTypes.LongTy, ModuleVersion);
4911 values.addInt(ObjCTypes.LongTy, Size);
4912 // This used to be the filename, now it is unused. <rdr://4327263>
4913 values.add(GetClassName(StringRef("")));
4914 values.add(EmitModuleSymbols());
4915 CreateMetadataVar("OBJC_MODULES", values,
4916 "__OBJC,__module_info,regular,no_dead_strip",
4917 CGM.getPointerAlign(), true);
4918 }
4919
EmitModuleSymbols()4920 llvm::Constant *CGObjCMac::EmitModuleSymbols() {
4921 unsigned NumClasses = DefinedClasses.size();
4922 unsigned NumCategories = DefinedCategories.size();
4923
4924 // Return null if no symbols were defined.
4925 if (!NumClasses && !NumCategories)
4926 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
4927
4928 ConstantInitBuilder builder(CGM);
4929 auto values = builder.beginStruct();
4930 values.addInt(ObjCTypes.LongTy, 0);
4931 values.addNullPointer(ObjCTypes.SelectorPtrTy);
4932 values.addInt(ObjCTypes.ShortTy, NumClasses);
4933 values.addInt(ObjCTypes.ShortTy, NumCategories);
4934
4935 // The runtime expects exactly the list of defined classes followed
4936 // by the list of defined categories, in a single array.
4937 auto array = values.beginArray(ObjCTypes.Int8PtrTy);
4938 for (unsigned i=0; i<NumClasses; i++) {
4939 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
4940 assert(ID);
4941 if (ObjCImplementationDecl *IMP = ID->getImplementation())
4942 // We are implementing a weak imported interface. Give it external linkage
4943 if (ID->isWeakImported() && !IMP->isWeakImported())
4944 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
4945
4946 array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy);
4947 }
4948 for (unsigned i=0; i<NumCategories; i++)
4949 array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy);
4950
4951 array.finishAndAddTo(values);
4952
4953 llvm::GlobalVariable *GV = CreateMetadataVar(
4954 "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip",
4955 CGM.getPointerAlign(), true);
4956 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
4957 }
4958
EmitClassRefFromId(CodeGenFunction & CGF,IdentifierInfo * II)4959 llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
4960 IdentifierInfo *II) {
4961 LazySymbols.insert(II);
4962
4963 llvm::GlobalVariable *&Entry = ClassReferences[II];
4964
4965 if (!Entry) {
4966 llvm::Constant *Casted =
4967 llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
4968 ObjCTypes.ClassPtrTy);
4969 Entry = CreateMetadataVar(
4970 "OBJC_CLASS_REFERENCES_", Casted,
4971 "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
4972 CGM.getPointerAlign(), true);
4973 }
4974
4975 return CGF.Builder.CreateAlignedLoad(Entry, CGF.getPointerAlign());
4976 }
4977
EmitClassRef(CodeGenFunction & CGF,const ObjCInterfaceDecl * ID)4978 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
4979 const ObjCInterfaceDecl *ID) {
4980 // If the class has the objc_runtime_visible attribute, we need to
4981 // use the Objective-C runtime to get the class.
4982 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
4983 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
4984
4985 IdentifierInfo *RuntimeName =
4986 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
4987 return EmitClassRefFromId(CGF, RuntimeName);
4988 }
4989
EmitNSAutoreleasePoolClassRef(CodeGenFunction & CGF)4990 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
4991 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
4992 return EmitClassRefFromId(CGF, II);
4993 }
4994
EmitSelector(CodeGenFunction & CGF,Selector Sel)4995 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
4996 return CGF.Builder.CreateLoad(EmitSelectorAddr(CGF, Sel));
4997 }
4998
EmitSelectorAddr(CodeGenFunction & CGF,Selector Sel)4999 Address CGObjCMac::EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel) {
5000 CharUnits Align = CGF.getPointerAlign();
5001
5002 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
5003 if (!Entry) {
5004 llvm::Constant *Casted =
5005 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5006 ObjCTypes.SelectorPtrTy);
5007 Entry = CreateMetadataVar(
5008 "OBJC_SELECTOR_REFERENCES_", Casted,
5009 "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
5010 Entry->setExternallyInitialized(true);
5011 }
5012
5013 return Address(Entry, Align);
5014 }
5015
GetClassName(StringRef RuntimeName)5016 llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
5017 llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
5018 if (!Entry)
5019 Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
5020 return getConstantGEP(VMContext, Entry, 0, 0);
5021 }
5022
GetMethodDefinition(const ObjCMethodDecl * MD)5023 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
5024 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
5025 I = MethodDefinitions.find(MD);
5026 if (I != MethodDefinitions.end())
5027 return I->second;
5028
5029 return nullptr;
5030 }
5031
5032 /// GetIvarLayoutName - Returns a unique constant for the given
5033 /// ivar layout bitmap.
GetIvarLayoutName(IdentifierInfo * Ident,const ObjCCommonTypesHelper & ObjCTypes)5034 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
5035 const ObjCCommonTypesHelper &ObjCTypes) {
5036 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5037 }
5038
visitRecord(const RecordType * RT,CharUnits offset)5039 void IvarLayoutBuilder::visitRecord(const RecordType *RT,
5040 CharUnits offset) {
5041 const RecordDecl *RD = RT->getDecl();
5042
5043 // If this is a union, remember that we had one, because it might mess
5044 // up the ordering of layout entries.
5045 if (RD->isUnion())
5046 IsDisordered = true;
5047
5048 const ASTRecordLayout *recLayout = nullptr;
5049 visitAggregate(RD->field_begin(), RD->field_end(), offset,
5050 [&](const FieldDecl *field) -> CharUnits {
5051 if (!recLayout)
5052 recLayout = &CGM.getContext().getASTRecordLayout(RD);
5053 auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
5054 return CGM.getContext().toCharUnitsFromBits(offsetInBits);
5055 });
5056 }
5057
5058 template <class Iterator, class GetOffsetFn>
visitAggregate(Iterator begin,Iterator end,CharUnits aggregateOffset,const GetOffsetFn & getOffset)5059 void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
5060 CharUnits aggregateOffset,
5061 const GetOffsetFn &getOffset) {
5062 for (; begin != end; ++begin) {
5063 auto field = *begin;
5064
5065 // Skip over bitfields.
5066 if (field->isBitField()) {
5067 continue;
5068 }
5069
5070 // Compute the offset of the field within the aggregate.
5071 CharUnits fieldOffset = aggregateOffset + getOffset(field);
5072
5073 visitField(field, fieldOffset);
5074 }
5075 }
5076
5077 /// Collect layout information for the given fields into IvarsInfo.
visitField(const FieldDecl * field,CharUnits fieldOffset)5078 void IvarLayoutBuilder::visitField(const FieldDecl *field,
5079 CharUnits fieldOffset) {
5080 QualType fieldType = field->getType();
5081
5082 // Drill down into arrays.
5083 uint64_t numElts = 1;
5084 if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) {
5085 numElts = 0;
5086 fieldType = arrayType->getElementType();
5087 }
5088 // Unlike incomplete arrays, constant arrays can be nested.
5089 while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
5090 numElts *= arrayType->getSize().getZExtValue();
5091 fieldType = arrayType->getElementType();
5092 }
5093
5094 assert(!fieldType->isArrayType() && "ivar of non-constant array type?");
5095
5096 // If we ended up with a zero-sized array, we've done what we can do within
5097 // the limits of this layout encoding.
5098 if (numElts == 0) return;
5099
5100 // Recurse if the base element type is a record type.
5101 if (auto recType = fieldType->getAs<RecordType>()) {
5102 size_t oldEnd = IvarsInfo.size();
5103
5104 visitRecord(recType, fieldOffset);
5105
5106 // If we have an array, replicate the first entry's layout information.
5107 auto numEltEntries = IvarsInfo.size() - oldEnd;
5108 if (numElts != 1 && numEltEntries != 0) {
5109 CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5110 for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
5111 // Copy the last numEltEntries onto the end of the array, adjusting
5112 // each for the element size.
5113 for (size_t i = 0; i != numEltEntries; ++i) {
5114 auto firstEntry = IvarsInfo[oldEnd + i];
5115 IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
5116 firstEntry.SizeInWords));
5117 }
5118 }
5119 }
5120
5121 return;
5122 }
5123
5124 // Classify the element type.
5125 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
5126
5127 // If it matches what we're looking for, add an entry.
5128 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
5129 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
5130 assert(CGM.getContext().getTypeSizeInChars(fieldType)
5131 == CGM.getPointerSize());
5132 IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
5133 }
5134 }
5135
5136 /// buildBitmap - This routine does the horsework of taking the offsets of
5137 /// strong/weak references and creating a bitmap. The bitmap is also
5138 /// returned in the given buffer, suitable for being passed to \c dump().
buildBitmap(CGObjCCommonMac & CGObjC,llvm::SmallVectorImpl<unsigned char> & buffer)5139 llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
5140 llvm::SmallVectorImpl<unsigned char> &buffer) {
5141 // The bitmap is a series of skip/scan instructions, aligned to word
5142 // boundaries. The skip is performed first.
5143 const unsigned char MaxNibble = 0xF;
5144 const unsigned char SkipMask = 0xF0, SkipShift = 4;
5145 const unsigned char ScanMask = 0x0F, ScanShift = 0;
5146
5147 assert(!IvarsInfo.empty() && "generating bitmap for no data");
5148
5149 // Sort the ivar info on byte position in case we encounterred a
5150 // union nested in the ivar list.
5151 if (IsDisordered) {
5152 // This isn't a stable sort, but our algorithm should handle it fine.
5153 llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
5154 } else {
5155 assert(std::is_sorted(IvarsInfo.begin(), IvarsInfo.end()));
5156 }
5157 assert(IvarsInfo.back().Offset < InstanceEnd);
5158
5159 assert(buffer.empty());
5160
5161 // Skip the next N words.
5162 auto skip = [&](unsigned numWords) {
5163 assert(numWords > 0);
5164
5165 // Try to merge into the previous byte. Since scans happen second, we
5166 // can't do this if it includes a scan.
5167 if (!buffer.empty() && !(buffer.back() & ScanMask)) {
5168 unsigned lastSkip = buffer.back() >> SkipShift;
5169 if (lastSkip < MaxNibble) {
5170 unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
5171 numWords -= claimed;
5172 lastSkip += claimed;
5173 buffer.back() = (lastSkip << SkipShift);
5174 }
5175 }
5176
5177 while (numWords >= MaxNibble) {
5178 buffer.push_back(MaxNibble << SkipShift);
5179 numWords -= MaxNibble;
5180 }
5181 if (numWords) {
5182 buffer.push_back(numWords << SkipShift);
5183 }
5184 };
5185
5186 // Scan the next N words.
5187 auto scan = [&](unsigned numWords) {
5188 assert(numWords > 0);
5189
5190 // Try to merge into the previous byte. Since scans happen second, we can
5191 // do this even if it includes a skip.
5192 if (!buffer.empty()) {
5193 unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
5194 if (lastScan < MaxNibble) {
5195 unsigned claimed = std::min(MaxNibble - lastScan, numWords);
5196 numWords -= claimed;
5197 lastScan += claimed;
5198 buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
5199 }
5200 }
5201
5202 while (numWords >= MaxNibble) {
5203 buffer.push_back(MaxNibble << ScanShift);
5204 numWords -= MaxNibble;
5205 }
5206 if (numWords) {
5207 buffer.push_back(numWords << ScanShift);
5208 }
5209 };
5210
5211 // One past the end of the last scan.
5212 unsigned endOfLastScanInWords = 0;
5213 const CharUnits WordSize = CGM.getPointerSize();
5214
5215 // Consider all the scan requests.
5216 for (auto &request : IvarsInfo) {
5217 CharUnits beginOfScan = request.Offset - InstanceBegin;
5218
5219 // Ignore scan requests that don't start at an even multiple of the
5220 // word size. We can't encode them.
5221 if ((beginOfScan % WordSize) != 0) continue;
5222
5223 // Ignore scan requests that start before the instance start.
5224 // This assumes that scans never span that boundary. The boundary
5225 // isn't the true start of the ivars, because in the fragile-ARC case
5226 // it's rounded up to word alignment, but the test above should leave
5227 // us ignoring that possibility.
5228 if (beginOfScan.isNegative()) {
5229 assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin);
5230 continue;
5231 }
5232
5233 unsigned beginOfScanInWords = beginOfScan / WordSize;
5234 unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
5235
5236 // If the scan starts some number of words after the last one ended,
5237 // skip forward.
5238 if (beginOfScanInWords > endOfLastScanInWords) {
5239 skip(beginOfScanInWords - endOfLastScanInWords);
5240
5241 // Otherwise, start scanning where the last left off.
5242 } else {
5243 beginOfScanInWords = endOfLastScanInWords;
5244
5245 // If that leaves us with nothing to scan, ignore this request.
5246 if (beginOfScanInWords >= endOfScanInWords) continue;
5247 }
5248
5249 // Scan to the end of the request.
5250 assert(beginOfScanInWords < endOfScanInWords);
5251 scan(endOfScanInWords - beginOfScanInWords);
5252 endOfLastScanInWords = endOfScanInWords;
5253 }
5254
5255 if (buffer.empty())
5256 return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
5257
5258 // For GC layouts, emit a skip to the end of the allocation so that we
5259 // have precise information about the entire thing. This isn't useful
5260 // or necessary for the ARC-style layout strings.
5261 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5262 unsigned lastOffsetInWords =
5263 (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5264 if (lastOffsetInWords > endOfLastScanInWords) {
5265 skip(lastOffsetInWords - endOfLastScanInWords);
5266 }
5267 }
5268
5269 // Null terminate the string.
5270 buffer.push_back(0);
5271
5272 auto *Entry = CGObjC.CreateCStringLiteral(
5273 reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
5274 return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5275 }
5276
5277 /// BuildIvarLayout - Builds ivar layout bitmap for the class
5278 /// implementation for the __strong or __weak case.
5279 /// The layout map displays which words in ivar list must be skipped
5280 /// and which must be scanned by GC (see below). String is built of bytes.
5281 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5282 /// of words to skip and right nibble is count of words to scan. So, each
5283 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5284 /// represented by a 0x00 byte which also ends the string.
5285 /// 1. when ForStrongLayout is true, following ivars are scanned:
5286 /// - id, Class
5287 /// - object *
5288 /// - __strong anything
5289 ///
5290 /// 2. When ForStrongLayout is false, following ivars are scanned:
5291 /// - __weak anything
5292 ///
5293 llvm::Constant *
BuildIvarLayout(const ObjCImplementationDecl * OMD,CharUnits beginOffset,CharUnits endOffset,bool ForStrongLayout,bool HasMRCWeakIvars)5294 CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
5295 CharUnits beginOffset, CharUnits endOffset,
5296 bool ForStrongLayout, bool HasMRCWeakIvars) {
5297 // If this is MRC, and we're either building a strong layout or there
5298 // are no weak ivars, bail out early.
5299 llvm::Type *PtrTy = CGM.Int8PtrTy;
5300 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5301 !CGM.getLangOpts().ObjCAutoRefCount &&
5302 (ForStrongLayout || !HasMRCWeakIvars))
5303 return llvm::Constant::getNullValue(PtrTy);
5304
5305 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5306 SmallVector<const ObjCIvarDecl*, 32> ivars;
5307
5308 // GC layout strings include the complete object layout, possibly
5309 // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5310 // up.
5311 //
5312 // ARC layout strings only include the class's ivars. In non-fragile
5313 // runtimes, that means starting at InstanceStart, rounded up to word
5314 // alignment. In fragile runtimes, there's no InstanceStart, so it means
5315 // starting at the offset of the first ivar, rounded up to word alignment.
5316 //
5317 // MRC weak layout strings follow the ARC style.
5318 CharUnits baseOffset;
5319 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5320 for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5321 IVD; IVD = IVD->getNextIvar())
5322 ivars.push_back(IVD);
5323
5324 if (isNonFragileABI()) {
5325 baseOffset = beginOffset; // InstanceStart
5326 } else if (!ivars.empty()) {
5327 baseOffset =
5328 CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5329 } else {
5330 baseOffset = CharUnits::Zero();
5331 }
5332
5333 baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5334 }
5335 else {
5336 CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5337
5338 baseOffset = CharUnits::Zero();
5339 }
5340
5341 if (ivars.empty())
5342 return llvm::Constant::getNullValue(PtrTy);
5343
5344 IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5345
5346 builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5347 [&](const ObjCIvarDecl *ivar) -> CharUnits {
5348 return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5349 });
5350
5351 if (!builder.hasBitmapData())
5352 return llvm::Constant::getNullValue(PtrTy);
5353
5354 llvm::SmallVector<unsigned char, 4> buffer;
5355 llvm::Constant *C = builder.buildBitmap(*this, buffer);
5356
5357 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5358 printf("\n%s ivar layout for class '%s': ",
5359 ForStrongLayout ? "strong" : "weak",
5360 OMD->getClassInterface()->getName().str().c_str());
5361 builder.dump(buffer);
5362 }
5363 return C;
5364 }
5365
GetMethodVarName(Selector Sel)5366 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5367 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5368 // FIXME: Avoid std::string in "Sel.getAsString()"
5369 if (!Entry)
5370 Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
5371 return getConstantGEP(VMContext, Entry, 0, 0);
5372 }
5373
5374 // FIXME: Merge into a single cstring creation function.
GetMethodVarName(IdentifierInfo * ID)5375 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5376 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5377 }
5378
GetMethodVarType(const FieldDecl * Field)5379 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5380 std::string TypeStr;
5381 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5382
5383 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5384 if (!Entry)
5385 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5386 return getConstantGEP(VMContext, Entry, 0, 0);
5387 }
5388
GetMethodVarType(const ObjCMethodDecl * D,bool Extended)5389 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5390 bool Extended) {
5391 std::string TypeStr =
5392 CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);
5393
5394 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5395 if (!Entry)
5396 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5397 return getConstantGEP(VMContext, Entry, 0, 0);
5398 }
5399
5400 // FIXME: Merge into a single cstring creation function.
GetPropertyName(IdentifierInfo * Ident)5401 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5402 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5403 if (!Entry)
5404 Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
5405 return getConstantGEP(VMContext, Entry, 0, 0);
5406 }
5407
5408 // FIXME: Merge into a single cstring creation function.
5409 // FIXME: This Decl should be more precise.
5410 llvm::Constant *
GetPropertyTypeString(const ObjCPropertyDecl * PD,const Decl * Container)5411 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5412 const Decl *Container) {
5413 std::string TypeStr =
5414 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
5415 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5416 }
5417
GetNameForMethod(const ObjCMethodDecl * D,const ObjCContainerDecl * CD,SmallVectorImpl<char> & Name)5418 void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
5419 const ObjCContainerDecl *CD,
5420 SmallVectorImpl<char> &Name) {
5421 llvm::raw_svector_ostream OS(Name);
5422 assert (CD && "Missing container decl in GetNameForMethod");
5423 OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
5424 << '[' << CD->getName();
5425 if (const ObjCCategoryImplDecl *CID =
5426 dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
5427 OS << '(' << *CID << ')';
5428 OS << ' ' << D->getSelector().getAsString() << ']';
5429 }
5430
FinishModule()5431 void CGObjCMac::FinishModule() {
5432 EmitModuleInfo();
5433
5434 // Emit the dummy bodies for any protocols which were referenced but
5435 // never defined.
5436 for (auto &entry : Protocols) {
5437 llvm::GlobalVariable *global = entry.second;
5438 if (global->hasInitializer())
5439 continue;
5440
5441 ConstantInitBuilder builder(CGM);
5442 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
5443 values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
5444 values.add(GetClassName(entry.first->getName()));
5445 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
5446 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5447 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5448 values.finishAndSetAsInitializer(global);
5449 CGM.addCompilerUsedGlobal(global);
5450 }
5451
5452 // Add assembler directives to add lazy undefined symbol references
5453 // for classes which are referenced but not defined. This is
5454 // important for correct linker interaction.
5455 //
5456 // FIXME: It would be nice if we had an LLVM construct for this.
5457 if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
5458 CGM.getTriple().isOSBinFormatMachO()) {
5459 SmallString<256> Asm;
5460 Asm += CGM.getModule().getModuleInlineAsm();
5461 if (!Asm.empty() && Asm.back() != '\n')
5462 Asm += '\n';
5463
5464 llvm::raw_svector_ostream OS(Asm);
5465 for (const auto *Sym : DefinedSymbols)
5466 OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
5467 << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
5468 for (const auto *Sym : LazySymbols)
5469 OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
5470 for (const auto &Category : DefinedCategoryNames)
5471 OS << "\t.objc_category_name_" << Category << "=0\n"
5472 << "\t.globl .objc_category_name_" << Category << "\n";
5473
5474 CGM.getModule().setModuleInlineAsm(OS.str());
5475 }
5476 }
5477
CGObjCNonFragileABIMac(CodeGen::CodeGenModule & cgm)5478 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5479 : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
5480 ObjCEmptyVtableVar(nullptr) {
5481 ObjCABI = 2;
5482 }
5483
5484 /* *** */
5485
ObjCCommonTypesHelper(CodeGen::CodeGenModule & cgm)5486 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5487 : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5488 {
5489 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5490 ASTContext &Ctx = CGM.getContext();
5491
5492 ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
5493 IntTy = CGM.IntTy;
5494 LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
5495 Int8PtrTy = CGM.Int8PtrTy;
5496 Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5497
5498 // arm64 targets use "int" ivar offset variables. All others,
5499 // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5500 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5501 IvarOffsetVarTy = IntTy;
5502 else
5503 IvarOffsetVarTy = LongTy;
5504
5505 ObjectPtrTy =
5506 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
5507 PtrObjectPtrTy =
5508 llvm::PointerType::getUnqual(ObjectPtrTy);
5509 SelectorPtrTy =
5510 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
5511
5512 // I'm not sure I like this. The implicit coordination is a bit
5513 // gross. We should solve this in a reasonable fashion because this
5514 // is a pretty common task (match some runtime data structure with
5515 // an LLVM data structure).
5516
5517 // FIXME: This is leaked.
5518 // FIXME: Merge with rewriter code?
5519
5520 // struct _objc_super {
5521 // id self;
5522 // Class cls;
5523 // }
5524 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5525 Ctx.getTranslationUnitDecl(),
5526 SourceLocation(), SourceLocation(),
5527 &Ctx.Idents.get("_objc_super"));
5528 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5529 nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5530 false, ICIS_NoInit));
5531 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5532 nullptr, Ctx.getObjCClassType(), nullptr,
5533 nullptr, false, ICIS_NoInit));
5534 RD->completeDefinition();
5535
5536 SuperCTy = Ctx.getTagDeclType(RD);
5537 SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5538
5539 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5540 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5541
5542 // struct _prop_t {
5543 // char *name;
5544 // char *attributes;
5545 // }
5546 PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy);
5547
5548 // struct _prop_list_t {
5549 // uint32_t entsize; // sizeof(struct _prop_t)
5550 // uint32_t count_of_properties;
5551 // struct _prop_t prop_list[count_of_properties];
5552 // }
5553 PropertyListTy = llvm::StructType::create(
5554 "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0));
5555 // struct _prop_list_t *
5556 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5557
5558 // struct _objc_method {
5559 // SEL _cmd;
5560 // char *method_type;
5561 // char *_imp;
5562 // }
5563 MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy,
5564 Int8PtrTy, Int8PtrTy);
5565
5566 // struct _objc_cache *
5567 CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5568 CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5569 }
5570
ObjCTypesHelper(CodeGen::CodeGenModule & cgm)5571 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5572 : ObjCCommonTypesHelper(cgm) {
5573 // struct _objc_method_description {
5574 // SEL name;
5575 // char *types;
5576 // }
5577 MethodDescriptionTy = llvm::StructType::create(
5578 "struct._objc_method_description", SelectorPtrTy, Int8PtrTy);
5579
5580 // struct _objc_method_description_list {
5581 // int count;
5582 // struct _objc_method_description[1];
5583 // }
5584 MethodDescriptionListTy =
5585 llvm::StructType::create("struct._objc_method_description_list", IntTy,
5586 llvm::ArrayType::get(MethodDescriptionTy, 0));
5587
5588 // struct _objc_method_description_list *
5589 MethodDescriptionListPtrTy =
5590 llvm::PointerType::getUnqual(MethodDescriptionListTy);
5591
5592 // Protocol description structures
5593
5594 // struct _objc_protocol_extension {
5595 // uint32_t size; // sizeof(struct _objc_protocol_extension)
5596 // struct _objc_method_description_list *optional_instance_methods;
5597 // struct _objc_method_description_list *optional_class_methods;
5598 // struct _objc_property_list *instance_properties;
5599 // const char ** extendedMethodTypes;
5600 // struct _objc_property_list *class_properties;
5601 // }
5602 ProtocolExtensionTy = llvm::StructType::create(
5603 "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy,
5604 MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy,
5605 PropertyListPtrTy);
5606
5607 // struct _objc_protocol_extension *
5608 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5609
5610 // Handle recursive construction of Protocol and ProtocolList types
5611
5612 ProtocolTy =
5613 llvm::StructType::create(VMContext, "struct._objc_protocol");
5614
5615 ProtocolListTy =
5616 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5617 ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy,
5618 llvm::ArrayType::get(ProtocolTy, 0));
5619
5620 // struct _objc_protocol {
5621 // struct _objc_protocol_extension *isa;
5622 // char *protocol_name;
5623 // struct _objc_protocol **_objc_protocol_list;
5624 // struct _objc_method_description_list *instance_methods;
5625 // struct _objc_method_description_list *class_methods;
5626 // }
5627 ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5628 llvm::PointerType::getUnqual(ProtocolListTy),
5629 MethodDescriptionListPtrTy, MethodDescriptionListPtrTy);
5630
5631 // struct _objc_protocol_list *
5632 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5633
5634 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5635
5636 // Class description structures
5637
5638 // struct _objc_ivar {
5639 // char *ivar_name;
5640 // char *ivar_type;
5641 // int ivar_offset;
5642 // }
5643 IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy,
5644 IntTy);
5645
5646 // struct _objc_ivar_list *
5647 IvarListTy =
5648 llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5649 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5650
5651 // struct _objc_method_list *
5652 MethodListTy =
5653 llvm::StructType::create(VMContext, "struct._objc_method_list");
5654 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5655
5656 // struct _objc_class_extension *
5657 ClassExtensionTy = llvm::StructType::create(
5658 "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy);
5659 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5660
5661 ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5662
5663 // struct _objc_class {
5664 // Class isa;
5665 // Class super_class;
5666 // char *name;
5667 // long version;
5668 // long info;
5669 // long instance_size;
5670 // struct _objc_ivar_list *ivars;
5671 // struct _objc_method_list *methods;
5672 // struct _objc_cache *cache;
5673 // struct _objc_protocol_list *protocols;
5674 // char *ivar_layout;
5675 // struct _objc_class_ext *ext;
5676 // };
5677 ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5678 llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy,
5679 LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy,
5680 ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy);
5681
5682 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5683
5684 // struct _objc_category {
5685 // char *category_name;
5686 // char *class_name;
5687 // struct _objc_method_list *instance_method;
5688 // struct _objc_method_list *class_method;
5689 // struct _objc_protocol_list *protocols;
5690 // uint32_t size; // sizeof(struct _objc_category)
5691 // struct _objc_property_list *instance_properties;// category's @property
5692 // struct _objc_property_list *class_properties;
5693 // }
5694 CategoryTy = llvm::StructType::create(
5695 "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5696 MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy,
5697 PropertyListPtrTy);
5698
5699 // Global metadata structures
5700
5701 // struct _objc_symtab {
5702 // long sel_ref_cnt;
5703 // SEL *refs;
5704 // short cls_def_cnt;
5705 // short cat_def_cnt;
5706 // char *defs[cls_def_cnt + cat_def_cnt];
5707 // }
5708 SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy,
5709 SelectorPtrTy, ShortTy, ShortTy,
5710 llvm::ArrayType::get(Int8PtrTy, 0));
5711 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
5712
5713 // struct _objc_module {
5714 // long version;
5715 // long size; // sizeof(struct _objc_module)
5716 // char *name;
5717 // struct _objc_symtab* symtab;
5718 // }
5719 ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy,
5720 Int8PtrTy, SymtabPtrTy);
5721
5722 // FIXME: This is the size of the setjmp buffer and should be target
5723 // specific. 18 is what's used on 32-bit X86.
5724 uint64_t SetJmpBufferSize = 18;
5725
5726 // Exceptions
5727 llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
5728
5729 ExceptionDataTy = llvm::StructType::create(
5730 "struct._objc_exception_data",
5731 llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy);
5732 }
5733
ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule & cgm)5734 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
5735 : ObjCCommonTypesHelper(cgm) {
5736 // struct _method_list_t {
5737 // uint32_t entsize; // sizeof(struct _objc_method)
5738 // uint32_t method_count;
5739 // struct _objc_method method_list[method_count];
5740 // }
5741 MethodListnfABITy =
5742 llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
5743 llvm::ArrayType::get(MethodTy, 0));
5744 // struct method_list_t *
5745 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
5746
5747 // struct _protocol_t {
5748 // id isa; // NULL
5749 // const char * const protocol_name;
5750 // const struct _protocol_list_t * protocol_list; // super protocols
5751 // const struct method_list_t * const instance_methods;
5752 // const struct method_list_t * const class_methods;
5753 // const struct method_list_t *optionalInstanceMethods;
5754 // const struct method_list_t *optionalClassMethods;
5755 // const struct _prop_list_t * properties;
5756 // const uint32_t size; // sizeof(struct _protocol_t)
5757 // const uint32_t flags; // = 0
5758 // const char ** extendedMethodTypes;
5759 // const char *demangledName;
5760 // const struct _prop_list_t * class_properties;
5761 // }
5762
5763 // Holder for struct _protocol_list_t *
5764 ProtocolListnfABITy =
5765 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5766
5767 ProtocolnfABITy = llvm::StructType::create(
5768 "struct._protocol_t", ObjectPtrTy, Int8PtrTy,
5769 llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy,
5770 MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5771 PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy,
5772 PropertyListPtrTy);
5773
5774 // struct _protocol_t*
5775 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
5776
5777 // struct _protocol_list_t {
5778 // long protocol_count; // Note, this is 32/64 bit
5779 // struct _protocol_t *[protocol_count];
5780 // }
5781 ProtocolListnfABITy->setBody(LongTy,
5782 llvm::ArrayType::get(ProtocolnfABIPtrTy, 0));
5783
5784 // struct _objc_protocol_list*
5785 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
5786
5787 // struct _ivar_t {
5788 // unsigned [long] int *offset; // pointer to ivar offset location
5789 // char *name;
5790 // char *type;
5791 // uint32_t alignment;
5792 // uint32_t size;
5793 // }
5794 IvarnfABITy = llvm::StructType::create(
5795 "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
5796 Int8PtrTy, Int8PtrTy, IntTy, IntTy);
5797
5798 // struct _ivar_list_t {
5799 // uint32 entsize; // sizeof(struct _ivar_t)
5800 // uint32 count;
5801 // struct _iver_t list[count];
5802 // }
5803 IvarListnfABITy =
5804 llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
5805 llvm::ArrayType::get(IvarnfABITy, 0));
5806
5807 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
5808
5809 // struct _class_ro_t {
5810 // uint32_t const flags;
5811 // uint32_t const instanceStart;
5812 // uint32_t const instanceSize;
5813 // uint32_t const reserved; // only when building for 64bit targets
5814 // const uint8_t * const ivarLayout;
5815 // const char *const name;
5816 // const struct _method_list_t * const baseMethods;
5817 // const struct _objc_protocol_list *const baseProtocols;
5818 // const struct _ivar_list_t *const ivars;
5819 // const uint8_t * const weakIvarLayout;
5820 // const struct _prop_list_t * const properties;
5821 // }
5822
5823 // FIXME. Add 'reserved' field in 64bit abi mode!
5824 ClassRonfABITy = llvm::StructType::create(
5825 "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy,
5826 MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy,
5827 Int8PtrTy, PropertyListPtrTy);
5828
5829 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
5830 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
5831 ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
5832 ->getPointerTo();
5833
5834 // struct _class_t {
5835 // struct _class_t *isa;
5836 // struct _class_t * const superclass;
5837 // void *cache;
5838 // IMP *vtable;
5839 // struct class_ro_t *ro;
5840 // }
5841
5842 ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
5843 ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
5844 llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy,
5845 llvm::PointerType::getUnqual(ImpnfABITy),
5846 llvm::PointerType::getUnqual(ClassRonfABITy));
5847
5848 // LLVM for struct _class_t *
5849 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
5850
5851 // struct _category_t {
5852 // const char * const name;
5853 // struct _class_t *const cls;
5854 // const struct _method_list_t * const instance_methods;
5855 // const struct _method_list_t * const class_methods;
5856 // const struct _protocol_list_t * const protocols;
5857 // const struct _prop_list_t * const properties;
5858 // const struct _prop_list_t * const class_properties;
5859 // const uint32_t size;
5860 // }
5861 CategorynfABITy = llvm::StructType::create(
5862 "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy,
5863 MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy,
5864 PropertyListPtrTy, IntTy);
5865
5866 // New types for nonfragile abi messaging.
5867 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5868 ASTContext &Ctx = CGM.getContext();
5869
5870 // MessageRefTy - LLVM for:
5871 // struct _message_ref_t {
5872 // IMP messenger;
5873 // SEL name;
5874 // };
5875
5876 // First the clang type for struct _message_ref_t
5877 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5878 Ctx.getTranslationUnitDecl(),
5879 SourceLocation(), SourceLocation(),
5880 &Ctx.Idents.get("_message_ref_t"));
5881 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5882 nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
5883 ICIS_NoInit));
5884 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5885 nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
5886 false, ICIS_NoInit));
5887 RD->completeDefinition();
5888
5889 MessageRefCTy = Ctx.getTagDeclType(RD);
5890 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
5891 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
5892
5893 // MessageRefPtrTy - LLVM for struct _message_ref_t*
5894 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
5895
5896 // SuperMessageRefTy - LLVM for:
5897 // struct _super_message_ref_t {
5898 // SUPER_IMP messenger;
5899 // SEL name;
5900 // };
5901 SuperMessageRefTy = llvm::StructType::create("struct._super_message_ref_t",
5902 ImpnfABITy, SelectorPtrTy);
5903
5904 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
5905 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
5906
5907
5908 // struct objc_typeinfo {
5909 // const void** vtable; // objc_ehtype_vtable + 2
5910 // const char* name; // c++ typeinfo string
5911 // Class cls;
5912 // };
5913 EHTypeTy = llvm::StructType::create("struct._objc_typeinfo",
5914 llvm::PointerType::getUnqual(Int8PtrTy),
5915 Int8PtrTy, ClassnfABIPtrTy);
5916 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
5917 }
5918
ModuleInitFunction()5919 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
5920 FinishNonFragileABIModule();
5921
5922 return nullptr;
5923 }
5924
AddModuleClassList(ArrayRef<llvm::GlobalValue * > Container,StringRef SymbolName,StringRef SectionName)5925 void CGObjCNonFragileABIMac::AddModuleClassList(
5926 ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName,
5927 StringRef SectionName) {
5928 unsigned NumClasses = Container.size();
5929
5930 if (!NumClasses)
5931 return;
5932
5933 SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
5934 for (unsigned i=0; i<NumClasses; i++)
5935 Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
5936 ObjCTypes.Int8PtrTy);
5937 llvm::Constant *Init =
5938 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
5939 Symbols.size()),
5940 Symbols);
5941
5942 llvm::GlobalVariable *GV =
5943 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
5944 llvm::GlobalValue::PrivateLinkage,
5945 Init,
5946 SymbolName);
5947 GV->setAlignment(CGM.getDataLayout().getABITypeAlignment(Init->getType()));
5948 GV->setSection(SectionName);
5949 CGM.addCompilerUsedGlobal(GV);
5950 }
5951
FinishNonFragileABIModule()5952 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
5953 // nonfragile abi has no module definition.
5954
5955 // Build list of all implemented class addresses in array
5956 // L_OBJC_LABEL_CLASS_$.
5957
5958 for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
5959 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
5960 assert(ID);
5961 if (ObjCImplementationDecl *IMP = ID->getImplementation())
5962 // We are implementing a weak imported interface. Give it external linkage
5963 if (ID->isWeakImported() && !IMP->isWeakImported()) {
5964 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5965 DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5966 }
5967 }
5968
5969 AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
5970 GetSectionName("__objc_classlist",
5971 "regular,no_dead_strip"));
5972
5973 AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$",
5974 GetSectionName("__objc_nlclslist",
5975 "regular,no_dead_strip"));
5976
5977 // Build list of all implemented category addresses in array
5978 // L_OBJC_LABEL_CATEGORY_$.
5979 AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$",
5980 GetSectionName("__objc_catlist",
5981 "regular,no_dead_strip"));
5982 AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$",
5983 GetSectionName("__objc_nlcatlist",
5984 "regular,no_dead_strip"));
5985
5986 EmitImageInfo();
5987 }
5988
5989 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of
5990 /// VTableDispatchMethods; false otherwise. What this means is that
5991 /// except for the 19 selectors in the list, we generate 32bit-style
5992 /// message dispatch call for all the rest.
isVTableDispatchedSelector(Selector Sel)5993 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
5994 // At various points we've experimented with using vtable-based
5995 // dispatch for all methods.
5996 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
5997 case CodeGenOptions::Legacy:
5998 return false;
5999 case CodeGenOptions::NonLegacy:
6000 return true;
6001 case CodeGenOptions::Mixed:
6002 break;
6003 }
6004
6005 // If so, see whether this selector is in the white-list of things which must
6006 // use the new dispatch convention. We lazily build a dense set for this.
6007 if (VTableDispatchMethods.empty()) {
6008 VTableDispatchMethods.insert(GetNullarySelector("alloc"));
6009 VTableDispatchMethods.insert(GetNullarySelector("class"));
6010 VTableDispatchMethods.insert(GetNullarySelector("self"));
6011 VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
6012 VTableDispatchMethods.insert(GetNullarySelector("length"));
6013 VTableDispatchMethods.insert(GetNullarySelector("count"));
6014
6015 // These are vtable-based if GC is disabled.
6016 // Optimistically use vtable dispatch for hybrid compiles.
6017 if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
6018 VTableDispatchMethods.insert(GetNullarySelector("retain"));
6019 VTableDispatchMethods.insert(GetNullarySelector("release"));
6020 VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
6021 }
6022
6023 VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
6024 VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
6025 VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
6026 VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
6027 VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
6028 VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
6029 VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
6030
6031 // These are vtable-based if GC is enabled.
6032 // Optimistically use vtable dispatch for hybrid compiles.
6033 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
6034 VTableDispatchMethods.insert(GetNullarySelector("hash"));
6035 VTableDispatchMethods.insert(GetUnarySelector("addObject"));
6036
6037 // "countByEnumeratingWithState:objects:count"
6038 IdentifierInfo *KeyIdents[] = {
6039 &CGM.getContext().Idents.get("countByEnumeratingWithState"),
6040 &CGM.getContext().Idents.get("objects"),
6041 &CGM.getContext().Idents.get("count")
6042 };
6043 VTableDispatchMethods.insert(
6044 CGM.getContext().Selectors.getSelector(3, KeyIdents));
6045 }
6046 }
6047
6048 return VTableDispatchMethods.count(Sel);
6049 }
6050
6051 /// BuildClassRoTInitializer - generate meta-data for:
6052 /// struct _class_ro_t {
6053 /// uint32_t const flags;
6054 /// uint32_t const instanceStart;
6055 /// uint32_t const instanceSize;
6056 /// uint32_t const reserved; // only when building for 64bit targets
6057 /// const uint8_t * const ivarLayout;
6058 /// const char *const name;
6059 /// const struct _method_list_t * const baseMethods;
6060 /// const struct _protocol_list_t *const baseProtocols;
6061 /// const struct _ivar_list_t *const ivars;
6062 /// const uint8_t * const weakIvarLayout;
6063 /// const struct _prop_list_t * const properties;
6064 /// }
6065 ///
BuildClassRoTInitializer(unsigned flags,unsigned InstanceStart,unsigned InstanceSize,const ObjCImplementationDecl * ID)6066 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
6067 unsigned flags,
6068 unsigned InstanceStart,
6069 unsigned InstanceSize,
6070 const ObjCImplementationDecl *ID) {
6071 std::string ClassName = ID->getObjCRuntimeNameAsString();
6072
6073 CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
6074 CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
6075
6076 bool hasMRCWeak = false;
6077 if (CGM.getLangOpts().ObjCAutoRefCount)
6078 flags |= NonFragileABI_Class_CompiledByARC;
6079 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
6080 flags |= NonFragileABI_Class_HasMRCWeakIvars;
6081
6082 ConstantInitBuilder builder(CGM);
6083 auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy);
6084
6085 values.addInt(ObjCTypes.IntTy, flags);
6086 values.addInt(ObjCTypes.IntTy, InstanceStart);
6087 values.addInt(ObjCTypes.IntTy, InstanceSize);
6088 values.add((flags & NonFragileABI_Class_Meta)
6089 ? GetIvarLayoutName(nullptr, ObjCTypes)
6090 : BuildStrongIvarLayout(ID, beginInstance, endInstance));
6091 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
6092
6093 // const struct _method_list_t * const baseMethods;
6094 SmallVector<const ObjCMethodDecl*, 16> methods;
6095 if (flags & NonFragileABI_Class_Meta) {
6096 for (const auto *MD : ID->class_methods())
6097 methods.push_back(MD);
6098 } else {
6099 for (const auto *MD : ID->instance_methods())
6100 methods.push_back(MD);
6101
6102 for (const auto *PID : ID->property_impls()) {
6103 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
6104 ObjCPropertyDecl *PD = PID->getPropertyDecl();
6105
6106 if (auto MD = PD->getGetterMethodDecl())
6107 if (GetMethodDefinition(MD))
6108 methods.push_back(MD);
6109 if (auto MD = PD->getSetterMethodDecl())
6110 if (GetMethodDefinition(MD))
6111 methods.push_back(MD);
6112 }
6113 }
6114 }
6115
6116 values.add(emitMethodList(ID->getObjCRuntimeNameAsString(),
6117 (flags & NonFragileABI_Class_Meta)
6118 ? MethodListType::ClassMethods
6119 : MethodListType::InstanceMethods,
6120 methods));
6121
6122 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6123 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
6124 values.add(EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_"
6125 + OID->getObjCRuntimeNameAsString(),
6126 OID->all_referenced_protocol_begin(),
6127 OID->all_referenced_protocol_end()));
6128
6129 if (flags & NonFragileABI_Class_Meta) {
6130 values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy);
6131 values.add(GetIvarLayoutName(nullptr, ObjCTypes));
6132 values.add(EmitPropertyList(
6133 "\01l_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6134 ID, ID->getClassInterface(), ObjCTypes, true));
6135 } else {
6136 values.add(EmitIvarList(ID));
6137 values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak));
6138 values.add(EmitPropertyList(
6139 "\01l_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6140 ID, ID->getClassInterface(), ObjCTypes, false));
6141 }
6142
6143 llvm::SmallString<64> roLabel;
6144 llvm::raw_svector_ostream(roLabel)
6145 << ((flags & NonFragileABI_Class_Meta) ? "\01l_OBJC_METACLASS_RO_$_"
6146 : "\01l_OBJC_CLASS_RO_$_")
6147 << ClassName;
6148
6149 llvm::GlobalVariable *CLASS_RO_GV =
6150 values.finishAndCreateGlobal(roLabel, CGM.getPointerAlign(),
6151 /*constant*/ false,
6152 llvm::GlobalValue::PrivateLinkage);
6153 if (CGM.getTriple().isOSBinFormatMachO())
6154 CLASS_RO_GV->setSection("__DATA, __objc_const");
6155 return CLASS_RO_GV;
6156 }
6157
6158 /// Build the metaclass object for a class.
6159 ///
6160 /// struct _class_t {
6161 /// struct _class_t *isa;
6162 /// struct _class_t * const superclass;
6163 /// void *cache;
6164 /// IMP *vtable;
6165 /// struct class_ro_t *ro;
6166 /// }
6167 ///
6168 llvm::GlobalVariable *
BuildClassObject(const ObjCInterfaceDecl * CI,bool isMetaclass,llvm::Constant * IsAGV,llvm::Constant * SuperClassGV,llvm::Constant * ClassRoGV,bool HiddenVisibility)6169 CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI,
6170 bool isMetaclass,
6171 llvm::Constant *IsAGV,
6172 llvm::Constant *SuperClassGV,
6173 llvm::Constant *ClassRoGV,
6174 bool HiddenVisibility) {
6175 ConstantInitBuilder builder(CGM);
6176 auto values = builder.beginStruct(ObjCTypes.ClassnfABITy);
6177 values.add(IsAGV);
6178 if (SuperClassGV) {
6179 values.add(SuperClassGV);
6180 } else {
6181 values.addNullPointer(ObjCTypes.ClassnfABIPtrTy);
6182 }
6183 values.add(ObjCEmptyCacheVar);
6184 values.add(ObjCEmptyVtableVar);
6185 values.add(ClassRoGV);
6186
6187 llvm::GlobalVariable *GV =
6188 cast<llvm::GlobalVariable>(GetClassGlobal(CI, isMetaclass, ForDefinition));
6189 values.finishAndSetAsInitializer(GV);
6190
6191 if (CGM.getTriple().isOSBinFormatMachO())
6192 GV->setSection("__DATA, __objc_data");
6193 GV->setAlignment(
6194 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy));
6195 if (!CGM.getTriple().isOSBinFormatCOFF())
6196 if (HiddenVisibility)
6197 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6198 return GV;
6199 }
6200
6201 bool
ImplementationIsNonLazy(const ObjCImplDecl * OD) const6202 CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
6203 return OD->getClassMethod(GetNullarySelector("load")) != nullptr;
6204 }
6205
GetClassSizeInfo(const ObjCImplementationDecl * OID,uint32_t & InstanceStart,uint32_t & InstanceSize)6206 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
6207 uint32_t &InstanceStart,
6208 uint32_t &InstanceSize) {
6209 const ASTRecordLayout &RL =
6210 CGM.getContext().getASTObjCImplementationLayout(OID);
6211
6212 // InstanceSize is really instance end.
6213 InstanceSize = RL.getDataSize().getQuantity();
6214
6215 // If there are no fields, the start is the same as the end.
6216 if (!RL.getFieldCount())
6217 InstanceStart = InstanceSize;
6218 else
6219 InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
6220 }
6221
getStorage(CodeGenModule & CGM,StringRef Name)6222 static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM,
6223 StringRef Name) {
6224 IdentifierInfo &II = CGM.getContext().Idents.get(Name);
6225 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
6226 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
6227
6228 const VarDecl *VD = nullptr;
6229 for (const auto &Result : DC->lookup(&II))
6230 if ((VD = dyn_cast<VarDecl>(Result)))
6231 break;
6232
6233 if (!VD)
6234 return llvm::GlobalValue::DLLImportStorageClass;
6235 if (VD->hasAttr<DLLExportAttr>())
6236 return llvm::GlobalValue::DLLExportStorageClass;
6237 if (VD->hasAttr<DLLImportAttr>())
6238 return llvm::GlobalValue::DLLImportStorageClass;
6239 return llvm::GlobalValue::DefaultStorageClass;
6240 }
6241
GenerateClass(const ObjCImplementationDecl * ID)6242 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
6243 if (!ObjCEmptyCacheVar) {
6244 ObjCEmptyCacheVar =
6245 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false,
6246 llvm::GlobalValue::ExternalLinkage, nullptr,
6247 "_objc_empty_cache");
6248 if (CGM.getTriple().isOSBinFormatCOFF())
6249 ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache"));
6250
6251 // Only OS X with deployment version <10.9 use the empty vtable symbol
6252 const llvm::Triple &Triple = CGM.getTarget().getTriple();
6253 if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9))
6254 ObjCEmptyVtableVar =
6255 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false,
6256 llvm::GlobalValue::ExternalLinkage, nullptr,
6257 "_objc_empty_vtable");
6258 else
6259 ObjCEmptyVtableVar =
6260 llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo());
6261 }
6262
6263 // FIXME: Is this correct (that meta class size is never computed)?
6264 uint32_t InstanceStart =
6265 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
6266 uint32_t InstanceSize = InstanceStart;
6267 uint32_t flags = NonFragileABI_Class_Meta;
6268
6269 llvm::Constant *SuperClassGV, *IsAGV;
6270
6271 const auto *CI = ID->getClassInterface();
6272 assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0");
6273
6274 // Build the flags for the metaclass.
6275 bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF())
6276 ? !CI->hasAttr<DLLExportAttr>()
6277 : CI->getVisibility() == HiddenVisibility;
6278 if (classIsHidden)
6279 flags |= NonFragileABI_Class_Hidden;
6280
6281 // FIXME: why is this flag set on the metaclass?
6282 // ObjC metaclasses have no fields and don't really get constructed.
6283 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6284 flags |= NonFragileABI_Class_HasCXXStructors;
6285 if (!ID->hasNonZeroConstructors())
6286 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6287 }
6288
6289 if (!CI->getSuperClass()) {
6290 // class is root
6291 flags |= NonFragileABI_Class_Root;
6292
6293 SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition);
6294 IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition);
6295 } else {
6296 // Has a root. Current class is not a root.
6297 const ObjCInterfaceDecl *Root = ID->getClassInterface();
6298 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
6299 Root = Super;
6300
6301 const auto *Super = CI->getSuperClass();
6302 IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition);
6303 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition);
6304 }
6305
6306 llvm::GlobalVariable *CLASS_RO_GV =
6307 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6308
6309 llvm::GlobalVariable *MetaTClass =
6310 BuildClassObject(CI, /*metaclass*/ true,
6311 IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden);
6312 CGM.setGVProperties(MetaTClass, CI);
6313 DefinedMetaClasses.push_back(MetaTClass);
6314
6315 // Metadata for the class
6316 flags = 0;
6317 if (classIsHidden)
6318 flags |= NonFragileABI_Class_Hidden;
6319
6320 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6321 flags |= NonFragileABI_Class_HasCXXStructors;
6322
6323 // Set a flag to enable a runtime optimization when a class has
6324 // fields that require destruction but which don't require
6325 // anything except zero-initialization during construction. This
6326 // is most notably true of __strong and __weak types, but you can
6327 // also imagine there being C++ types with non-trivial default
6328 // constructors that merely set all fields to null.
6329 if (!ID->hasNonZeroConstructors())
6330 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6331 }
6332
6333 if (hasObjCExceptionAttribute(CGM.getContext(), CI))
6334 flags |= NonFragileABI_Class_Exception;
6335
6336 if (!CI->getSuperClass()) {
6337 flags |= NonFragileABI_Class_Root;
6338 SuperClassGV = nullptr;
6339 } else {
6340 // Has a root. Current class is not a root.
6341 const auto *Super = CI->getSuperClass();
6342 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition);
6343 }
6344
6345 GetClassSizeInfo(ID, InstanceStart, InstanceSize);
6346 CLASS_RO_GV =
6347 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6348
6349 llvm::GlobalVariable *ClassMD =
6350 BuildClassObject(CI, /*metaclass*/ false,
6351 MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden);
6352 CGM.setGVProperties(ClassMD, CI);
6353 DefinedClasses.push_back(ClassMD);
6354 ImplementedClasses.push_back(CI);
6355
6356 // Determine if this class is also "non-lazy".
6357 if (ImplementationIsNonLazy(ID))
6358 DefinedNonLazyClasses.push_back(ClassMD);
6359
6360 // Force the definition of the EHType if necessary.
6361 if (flags & NonFragileABI_Class_Exception)
6362 (void) GetInterfaceEHType(CI, ForDefinition);
6363 // Make sure method definition entries are all clear for next implementation.
6364 MethodDefinitions.clear();
6365 }
6366
6367 /// GenerateProtocolRef - This routine is called to generate code for
6368 /// a protocol reference expression; as in:
6369 /// @code
6370 /// @protocol(Proto1);
6371 /// @endcode
6372 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
6373 /// which will hold address of the protocol meta-data.
6374 ///
GenerateProtocolRef(CodeGenFunction & CGF,const ObjCProtocolDecl * PD)6375 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
6376 const ObjCProtocolDecl *PD) {
6377
6378 // This routine is called for @protocol only. So, we must build definition
6379 // of protocol's meta-data (not a reference to it!)
6380 //
6381 llvm::Constant *Init =
6382 llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
6383 ObjCTypes.getExternalProtocolPtrTy());
6384
6385 std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_");
6386 ProtocolName += PD->getObjCRuntimeNameAsString();
6387
6388 CharUnits Align = CGF.getPointerAlign();
6389
6390 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
6391 if (PTGV)
6392 return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6393 PTGV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6394 llvm::GlobalValue::WeakAnyLinkage, Init,
6395 ProtocolName);
6396 PTGV->setSection(GetSectionName("__objc_protorefs",
6397 "coalesced,no_dead_strip"));
6398 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6399 PTGV->setAlignment(Align.getQuantity());
6400 if (!CGM.getTriple().isOSBinFormatMachO())
6401 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolName));
6402 CGM.addUsedGlobal(PTGV);
6403 return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6404 }
6405
6406 /// GenerateCategory - Build metadata for a category implementation.
6407 /// struct _category_t {
6408 /// const char * const name;
6409 /// struct _class_t *const cls;
6410 /// const struct _method_list_t * const instance_methods;
6411 /// const struct _method_list_t * const class_methods;
6412 /// const struct _protocol_list_t * const protocols;
6413 /// const struct _prop_list_t * const properties;
6414 /// const struct _prop_list_t * const class_properties;
6415 /// const uint32_t size;
6416 /// }
6417 ///
GenerateCategory(const ObjCCategoryImplDecl * OCD)6418 void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
6419 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
6420 const char *Prefix = "\01l_OBJC_$_CATEGORY_";
6421
6422 llvm::SmallString<64> ExtCatName(Prefix);
6423 ExtCatName += Interface->getObjCRuntimeNameAsString();
6424 ExtCatName += "_$_";
6425 ExtCatName += OCD->getNameAsString();
6426
6427 ConstantInitBuilder builder(CGM);
6428 auto values = builder.beginStruct(ObjCTypes.CategorynfABITy);
6429 values.add(GetClassName(OCD->getIdentifier()->getName()));
6430 // meta-class entry symbol
6431 values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition));
6432 std::string listName =
6433 (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str();
6434
6435 SmallVector<const ObjCMethodDecl *, 16> instanceMethods;
6436 SmallVector<const ObjCMethodDecl *, 8> classMethods;
6437 for (const auto *MD : OCD->methods()) {
6438 if (MD->isInstanceMethod()) {
6439 instanceMethods.push_back(MD);
6440 } else {
6441 classMethods.push_back(MD);
6442 }
6443 }
6444
6445 values.add(emitMethodList(listName, MethodListType::CategoryInstanceMethods,
6446 instanceMethods));
6447 values.add(emitMethodList(listName, MethodListType::CategoryClassMethods,
6448 classMethods));
6449
6450 const ObjCCategoryDecl *Category =
6451 Interface->FindCategoryDeclaration(OCD->getIdentifier());
6452 if (Category) {
6453 SmallString<256> ExtName;
6454 llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
6455 << OCD->getName();
6456 values.add(EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_"
6457 + Interface->getObjCRuntimeNameAsString() + "_$_"
6458 + Category->getName(),
6459 Category->protocol_begin(),
6460 Category->protocol_end()));
6461 values.add(EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
6462 OCD, Category, ObjCTypes, false));
6463 values.add(EmitPropertyList("\01l_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
6464 OCD, Category, ObjCTypes, true));
6465 } else {
6466 values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy);
6467 values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6468 values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6469 }
6470
6471 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy);
6472 values.addInt(ObjCTypes.IntTy, Size);
6473
6474 llvm::GlobalVariable *GCATV =
6475 values.finishAndCreateGlobal(ExtCatName.str(), CGM.getPointerAlign(),
6476 /*constant*/ false,
6477 llvm::GlobalValue::PrivateLinkage);
6478 if (CGM.getTriple().isOSBinFormatMachO())
6479 GCATV->setSection("__DATA, __objc_const");
6480 CGM.addCompilerUsedGlobal(GCATV);
6481 DefinedCategories.push_back(GCATV);
6482
6483 // Determine if this category is also "non-lazy".
6484 if (ImplementationIsNonLazy(OCD))
6485 DefinedNonLazyCategories.push_back(GCATV);
6486 // method definition entries must be clear for next implementation.
6487 MethodDefinitions.clear();
6488 }
6489
6490 /// emitMethodConstant - Return a struct objc_method constant. If
6491 /// forProtocol is true, the implementation will be null; otherwise,
6492 /// the method must have a definition registered with the runtime.
6493 ///
6494 /// struct _objc_method {
6495 /// SEL _cmd;
6496 /// char *method_type;
6497 /// char *_imp;
6498 /// }
emitMethodConstant(ConstantArrayBuilder & builder,const ObjCMethodDecl * MD,bool forProtocol)6499 void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
6500 const ObjCMethodDecl *MD,
6501 bool forProtocol) {
6502 auto method = builder.beginStruct(ObjCTypes.MethodTy);
6503 method.addBitCast(GetMethodVarName(MD->getSelector()),
6504 ObjCTypes.SelectorPtrTy);
6505 method.add(GetMethodVarType(MD));
6506
6507 if (forProtocol) {
6508 // Protocol methods have no implementation. So, this entry is always NULL.
6509 method.addNullPointer(ObjCTypes.Int8PtrTy);
6510 } else {
6511 llvm::Function *fn = GetMethodDefinition(MD);
6512 assert(fn && "no definition for method?");
6513 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
6514 }
6515
6516 method.finishAndAddTo(builder);
6517 }
6518
6519 /// Build meta-data for method declarations.
6520 ///
6521 /// struct _method_list_t {
6522 /// uint32_t entsize; // sizeof(struct _objc_method)
6523 /// uint32_t method_count;
6524 /// struct _objc_method method_list[method_count];
6525 /// }
6526 ///
6527 llvm::Constant *
emitMethodList(Twine name,MethodListType kind,ArrayRef<const ObjCMethodDecl * > methods)6528 CGObjCNonFragileABIMac::emitMethodList(Twine name, MethodListType kind,
6529 ArrayRef<const ObjCMethodDecl *> methods) {
6530 // Return null for empty list.
6531 if (methods.empty())
6532 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
6533
6534 StringRef prefix;
6535 bool forProtocol;
6536 switch (kind) {
6537 case MethodListType::CategoryInstanceMethods:
6538 prefix = "\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_";
6539 forProtocol = false;
6540 break;
6541 case MethodListType::CategoryClassMethods:
6542 prefix = "\01l_OBJC_$_CATEGORY_CLASS_METHODS_";
6543 forProtocol = false;
6544 break;
6545 case MethodListType::InstanceMethods:
6546 prefix = "\01l_OBJC_$_INSTANCE_METHODS_";
6547 forProtocol = false;
6548 break;
6549 case MethodListType::ClassMethods:
6550 prefix = "\01l_OBJC_$_CLASS_METHODS_";
6551 forProtocol = false;
6552 break;
6553
6554 case MethodListType::ProtocolInstanceMethods:
6555 prefix = "\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_";
6556 forProtocol = true;
6557 break;
6558 case MethodListType::ProtocolClassMethods:
6559 prefix = "\01l_OBJC_$_PROTOCOL_CLASS_METHODS_";
6560 forProtocol = true;
6561 break;
6562 case MethodListType::OptionalProtocolInstanceMethods:
6563 prefix = "\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_";
6564 forProtocol = true;
6565 break;
6566 case MethodListType::OptionalProtocolClassMethods:
6567 prefix = "\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_";
6568 forProtocol = true;
6569 break;
6570 }
6571
6572 ConstantInitBuilder builder(CGM);
6573 auto values = builder.beginStruct();
6574
6575 // sizeof(struct _objc_method)
6576 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
6577 values.addInt(ObjCTypes.IntTy, Size);
6578 // method_count
6579 values.addInt(ObjCTypes.IntTy, methods.size());
6580 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
6581 for (auto MD : methods) {
6582 emitMethodConstant(methodArray, MD, forProtocol);
6583 }
6584 methodArray.finishAndAddTo(values);
6585
6586 auto *GV = values.finishAndCreateGlobal(prefix + name, CGM.getPointerAlign(),
6587 /*constant*/ false,
6588 llvm::GlobalValue::PrivateLinkage);
6589 if (CGM.getTriple().isOSBinFormatMachO())
6590 GV->setSection("__DATA, __objc_const");
6591 CGM.addCompilerUsedGlobal(GV);
6592 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6593 }
6594
6595 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6596 /// the given ivar.
6597 llvm::GlobalVariable *
ObjCIvarOffsetVariable(const ObjCInterfaceDecl * ID,const ObjCIvarDecl * Ivar)6598 CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
6599 const ObjCIvarDecl *Ivar) {
6600 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
6601 llvm::SmallString<64> Name("OBJC_IVAR_$_");
6602 Name += Container->getObjCRuntimeNameAsString();
6603 Name += ".";
6604 Name += Ivar->getName();
6605 llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name);
6606 if (!IvarOffsetGV) {
6607 IvarOffsetGV =
6608 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.IvarOffsetVarTy,
6609 false, llvm::GlobalValue::ExternalLinkage,
6610 nullptr, Name.str());
6611 if (CGM.getTriple().isOSBinFormatCOFF()) {
6612 bool IsPrivateOrPackage =
6613 Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6614 Ivar->getAccessControl() == ObjCIvarDecl::Package;
6615
6616 const ObjCInterfaceDecl *ContainingID = Ivar->getContainingInterface();
6617
6618 if (ContainingID->hasAttr<DLLImportAttr>())
6619 IvarOffsetGV
6620 ->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6621 else if (ContainingID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage)
6622 IvarOffsetGV
6623 ->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6624 }
6625 }
6626 return IvarOffsetGV;
6627 }
6628
6629 llvm::Constant *
EmitIvarOffsetVar(const ObjCInterfaceDecl * ID,const ObjCIvarDecl * Ivar,unsigned long int Offset)6630 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
6631 const ObjCIvarDecl *Ivar,
6632 unsigned long int Offset) {
6633 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
6634 IvarOffsetGV->setInitializer(
6635 llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
6636 IvarOffsetGV->setAlignment(
6637 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy));
6638
6639 if (!CGM.getTriple().isOSBinFormatCOFF()) {
6640 // FIXME: This matches gcc, but shouldn't the visibility be set on the use
6641 // as well (i.e., in ObjCIvarOffsetVariable).
6642 if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6643 Ivar->getAccessControl() == ObjCIvarDecl::Package ||
6644 ID->getVisibility() == HiddenVisibility)
6645 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6646 else
6647 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
6648 }
6649
6650 if (CGM.getTriple().isOSBinFormatMachO())
6651 IvarOffsetGV->setSection("__DATA, __objc_ivar");
6652 return IvarOffsetGV;
6653 }
6654
6655 /// EmitIvarList - Emit the ivar list for the given
6656 /// implementation. The return value has type
6657 /// IvarListnfABIPtrTy.
6658 /// struct _ivar_t {
6659 /// unsigned [long] int *offset; // pointer to ivar offset location
6660 /// char *name;
6661 /// char *type;
6662 /// uint32_t alignment;
6663 /// uint32_t size;
6664 /// }
6665 /// struct _ivar_list_t {
6666 /// uint32 entsize; // sizeof(struct _ivar_t)
6667 /// uint32 count;
6668 /// struct _iver_t list[count];
6669 /// }
6670 ///
6671
EmitIvarList(const ObjCImplementationDecl * ID)6672 llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
6673 const ObjCImplementationDecl *ID) {
6674
6675 ConstantInitBuilder builder(CGM);
6676 auto ivarList = builder.beginStruct();
6677 ivarList.addInt(ObjCTypes.IntTy,
6678 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy));
6679 auto ivarCountSlot = ivarList.addPlaceholder();
6680 auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy);
6681
6682 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6683 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
6684
6685 // FIXME. Consolidate this with similar code in GenerateClass.
6686
6687 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
6688 IVD; IVD = IVD->getNextIvar()) {
6689 // Ignore unnamed bit-fields.
6690 if (!IVD->getDeclName())
6691 continue;
6692
6693 auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy);
6694 ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD,
6695 ComputeIvarBaseOffset(CGM, ID, IVD)));
6696 ivar.add(GetMethodVarName(IVD->getIdentifier()));
6697 ivar.add(GetMethodVarType(IVD));
6698 llvm::Type *FieldTy =
6699 CGM.getTypes().ConvertTypeForMem(IVD->getType());
6700 unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
6701 unsigned Align = CGM.getContext().getPreferredTypeAlign(
6702 IVD->getType().getTypePtr()) >> 3;
6703 Align = llvm::Log2_32(Align);
6704 ivar.addInt(ObjCTypes.IntTy, Align);
6705 // NOTE. Size of a bitfield does not match gcc's, because of the
6706 // way bitfields are treated special in each. But I am told that
6707 // 'size' for bitfield ivars is ignored by the runtime so it does
6708 // not matter. If it matters, there is enough info to get the
6709 // bitfield right!
6710 ivar.addInt(ObjCTypes.IntTy, Size);
6711 ivar.finishAndAddTo(ivars);
6712 }
6713 // Return null for empty list.
6714 if (ivars.empty()) {
6715 ivars.abandon();
6716 ivarList.abandon();
6717 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
6718 }
6719
6720 auto ivarCount = ivars.size();
6721 ivars.finishAndAddTo(ivarList);
6722 ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount);
6723
6724 const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_";
6725 llvm::GlobalVariable *GV =
6726 ivarList.finishAndCreateGlobal(Prefix + OID->getObjCRuntimeNameAsString(),
6727 CGM.getPointerAlign(), /*constant*/ false,
6728 llvm::GlobalValue::PrivateLinkage);
6729 if (CGM.getTriple().isOSBinFormatMachO())
6730 GV->setSection("__DATA, __objc_const");
6731 CGM.addCompilerUsedGlobal(GV);
6732 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
6733 }
6734
GetOrEmitProtocolRef(const ObjCProtocolDecl * PD)6735 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
6736 const ObjCProtocolDecl *PD) {
6737 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
6738
6739 if (!Entry) {
6740 // We use the initializer as a marker of whether this is a forward
6741 // reference or not. At module finalization we add the empty
6742 // contents for protocols which were referenced but never defined.
6743 llvm::SmallString<64> Protocol;
6744 llvm::raw_svector_ostream(Protocol) << "\01l_OBJC_PROTOCOL_$_"
6745 << PD->getObjCRuntimeNameAsString();
6746
6747 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
6748 false, llvm::GlobalValue::ExternalLinkage,
6749 nullptr, Protocol);
6750 if (!CGM.getTriple().isOSBinFormatMachO())
6751 Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol));
6752 }
6753
6754 return Entry;
6755 }
6756
6757 /// GetOrEmitProtocol - Generate the protocol meta-data:
6758 /// @code
6759 /// struct _protocol_t {
6760 /// id isa; // NULL
6761 /// const char * const protocol_name;
6762 /// const struct _protocol_list_t * protocol_list; // super protocols
6763 /// const struct method_list_t * const instance_methods;
6764 /// const struct method_list_t * const class_methods;
6765 /// const struct method_list_t *optionalInstanceMethods;
6766 /// const struct method_list_t *optionalClassMethods;
6767 /// const struct _prop_list_t * properties;
6768 /// const uint32_t size; // sizeof(struct _protocol_t)
6769 /// const uint32_t flags; // = 0
6770 /// const char ** extendedMethodTypes;
6771 /// const char *demangledName;
6772 /// const struct _prop_list_t * class_properties;
6773 /// }
6774 /// @endcode
6775 ///
6776
GetOrEmitProtocol(const ObjCProtocolDecl * PD)6777 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
6778 const ObjCProtocolDecl *PD) {
6779 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
6780
6781 // Early exit if a defining object has already been generated.
6782 if (Entry && Entry->hasInitializer())
6783 return Entry;
6784
6785 // Use the protocol definition, if there is one.
6786 if (const ObjCProtocolDecl *Def = PD->getDefinition())
6787 PD = Def;
6788
6789 auto methodLists = ProtocolMethodLists::get(PD);
6790
6791 ConstantInitBuilder builder(CGM);
6792 auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy);
6793
6794 // isa is NULL
6795 values.addNullPointer(ObjCTypes.ObjectPtrTy);
6796 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
6797 values.add(EmitProtocolList("\01l_OBJC_$_PROTOCOL_REFS_"
6798 + PD->getObjCRuntimeNameAsString(),
6799 PD->protocol_begin(),
6800 PD->protocol_end()));
6801 values.add(methodLists.emitMethodList(this, PD,
6802 ProtocolMethodLists::RequiredInstanceMethods));
6803 values.add(methodLists.emitMethodList(this, PD,
6804 ProtocolMethodLists::RequiredClassMethods));
6805 values.add(methodLists.emitMethodList(this, PD,
6806 ProtocolMethodLists::OptionalInstanceMethods));
6807 values.add(methodLists.emitMethodList(this, PD,
6808 ProtocolMethodLists::OptionalClassMethods));
6809 values.add(EmitPropertyList(
6810 "\01l_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6811 nullptr, PD, ObjCTypes, false));
6812 uint32_t Size =
6813 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
6814 values.addInt(ObjCTypes.IntTy, Size);
6815 values.addInt(ObjCTypes.IntTy, 0);
6816 values.add(EmitProtocolMethodTypes("\01l_OBJC_$_PROTOCOL_METHOD_TYPES_"
6817 + PD->getObjCRuntimeNameAsString(),
6818 methodLists.emitExtendedTypesArray(this),
6819 ObjCTypes));
6820
6821 // const char *demangledName;
6822 values.addNullPointer(ObjCTypes.Int8PtrTy);
6823
6824 values.add(EmitPropertyList(
6825 "\01l_OBJC_$_CLASS_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6826 nullptr, PD, ObjCTypes, true));
6827
6828 if (Entry) {
6829 // Already created, fix the linkage and update the initializer.
6830 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
6831 values.finishAndSetAsInitializer(Entry);
6832 } else {
6833 llvm::SmallString<64> symbolName;
6834 llvm::raw_svector_ostream(symbolName)
6835 << "\01l_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString();
6836
6837 Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(),
6838 /*constant*/ false,
6839 llvm::GlobalValue::WeakAnyLinkage);
6840 if (!CGM.getTriple().isOSBinFormatMachO())
6841 Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName));
6842
6843 Protocols[PD->getIdentifier()] = Entry;
6844 }
6845 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
6846 CGM.addUsedGlobal(Entry);
6847
6848 // Use this protocol meta-data to build protocol list table in section
6849 // __DATA, __objc_protolist
6850 llvm::SmallString<64> ProtocolRef;
6851 llvm::raw_svector_ostream(ProtocolRef) << "\01l_OBJC_LABEL_PROTOCOL_$_"
6852 << PD->getObjCRuntimeNameAsString();
6853
6854 llvm::GlobalVariable *PTGV =
6855 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
6856 false, llvm::GlobalValue::WeakAnyLinkage, Entry,
6857 ProtocolRef);
6858 if (!CGM.getTriple().isOSBinFormatMachO())
6859 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef));
6860 PTGV->setAlignment(
6861 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy));
6862 PTGV->setSection(GetSectionName("__objc_protolist",
6863 "coalesced,no_dead_strip"));
6864 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6865 CGM.addUsedGlobal(PTGV);
6866 return Entry;
6867 }
6868
6869 /// EmitProtocolList - Generate protocol list meta-data:
6870 /// @code
6871 /// struct _protocol_list_t {
6872 /// long protocol_count; // Note, this is 32/64 bit
6873 /// struct _protocol_t[protocol_count];
6874 /// }
6875 /// @endcode
6876 ///
6877 llvm::Constant *
EmitProtocolList(Twine Name,ObjCProtocolDecl::protocol_iterator begin,ObjCProtocolDecl::protocol_iterator end)6878 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
6879 ObjCProtocolDecl::protocol_iterator begin,
6880 ObjCProtocolDecl::protocol_iterator end) {
6881 SmallVector<llvm::Constant *, 16> ProtocolRefs;
6882
6883 // Just return null for empty protocol lists
6884 if (begin == end)
6885 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
6886
6887 // FIXME: We shouldn't need to do this lookup here, should we?
6888 SmallString<256> TmpName;
6889 Name.toVector(TmpName);
6890 llvm::GlobalVariable *GV =
6891 CGM.getModule().getGlobalVariable(TmpName.str(), true);
6892 if (GV)
6893 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
6894
6895 ConstantInitBuilder builder(CGM);
6896 auto values = builder.beginStruct();
6897 auto countSlot = values.addPlaceholder();
6898
6899 // A null-terminated array of protocols.
6900 auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy);
6901 for (; begin != end; ++begin)
6902 array.add(GetProtocolRef(*begin)); // Implemented???
6903 auto count = array.size();
6904 array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy);
6905
6906 array.finishAndAddTo(values);
6907 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
6908
6909 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
6910 /*constant*/ false,
6911 llvm::GlobalValue::PrivateLinkage);
6912 if (CGM.getTriple().isOSBinFormatMachO())
6913 GV->setSection("__DATA, __objc_const");
6914 CGM.addCompilerUsedGlobal(GV);
6915 return llvm::ConstantExpr::getBitCast(GV,
6916 ObjCTypes.ProtocolListnfABIPtrTy);
6917 }
6918
6919 /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
6920 /// This code gen. amounts to generating code for:
6921 /// @code
6922 /// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
6923 /// @encode
6924 ///
EmitObjCValueForIvar(CodeGen::CodeGenFunction & CGF,QualType ObjectTy,llvm::Value * BaseValue,const ObjCIvarDecl * Ivar,unsigned CVRQualifiers)6925 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
6926 CodeGen::CodeGenFunction &CGF,
6927 QualType ObjectTy,
6928 llvm::Value *BaseValue,
6929 const ObjCIvarDecl *Ivar,
6930 unsigned CVRQualifiers) {
6931 ObjCInterfaceDecl *ID = ObjectTy->getAs<ObjCObjectType>()->getInterface();
6932 llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
6933 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
6934 Offset);
6935 }
6936
EmitIvarOffset(CodeGen::CodeGenFunction & CGF,const ObjCInterfaceDecl * Interface,const ObjCIvarDecl * Ivar)6937 llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset(
6938 CodeGen::CodeGenFunction &CGF,
6939 const ObjCInterfaceDecl *Interface,
6940 const ObjCIvarDecl *Ivar) {
6941 llvm::Value *IvarOffsetValue = ObjCIvarOffsetVariable(Interface, Ivar);
6942 IvarOffsetValue = CGF.Builder.CreateAlignedLoad(IvarOffsetValue,
6943 CGF.getSizeAlign(), "ivar");
6944 if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
6945 cast<llvm::LoadInst>(IvarOffsetValue)
6946 ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
6947 llvm::MDNode::get(VMContext, None));
6948
6949 // This could be 32bit int or 64bit integer depending on the architecture.
6950 // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
6951 // as this is what caller always expects.
6952 if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
6953 IvarOffsetValue = CGF.Builder.CreateIntCast(
6954 IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
6955 return IvarOffsetValue;
6956 }
6957
appendSelectorForMessageRefTable(std::string & buffer,Selector selector)6958 static void appendSelectorForMessageRefTable(std::string &buffer,
6959 Selector selector) {
6960 if (selector.isUnarySelector()) {
6961 buffer += selector.getNameForSlot(0);
6962 return;
6963 }
6964
6965 for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
6966 buffer += selector.getNameForSlot(i);
6967 buffer += '_';
6968 }
6969 }
6970
6971 /// Emit a "vtable" message send. We emit a weak hidden-visibility
6972 /// struct, initially containing the selector pointer and a pointer to
6973 /// a "fixup" variant of the appropriate objc_msgSend. To call, we
6974 /// load and call the function pointer, passing the address of the
6975 /// struct as the second parameter. The runtime determines whether
6976 /// the selector is currently emitted using vtable dispatch; if so, it
6977 /// substitutes a stub function which simply tail-calls through the
6978 /// appropriate vtable slot, and if not, it substitues a stub function
6979 /// which tail-calls objc_msgSend. Both stubs adjust the selector
6980 /// argument to correctly point to the selector.
6981 RValue
EmitVTableMessageSend(CodeGenFunction & CGF,ReturnValueSlot returnSlot,QualType resultType,Selector selector,llvm::Value * arg0,QualType arg0Type,bool isSuper,const CallArgList & formalArgs,const ObjCMethodDecl * method)6982 CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
6983 ReturnValueSlot returnSlot,
6984 QualType resultType,
6985 Selector selector,
6986 llvm::Value *arg0,
6987 QualType arg0Type,
6988 bool isSuper,
6989 const CallArgList &formalArgs,
6990 const ObjCMethodDecl *method) {
6991 // Compute the actual arguments.
6992 CallArgList args;
6993
6994 // First argument: the receiver / super-call structure.
6995 if (!isSuper)
6996 arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
6997 args.add(RValue::get(arg0), arg0Type);
6998
6999 // Second argument: a pointer to the message ref structure. Leave
7000 // the actual argument value blank for now.
7001 args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);
7002
7003 args.insert(args.end(), formalArgs.begin(), formalArgs.end());
7004
7005 MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);
7006
7007 NullReturnState nullReturn;
7008
7009 // Find the function to call and the mangled name for the message
7010 // ref structure. Using a different mangled name wouldn't actually
7011 // be a problem; it would just be a waste.
7012 //
7013 // The runtime currently never uses vtable dispatch for anything
7014 // except normal, non-super message-sends.
7015 // FIXME: don't use this for that.
7016 llvm::Constant *fn = nullptr;
7017 std::string messageRefName("\01l_");
7018 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
7019 if (isSuper) {
7020 fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
7021 messageRefName += "objc_msgSendSuper2_stret_fixup";
7022 } else {
7023 nullReturn.init(CGF, arg0);
7024 fn = ObjCTypes.getMessageSendStretFixupFn();
7025 messageRefName += "objc_msgSend_stret_fixup";
7026 }
7027 } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
7028 fn = ObjCTypes.getMessageSendFpretFixupFn();
7029 messageRefName += "objc_msgSend_fpret_fixup";
7030 } else {
7031 if (isSuper) {
7032 fn = ObjCTypes.getMessageSendSuper2FixupFn();
7033 messageRefName += "objc_msgSendSuper2_fixup";
7034 } else {
7035 fn = ObjCTypes.getMessageSendFixupFn();
7036 messageRefName += "objc_msgSend_fixup";
7037 }
7038 }
7039 assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend");
7040 messageRefName += '_';
7041
7042 // Append the selector name, except use underscores anywhere we
7043 // would have used colons.
7044 appendSelectorForMessageRefTable(messageRefName, selector);
7045
7046 llvm::GlobalVariable *messageRef
7047 = CGM.getModule().getGlobalVariable(messageRefName);
7048 if (!messageRef) {
7049 // Build the message ref structure.
7050 ConstantInitBuilder builder(CGM);
7051 auto values = builder.beginStruct();
7052 values.add(fn);
7053 values.add(GetMethodVarName(selector));
7054 messageRef = values.finishAndCreateGlobal(messageRefName,
7055 CharUnits::fromQuantity(16),
7056 /*constant*/ false,
7057 llvm::GlobalValue::WeakAnyLinkage);
7058 messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
7059 messageRef->setSection(GetSectionName("__objc_msgrefs", "coalesced"));
7060 }
7061
7062 bool requiresnullCheck = false;
7063 if (CGM.getLangOpts().ObjCAutoRefCount && method)
7064 for (const auto *ParamDecl : method->parameters()) {
7065 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
7066 if (!nullReturn.NullBB)
7067 nullReturn.init(CGF, arg0);
7068 requiresnullCheck = true;
7069 break;
7070 }
7071 }
7072
7073 Address mref =
7074 Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
7075 CGF.getPointerAlign());
7076
7077 // Update the message ref argument.
7078 args[1].setRValue(RValue::get(mref.getPointer()));
7079
7080 // Load the function to call from the message ref table.
7081 Address calleeAddr =
7082 CGF.Builder.CreateStructGEP(mref, 0, CharUnits::Zero());
7083 llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn");
7084
7085 calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
7086 CGCallee callee(CGCalleeInfo(), calleePtr);
7087
7088 RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
7089 return nullReturn.complete(CGF, returnSlot, result, resultType, formalArgs,
7090 requiresnullCheck ? method : nullptr);
7091 }
7092
7093 /// Generate code for a message send expression in the nonfragile abi.
7094 CodeGen::RValue
GenerateMessageSend(CodeGen::CodeGenFunction & CGF,ReturnValueSlot Return,QualType ResultType,Selector Sel,llvm::Value * Receiver,const CallArgList & CallArgs,const ObjCInterfaceDecl * Class,const ObjCMethodDecl * Method)7095 CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
7096 ReturnValueSlot Return,
7097 QualType ResultType,
7098 Selector Sel,
7099 llvm::Value *Receiver,
7100 const CallArgList &CallArgs,
7101 const ObjCInterfaceDecl *Class,
7102 const ObjCMethodDecl *Method) {
7103 return isVTableDispatchedSelector(Sel)
7104 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7105 Receiver, CGF.getContext().getObjCIdType(),
7106 false, CallArgs, Method)
7107 : EmitMessageSend(CGF, Return, ResultType,
7108 EmitSelector(CGF, Sel),
7109 Receiver, CGF.getContext().getObjCIdType(),
7110 false, CallArgs, Method, Class, ObjCTypes);
7111 }
7112
7113 llvm::Constant *
GetClassGlobal(const ObjCInterfaceDecl * ID,bool metaclass,ForDefinition_t isForDefinition)7114 CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID,
7115 bool metaclass,
7116 ForDefinition_t isForDefinition) {
7117 auto prefix =
7118 (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix());
7119 return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(),
7120 isForDefinition,
7121 ID->isWeakImported(),
7122 !isForDefinition
7123 && CGM.getTriple().isOSBinFormatCOFF()
7124 && ID->hasAttr<DLLImportAttr>());
7125 }
7126
7127 llvm::Constant *
GetClassGlobal(StringRef Name,ForDefinition_t IsForDefinition,bool Weak,bool DLLImport)7128 CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
7129 ForDefinition_t IsForDefinition,
7130 bool Weak, bool DLLImport) {
7131 llvm::GlobalValue::LinkageTypes L =
7132 Weak ? llvm::GlobalValue::ExternalWeakLinkage
7133 : llvm::GlobalValue::ExternalLinkage;
7134
7135
7136
7137 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
7138 if (!GV) {
7139 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
7140 false, L, nullptr, Name);
7141
7142 if (DLLImport)
7143 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
7144 }
7145
7146 assert(GV->getLinkage() == L);
7147 return GV;
7148 }
7149
7150 llvm::Value *
EmitClassRefFromId(CodeGenFunction & CGF,IdentifierInfo * II,const ObjCInterfaceDecl * ID)7151 CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
7152 IdentifierInfo *II,
7153 const ObjCInterfaceDecl *ID) {
7154 CharUnits Align = CGF.getPointerAlign();
7155 llvm::GlobalVariable *&Entry = ClassReferences[II];
7156
7157 if (!Entry) {
7158 llvm::Constant *ClassGV;
7159 if (ID) {
7160 ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7161 } else {
7162 ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(),
7163 NotForDefinition);
7164 }
7165
7166 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7167 false, llvm::GlobalValue::PrivateLinkage,
7168 ClassGV, "OBJC_CLASSLIST_REFERENCES_$_");
7169 Entry->setAlignment(Align.getQuantity());
7170 Entry->setSection(GetSectionName("__objc_classrefs",
7171 "regular,no_dead_strip"));
7172 CGM.addCompilerUsedGlobal(Entry);
7173 }
7174 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7175 }
7176
EmitClassRef(CodeGenFunction & CGF,const ObjCInterfaceDecl * ID)7177 llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
7178 const ObjCInterfaceDecl *ID) {
7179 // If the class has the objc_runtime_visible attribute, we need to
7180 // use the Objective-C runtime to get the class.
7181 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
7182 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
7183
7184 return EmitClassRefFromId(CGF, ID->getIdentifier(), ID);
7185 }
7186
EmitNSAutoreleasePoolClassRef(CodeGenFunction & CGF)7187 llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
7188 CodeGenFunction &CGF) {
7189 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
7190 return EmitClassRefFromId(CGF, II, nullptr);
7191 }
7192
7193 llvm::Value *
EmitSuperClassRef(CodeGenFunction & CGF,const ObjCInterfaceDecl * ID)7194 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
7195 const ObjCInterfaceDecl *ID) {
7196 CharUnits Align = CGF.getPointerAlign();
7197 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
7198
7199 if (!Entry) {
7200 auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7201 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7202 false, llvm::GlobalValue::PrivateLinkage,
7203 ClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
7204 Entry->setAlignment(Align.getQuantity());
7205 Entry->setSection(GetSectionName("__objc_superrefs",
7206 "regular,no_dead_strip"));
7207 CGM.addCompilerUsedGlobal(Entry);
7208 }
7209 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7210 }
7211
7212 /// EmitMetaClassRef - Return a Value * of the address of _class_t
7213 /// meta-data
7214 ///
EmitMetaClassRef(CodeGenFunction & CGF,const ObjCInterfaceDecl * ID,bool Weak)7215 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
7216 const ObjCInterfaceDecl *ID,
7217 bool Weak) {
7218 CharUnits Align = CGF.getPointerAlign();
7219 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
7220 if (!Entry) {
7221 auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition);
7222
7223 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7224 false, llvm::GlobalValue::PrivateLinkage,
7225 MetaClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
7226 Entry->setAlignment(Align.getQuantity());
7227
7228 Entry->setSection(GetSectionName("__objc_superrefs",
7229 "regular,no_dead_strip"));
7230 CGM.addCompilerUsedGlobal(Entry);
7231 }
7232
7233 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7234 }
7235
7236 /// GetClass - Return a reference to the class for the given interface
7237 /// decl.
GetClass(CodeGenFunction & CGF,const ObjCInterfaceDecl * ID)7238 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
7239 const ObjCInterfaceDecl *ID) {
7240 if (ID->isWeakImported()) {
7241 auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7242 (void)ClassGV;
7243 assert(!isa<llvm::GlobalVariable>(ClassGV) ||
7244 cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage());
7245 }
7246
7247 return EmitClassRef(CGF, ID);
7248 }
7249
7250 /// Generates a message send where the super is the receiver. This is
7251 /// a message send to self with special delivery semantics indicating
7252 /// which class's method should be called.
7253 CodeGen::RValue
GenerateMessageSendSuper(CodeGen::CodeGenFunction & CGF,ReturnValueSlot Return,QualType ResultType,Selector Sel,const ObjCInterfaceDecl * Class,bool isCategoryImpl,llvm::Value * Receiver,bool IsClassMessage,const CodeGen::CallArgList & CallArgs,const ObjCMethodDecl * Method)7254 CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
7255 ReturnValueSlot Return,
7256 QualType ResultType,
7257 Selector Sel,
7258 const ObjCInterfaceDecl *Class,
7259 bool isCategoryImpl,
7260 llvm::Value *Receiver,
7261 bool IsClassMessage,
7262 const CodeGen::CallArgList &CallArgs,
7263 const ObjCMethodDecl *Method) {
7264 // ...
7265 // Create and init a super structure; this is a (receiver, class)
7266 // pair we will pass to objc_msgSendSuper.
7267 Address ObjCSuper =
7268 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
7269 "objc_super");
7270
7271 llvm::Value *ReceiverAsObject =
7272 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
7273 CGF.Builder.CreateStore(
7274 ReceiverAsObject,
7275 CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
7276
7277 // If this is a class message the metaclass is passed as the target.
7278 llvm::Value *Target;
7279 if (IsClassMessage)
7280 Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported());
7281 else
7282 Target = EmitSuperClassRef(CGF, Class);
7283
7284 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
7285 // ObjCTypes types.
7286 llvm::Type *ClassTy =
7287 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
7288 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
7289 CGF.Builder.CreateStore(
7290 Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1, CGF.getPointerSize()));
7291
7292 return (isVTableDispatchedSelector(Sel))
7293 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7294 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7295 true, CallArgs, Method)
7296 : EmitMessageSend(CGF, Return, ResultType,
7297 EmitSelector(CGF, Sel),
7298 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7299 true, CallArgs, Method, Class, ObjCTypes);
7300 }
7301
EmitSelector(CodeGenFunction & CGF,Selector Sel)7302 llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
7303 Selector Sel) {
7304 Address Addr = EmitSelectorAddr(CGF, Sel);
7305
7306 llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr);
7307 LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7308 llvm::MDNode::get(VMContext, None));
7309 return LI;
7310 }
7311
EmitSelectorAddr(CodeGenFunction & CGF,Selector Sel)7312 Address CGObjCNonFragileABIMac::EmitSelectorAddr(CodeGenFunction &CGF,
7313 Selector Sel) {
7314 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
7315
7316 CharUnits Align = CGF.getPointerAlign();
7317 if (!Entry) {
7318 llvm::Constant *Casted =
7319 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
7320 ObjCTypes.SelectorPtrTy);
7321 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.SelectorPtrTy,
7322 false, llvm::GlobalValue::PrivateLinkage,
7323 Casted, "OBJC_SELECTOR_REFERENCES_");
7324 Entry->setExternallyInitialized(true);
7325 Entry->setSection(GetSectionName("__objc_selrefs",
7326 "literal_pointers,no_dead_strip"));
7327 Entry->setAlignment(Align.getQuantity());
7328 CGM.addCompilerUsedGlobal(Entry);
7329 }
7330
7331 return Address(Entry, Align);
7332 }
7333
7334 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
7335 /// objc_assign_ivar (id src, id *dst, ptrdiff_t)
7336 ///
EmitObjCIvarAssign(CodeGen::CodeGenFunction & CGF,llvm::Value * src,Address dst,llvm::Value * ivarOffset)7337 void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
7338 llvm::Value *src,
7339 Address dst,
7340 llvm::Value *ivarOffset) {
7341 llvm::Type * SrcTy = src->getType();
7342 if (!isa<llvm::PointerType>(SrcTy)) {
7343 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7344 assert(Size <= 8 && "does not support size > 8");
7345 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7346 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7347 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7348 }
7349 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7350 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7351 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
7352 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
7353 }
7354
7355 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
7356 /// objc_assign_strongCast (id src, id *dst)
7357 ///
EmitObjCStrongCastAssign(CodeGen::CodeGenFunction & CGF,llvm::Value * src,Address dst)7358 void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
7359 CodeGen::CodeGenFunction &CGF,
7360 llvm::Value *src, Address dst) {
7361 llvm::Type * SrcTy = src->getType();
7362 if (!isa<llvm::PointerType>(SrcTy)) {
7363 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7364 assert(Size <= 8 && "does not support size > 8");
7365 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7366 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7367 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7368 }
7369 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7370 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7371 llvm::Value *args[] = { src, dst.getPointer() };
7372 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
7373 args, "weakassign");
7374 }
7375
EmitGCMemmoveCollectable(CodeGen::CodeGenFunction & CGF,Address DestPtr,Address SrcPtr,llvm::Value * Size)7376 void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
7377 CodeGen::CodeGenFunction &CGF,
7378 Address DestPtr,
7379 Address SrcPtr,
7380 llvm::Value *Size) {
7381 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
7382 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
7383 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), Size };
7384 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
7385 }
7386
7387 /// EmitObjCWeakRead - Code gen for loading value of a __weak
7388 /// object: objc_read_weak (id *src)
7389 ///
EmitObjCWeakRead(CodeGen::CodeGenFunction & CGF,Address AddrWeakObj)7390 llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
7391 CodeGen::CodeGenFunction &CGF,
7392 Address AddrWeakObj) {
7393 llvm::Type *DestTy = AddrWeakObj.getElementType();
7394 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
7395 llvm::Value *read_weak =
7396 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
7397 AddrWeakObj.getPointer(), "weakread");
7398 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
7399 return read_weak;
7400 }
7401
7402 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
7403 /// objc_assign_weak (id src, id *dst)
7404 ///
EmitObjCWeakAssign(CodeGen::CodeGenFunction & CGF,llvm::Value * src,Address dst)7405 void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
7406 llvm::Value *src, Address dst) {
7407 llvm::Type * SrcTy = src->getType();
7408 if (!isa<llvm::PointerType>(SrcTy)) {
7409 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7410 assert(Size <= 8 && "does not support size > 8");
7411 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7412 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7413 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7414 }
7415 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7416 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7417 llvm::Value *args[] = { src, dst.getPointer() };
7418 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
7419 args, "weakassign");
7420 }
7421
7422 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
7423 /// objc_assign_global (id src, id *dst)
7424 ///
EmitObjCGlobalAssign(CodeGen::CodeGenFunction & CGF,llvm::Value * src,Address dst,bool threadlocal)7425 void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
7426 llvm::Value *src, Address dst,
7427 bool threadlocal) {
7428 llvm::Type * SrcTy = src->getType();
7429 if (!isa<llvm::PointerType>(SrcTy)) {
7430 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7431 assert(Size <= 8 && "does not support size > 8");
7432 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7433 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7434 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7435 }
7436 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7437 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7438 llvm::Value *args[] = { src, dst.getPointer() };
7439 if (!threadlocal)
7440 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
7441 args, "globalassign");
7442 else
7443 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
7444 args, "threadlocalassign");
7445 }
7446
7447 void
EmitSynchronizedStmt(CodeGen::CodeGenFunction & CGF,const ObjCAtSynchronizedStmt & S)7448 CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
7449 const ObjCAtSynchronizedStmt &S) {
7450 EmitAtSynchronizedStmt(CGF, S,
7451 cast<llvm::Function>(ObjCTypes.getSyncEnterFn()),
7452 cast<llvm::Function>(ObjCTypes.getSyncExitFn()));
7453 }
7454
7455 llvm::Constant *
GetEHType(QualType T)7456 CGObjCNonFragileABIMac::GetEHType(QualType T) {
7457 // There's a particular fixed type info for 'id'.
7458 if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
7459 auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
7460 if (!IDEHType) {
7461 IDEHType =
7462 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7463 llvm::GlobalValue::ExternalLinkage, nullptr,
7464 "OBJC_EHTYPE_id");
7465 if (CGM.getTriple().isOSBinFormatCOFF())
7466 IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id"));
7467 }
7468 return IDEHType;
7469 }
7470
7471 // All other types should be Objective-C interface pointer types.
7472 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
7473 assert(PT && "Invalid @catch type.");
7474
7475 const ObjCInterfaceType *IT = PT->getInterfaceType();
7476 assert(IT && "Invalid @catch type.");
7477
7478 return GetInterfaceEHType(IT->getDecl(), NotForDefinition);
7479 }
7480
EmitTryStmt(CodeGen::CodeGenFunction & CGF,const ObjCAtTryStmt & S)7481 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
7482 const ObjCAtTryStmt &S) {
7483 EmitTryCatchStmt(CGF, S,
7484 cast<llvm::Function>(ObjCTypes.getObjCBeginCatchFn()),
7485 cast<llvm::Function>(ObjCTypes.getObjCEndCatchFn()),
7486 cast<llvm::Function>(ObjCTypes.getExceptionRethrowFn()));
7487 }
7488
7489 /// EmitThrowStmt - Generate code for a throw statement.
EmitThrowStmt(CodeGen::CodeGenFunction & CGF,const ObjCAtThrowStmt & S,bool ClearInsertionPoint)7490 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
7491 const ObjCAtThrowStmt &S,
7492 bool ClearInsertionPoint) {
7493 if (const Expr *ThrowExpr = S.getThrowExpr()) {
7494 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
7495 Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7496 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception)
7497 .setDoesNotReturn();
7498 } else {
7499 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn())
7500 .setDoesNotReturn();
7501 }
7502
7503 CGF.Builder.CreateUnreachable();
7504 if (ClearInsertionPoint)
7505 CGF.Builder.ClearInsertionPoint();
7506 }
7507
7508 llvm::Constant *
GetInterfaceEHType(const ObjCInterfaceDecl * ID,ForDefinition_t IsForDefinition)7509 CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
7510 ForDefinition_t IsForDefinition) {
7511 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
7512 StringRef ClassName = ID->getObjCRuntimeNameAsString();
7513
7514 // If we don't need a definition, return the entry if found or check
7515 // if we use an external reference.
7516 if (!IsForDefinition) {
7517 if (Entry)
7518 return Entry;
7519
7520 // If this type (or a super class) has the __objc_exception__
7521 // attribute, emit an external reference.
7522 if (hasObjCExceptionAttribute(CGM.getContext(), ID)) {
7523 std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str();
7524 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
7525 false, llvm::GlobalValue::ExternalLinkage,
7526 nullptr, EHTypeName);
7527 CGM.setGVProperties(Entry, ID);
7528 return Entry;
7529 }
7530 }
7531
7532 // Otherwise we need to either make a new entry or fill in the initializer.
7533 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
7534
7535 std::string VTableName = "objc_ehtype_vtable";
7536 auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName);
7537 if (!VTableGV) {
7538 VTableGV =
7539 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false,
7540 llvm::GlobalValue::ExternalLinkage, nullptr,
7541 VTableName);
7542 if (CGM.getTriple().isOSBinFormatCOFF())
7543 VTableGV->setDLLStorageClass(getStorage(CGM, VTableName));
7544 }
7545
7546 llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
7547 ConstantInitBuilder builder(CGM);
7548 auto values = builder.beginStruct(ObjCTypes.EHTypeTy);
7549 values.add(
7550 llvm::ConstantExpr::getInBoundsGetElementPtr(VTableGV->getValueType(),
7551 VTableGV, VTableIdx));
7552 values.add(GetClassName(ClassName));
7553 values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition));
7554
7555 llvm::GlobalValue::LinkageTypes L = IsForDefinition
7556 ? llvm::GlobalValue::ExternalLinkage
7557 : llvm::GlobalValue::WeakAnyLinkage;
7558 if (Entry) {
7559 values.finishAndSetAsInitializer(Entry);
7560 Entry->setAlignment(CGM.getPointerAlign().getQuantity());
7561 } else {
7562 Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName,
7563 CGM.getPointerAlign(),
7564 /*constant*/ false,
7565 L);
7566 if (hasObjCExceptionAttribute(CGM.getContext(), ID))
7567 CGM.setGVProperties(Entry, ID);
7568 }
7569 assert(Entry->getLinkage() == L);
7570
7571 if (!CGM.getTriple().isOSBinFormatCOFF())
7572 if (ID->getVisibility() == HiddenVisibility)
7573 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7574
7575 if (IsForDefinition)
7576 if (CGM.getTriple().isOSBinFormatMachO())
7577 Entry->setSection("__DATA,__objc_const");
7578
7579 return Entry;
7580 }
7581
7582 /* *** */
7583
7584 CodeGen::CGObjCRuntime *
CreateMacObjCRuntime(CodeGen::CodeGenModule & CGM)7585 CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
7586 switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
7587 case ObjCRuntime::FragileMacOSX:
7588 return new CGObjCMac(CGM);
7589
7590 case ObjCRuntime::MacOSX:
7591 case ObjCRuntime::iOS:
7592 case ObjCRuntime::WatchOS:
7593 return new CGObjCNonFragileABIMac(CGM);
7594
7595 case ObjCRuntime::GNUstep:
7596 case ObjCRuntime::GCC:
7597 case ObjCRuntime::ObjFW:
7598 llvm_unreachable("these runtimes are not Mac runtimes");
7599 }
7600 llvm_unreachable("bad runtime");
7601 }
7602