1 //===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This provides Objective-C code generation targeting the Apple runtime.
12 //===----------------------------------------------------------------------===//
15 #include "CGCleanup.h"
16 #include "CGObjCRuntime.h"
17 #include "CGRecordLayout.h"
18 #include "CodeGenFunction.h"
19 #include "CodeGenModule.h"
20 #include "ConstantBuilder.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"
43 using namespace clang;
44 using namespace CodeGen;
48 // FIXME: We should find a nicer way to make the labels for metadata, string
49 // concatenation is lame.
51 class ObjCCommonTypesHelper {
53 llvm::LLVMContext &VMContext;
56 // The types of these functions don't really matter because we
57 // should always bitcast before calling them.
59 /// id objc_msgSend (id, SEL, ...)
61 /// The default messenger, used for sends whose ABI is unchanged from
62 /// the all-integer/pointer case.
63 llvm::Constant *getMessageSendFn() const {
64 // Add the non-lazy-bind attribute, since objc_msgSend is likely to
66 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
68 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
71 llvm::AttributeSet::get(CGM.getLLVMContext(),
72 llvm::AttributeSet::FunctionIndex,
73 llvm::Attribute::NonLazyBind));
76 /// void objc_msgSend_stret (id, SEL, ...)
78 /// The messenger used when the return value is an aggregate returned
79 /// by indirect reference in the first argument, and therefore the
80 /// self and selector parameters are shifted over by one.
81 llvm::Constant *getMessageSendStretFn() const {
82 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
83 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
85 "objc_msgSend_stret");
89 /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
91 /// The messenger used when the return value is returned on the x87
92 /// floating-point stack; without a special entrypoint, the nil case
93 /// would be unbalanced.
94 llvm::Constant *getMessageSendFpretFn() const {
95 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
96 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
98 "objc_msgSend_fpret");
102 /// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
104 /// The messenger used when the return value is returned in two values on the
105 /// x87 floating point stack; without a special entrypoint, the nil case
106 /// would be unbalanced. Only used on 64-bit X86.
107 llvm::Constant *getMessageSendFp2retFn() const {
108 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
109 llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext);
110 llvm::Type *resultType =
111 llvm::StructType::get(longDoubleType, longDoubleType, nullptr);
113 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType,
115 "objc_msgSend_fp2ret");
118 /// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
120 /// The messenger used for super calls, which have different dispatch
121 /// semantics. The class passed is the superclass of the current
123 llvm::Constant *getMessageSendSuperFn() const {
124 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
125 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
127 "objc_msgSendSuper");
130 /// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
132 /// A slightly different messenger used for super calls. The class
133 /// passed is the current class.
134 llvm::Constant *getMessageSendSuperFn2() const {
135 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
136 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
138 "objc_msgSendSuper2");
141 /// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super,
144 /// The messenger used for super calls which return an aggregate indirectly.
145 llvm::Constant *getMessageSendSuperStretFn() const {
146 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
147 return CGM.CreateRuntimeFunction(
148 llvm::FunctionType::get(CGM.VoidTy, params, true),
149 "objc_msgSendSuper_stret");
152 /// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
155 /// objc_msgSendSuper_stret with the super2 semantics.
156 llvm::Constant *getMessageSendSuperStretFn2() const {
157 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
158 return CGM.CreateRuntimeFunction(
159 llvm::FunctionType::get(CGM.VoidTy, params, true),
160 "objc_msgSendSuper2_stret");
163 llvm::Constant *getMessageSendSuperFpretFn() const {
164 // There is no objc_msgSendSuper_fpret? How can that work?
165 return getMessageSendSuperFn();
168 llvm::Constant *getMessageSendSuperFpretFn2() const {
169 // There is no objc_msgSendSuper_fpret? How can that work?
170 return getMessageSendSuperFn2();
174 CodeGen::CodeGenModule &CGM;
177 llvm::IntegerType *ShortTy, *IntTy, *LongTy;
178 llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy;
179 llvm::Type *IvarOffsetVarTy;
181 /// ObjectPtrTy - LLVM type for object handles (typeof(id))
182 llvm::PointerType *ObjectPtrTy;
184 /// PtrObjectPtrTy - LLVM type for id *
185 llvm::PointerType *PtrObjectPtrTy;
187 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
188 llvm::PointerType *SelectorPtrTy;
191 /// ProtocolPtrTy - LLVM type for external protocol handles
192 /// (typeof(Protocol))
193 llvm::Type *ExternalProtocolPtrTy;
196 llvm::Type *getExternalProtocolPtrTy() {
197 if (!ExternalProtocolPtrTy) {
198 // FIXME: It would be nice to unify this with the opaque type, so that the
199 // IR comes out a bit cleaner.
200 CodeGen::CodeGenTypes &Types = CGM.getTypes();
201 ASTContext &Ctx = CGM.getContext();
202 llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
203 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
206 return ExternalProtocolPtrTy;
209 // SuperCTy - clang type for struct objc_super.
211 // SuperPtrCTy - clang type for struct objc_super *.
212 QualType SuperPtrCTy;
214 /// SuperTy - LLVM type for struct objc_super.
215 llvm::StructType *SuperTy;
216 /// SuperPtrTy - LLVM type for struct objc_super *.
217 llvm::PointerType *SuperPtrTy;
219 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
220 /// in GCC parlance).
221 llvm::StructType *PropertyTy;
223 /// PropertyListTy - LLVM type for struct objc_property_list
224 /// (_prop_list_t in GCC parlance).
225 llvm::StructType *PropertyListTy;
226 /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
227 llvm::PointerType *PropertyListPtrTy;
229 // MethodTy - LLVM type for struct objc_method.
230 llvm::StructType *MethodTy;
232 /// CacheTy - LLVM type for struct objc_cache.
234 /// CachePtrTy - LLVM type for struct objc_cache *.
235 llvm::PointerType *CachePtrTy;
237 llvm::Constant *getGetPropertyFn() {
238 CodeGen::CodeGenTypes &Types = CGM.getTypes();
239 ASTContext &Ctx = CGM.getContext();
240 // id objc_getProperty (id, SEL, ptrdiff_t, bool)
241 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
242 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
243 CanQualType Params[] = {
245 Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), Ctx.BoolTy};
246 llvm::FunctionType *FTy =
247 Types.GetFunctionType(
248 Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
249 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
252 llvm::Constant *getSetPropertyFn() {
253 CodeGen::CodeGenTypes &Types = CGM.getTypes();
254 ASTContext &Ctx = CGM.getContext();
255 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
256 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
257 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
258 CanQualType Params[] = {
261 Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(),
265 llvm::FunctionType *FTy =
266 Types.GetFunctionType(
267 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
268 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
271 llvm::Constant *getOptimizedSetPropertyFn(bool atomic, bool copy) {
272 CodeGen::CodeGenTypes &Types = CGM.getTypes();
273 ASTContext &Ctx = CGM.getContext();
274 // void objc_setProperty_atomic(id self, SEL _cmd,
275 // id newValue, ptrdiff_t offset);
276 // void objc_setProperty_nonatomic(id self, SEL _cmd,
277 // id newValue, ptrdiff_t offset);
278 // void objc_setProperty_atomic_copy(id self, SEL _cmd,
279 // id newValue, ptrdiff_t offset);
280 // void objc_setProperty_nonatomic_copy(id self, SEL _cmd,
281 // id newValue, ptrdiff_t offset);
283 SmallVector<CanQualType,4> Params;
284 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
285 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
286 Params.push_back(IdType);
287 Params.push_back(SelType);
288 Params.push_back(IdType);
289 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
290 llvm::FunctionType *FTy =
291 Types.GetFunctionType(
292 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
295 name = "objc_setProperty_atomic_copy";
296 else if (atomic && !copy)
297 name = "objc_setProperty_atomic";
298 else if (!atomic && copy)
299 name = "objc_setProperty_nonatomic_copy";
301 name = "objc_setProperty_nonatomic";
303 return CGM.CreateRuntimeFunction(FTy, name);
306 llvm::Constant *getCopyStructFn() {
307 CodeGen::CodeGenTypes &Types = CGM.getTypes();
308 ASTContext &Ctx = CGM.getContext();
309 // void objc_copyStruct (void *, const void *, size_t, bool, bool)
310 SmallVector<CanQualType,5> Params;
311 Params.push_back(Ctx.VoidPtrTy);
312 Params.push_back(Ctx.VoidPtrTy);
313 Params.push_back(Ctx.LongTy);
314 Params.push_back(Ctx.BoolTy);
315 Params.push_back(Ctx.BoolTy);
316 llvm::FunctionType *FTy =
317 Types.GetFunctionType(
318 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
319 return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
322 /// This routine declares and returns address of:
323 /// void objc_copyCppObjectAtomic(
324 /// void *dest, const void *src,
325 /// void (*copyHelper) (void *dest, const void *source));
326 llvm::Constant *getCppAtomicObjectFunction() {
327 CodeGen::CodeGenTypes &Types = CGM.getTypes();
328 ASTContext &Ctx = CGM.getContext();
329 /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
330 SmallVector<CanQualType,3> Params;
331 Params.push_back(Ctx.VoidPtrTy);
332 Params.push_back(Ctx.VoidPtrTy);
333 Params.push_back(Ctx.VoidPtrTy);
334 llvm::FunctionType *FTy =
335 Types.GetFunctionType(
336 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
337 return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
340 llvm::Constant *getEnumerationMutationFn() {
341 CodeGen::CodeGenTypes &Types = CGM.getTypes();
342 ASTContext &Ctx = CGM.getContext();
343 // void objc_enumerationMutation (id)
344 SmallVector<CanQualType,1> Params;
345 Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
346 llvm::FunctionType *FTy =
347 Types.GetFunctionType(
348 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
349 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
352 llvm::Constant *getLookUpClassFn() {
353 CodeGen::CodeGenTypes &Types = CGM.getTypes();
354 ASTContext &Ctx = CGM.getContext();
355 // Class objc_lookUpClass (const char *)
356 SmallVector<CanQualType,1> Params;
358 Ctx.getCanonicalType(Ctx.getPointerType(Ctx.CharTy.withConst())));
359 llvm::FunctionType *FTy =
360 Types.GetFunctionType(Types.arrangeBuiltinFunctionDeclaration(
361 Ctx.getCanonicalType(Ctx.getObjCClassType()),
363 return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass");
366 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
367 llvm::Constant *getGcReadWeakFn() {
368 // id objc_read_weak (id *)
369 llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
370 llvm::FunctionType *FTy =
371 llvm::FunctionType::get(ObjectPtrTy, args, false);
372 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
375 /// GcAssignWeakFn -- LLVM objc_assign_weak function.
376 llvm::Constant *getGcAssignWeakFn() {
377 // id objc_assign_weak (id, id *)
378 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
379 llvm::FunctionType *FTy =
380 llvm::FunctionType::get(ObjectPtrTy, args, false);
381 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
384 /// GcAssignGlobalFn -- LLVM objc_assign_global function.
385 llvm::Constant *getGcAssignGlobalFn() {
386 // id objc_assign_global(id, id *)
387 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
388 llvm::FunctionType *FTy =
389 llvm::FunctionType::get(ObjectPtrTy, args, false);
390 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
393 /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
394 llvm::Constant *getGcAssignThreadLocalFn() {
395 // id objc_assign_threadlocal(id src, id * dest)
396 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
397 llvm::FunctionType *FTy =
398 llvm::FunctionType::get(ObjectPtrTy, args, false);
399 return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
402 /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
403 llvm::Constant *getGcAssignIvarFn() {
404 // id objc_assign_ivar(id, id *, ptrdiff_t)
405 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
407 llvm::FunctionType *FTy =
408 llvm::FunctionType::get(ObjectPtrTy, args, false);
409 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
412 /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
413 llvm::Constant *GcMemmoveCollectableFn() {
414 // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
415 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
416 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
417 return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
420 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
421 llvm::Constant *getGcAssignStrongCastFn() {
422 // id objc_assign_strongCast(id, id *)
423 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
424 llvm::FunctionType *FTy =
425 llvm::FunctionType::get(ObjectPtrTy, args, false);
426 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
429 /// ExceptionThrowFn - LLVM objc_exception_throw function.
430 llvm::Constant *getExceptionThrowFn() {
431 // void objc_exception_throw(id)
432 llvm::Type *args[] = { ObjectPtrTy };
433 llvm::FunctionType *FTy =
434 llvm::FunctionType::get(CGM.VoidTy, args, false);
435 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
438 /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
439 llvm::Constant *getExceptionRethrowFn() {
440 // void objc_exception_rethrow(void)
441 llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
442 return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
445 /// SyncEnterFn - LLVM object_sync_enter function.
446 llvm::Constant *getSyncEnterFn() {
447 // int objc_sync_enter (id)
448 llvm::Type *args[] = { ObjectPtrTy };
449 llvm::FunctionType *FTy =
450 llvm::FunctionType::get(CGM.IntTy, args, false);
451 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
454 /// SyncExitFn - LLVM object_sync_exit function.
455 llvm::Constant *getSyncExitFn() {
456 // int objc_sync_exit (id)
457 llvm::Type *args[] = { ObjectPtrTy };
458 llvm::FunctionType *FTy =
459 llvm::FunctionType::get(CGM.IntTy, args, false);
460 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
463 llvm::Constant *getSendFn(bool IsSuper) const {
464 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
467 llvm::Constant *getSendFn2(bool IsSuper) const {
468 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
471 llvm::Constant *getSendStretFn(bool IsSuper) const {
472 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
475 llvm::Constant *getSendStretFn2(bool IsSuper) const {
476 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
479 llvm::Constant *getSendFpretFn(bool IsSuper) const {
480 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
483 llvm::Constant *getSendFpretFn2(bool IsSuper) const {
484 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
487 llvm::Constant *getSendFp2retFn(bool IsSuper) const {
488 return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
491 llvm::Constant *getSendFp2RetFn2(bool IsSuper) const {
492 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn();
495 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
498 /// ObjCTypesHelper - Helper class that encapsulates lazy
499 /// construction of varies types used during ObjC generation.
500 class ObjCTypesHelper : public ObjCCommonTypesHelper {
502 /// SymtabTy - LLVM type for struct objc_symtab.
503 llvm::StructType *SymtabTy;
504 /// SymtabPtrTy - LLVM type for struct objc_symtab *.
505 llvm::PointerType *SymtabPtrTy;
506 /// ModuleTy - LLVM type for struct objc_module.
507 llvm::StructType *ModuleTy;
509 /// ProtocolTy - LLVM type for struct objc_protocol.
510 llvm::StructType *ProtocolTy;
511 /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
512 llvm::PointerType *ProtocolPtrTy;
513 /// ProtocolExtensionTy - LLVM type for struct
514 /// objc_protocol_extension.
515 llvm::StructType *ProtocolExtensionTy;
516 /// ProtocolExtensionTy - LLVM type for struct
517 /// objc_protocol_extension *.
518 llvm::PointerType *ProtocolExtensionPtrTy;
519 /// MethodDescriptionTy - LLVM type for struct
520 /// objc_method_description.
521 llvm::StructType *MethodDescriptionTy;
522 /// MethodDescriptionListTy - LLVM type for struct
523 /// objc_method_description_list.
524 llvm::StructType *MethodDescriptionListTy;
525 /// MethodDescriptionListPtrTy - LLVM type for struct
526 /// objc_method_description_list *.
527 llvm::PointerType *MethodDescriptionListPtrTy;
528 /// ProtocolListTy - LLVM type for struct objc_property_list.
529 llvm::StructType *ProtocolListTy;
530 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
531 llvm::PointerType *ProtocolListPtrTy;
532 /// CategoryTy - LLVM type for struct objc_category.
533 llvm::StructType *CategoryTy;
534 /// ClassTy - LLVM type for struct objc_class.
535 llvm::StructType *ClassTy;
536 /// ClassPtrTy - LLVM type for struct objc_class *.
537 llvm::PointerType *ClassPtrTy;
538 /// ClassExtensionTy - LLVM type for struct objc_class_ext.
539 llvm::StructType *ClassExtensionTy;
540 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
541 llvm::PointerType *ClassExtensionPtrTy;
542 // IvarTy - LLVM type for struct objc_ivar.
543 llvm::StructType *IvarTy;
544 /// IvarListTy - LLVM type for struct objc_ivar_list.
545 llvm::StructType *IvarListTy;
546 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
547 llvm::PointerType *IvarListPtrTy;
548 /// MethodListTy - LLVM type for struct objc_method_list.
549 llvm::StructType *MethodListTy;
550 /// MethodListPtrTy - LLVM type for struct objc_method_list *.
551 llvm::PointerType *MethodListPtrTy;
553 /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
554 llvm::StructType *ExceptionDataTy;
556 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
557 llvm::Constant *getExceptionTryEnterFn() {
558 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
559 return CGM.CreateRuntimeFunction(
560 llvm::FunctionType::get(CGM.VoidTy, params, false),
561 "objc_exception_try_enter");
564 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
565 llvm::Constant *getExceptionTryExitFn() {
566 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
567 return CGM.CreateRuntimeFunction(
568 llvm::FunctionType::get(CGM.VoidTy, params, false),
569 "objc_exception_try_exit");
572 /// ExceptionExtractFn - LLVM objc_exception_extract function.
573 llvm::Constant *getExceptionExtractFn() {
574 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
575 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
577 "objc_exception_extract");
580 /// ExceptionMatchFn - LLVM objc_exception_match function.
581 llvm::Constant *getExceptionMatchFn() {
582 llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
583 return CGM.CreateRuntimeFunction(
584 llvm::FunctionType::get(CGM.Int32Ty, params, false),
585 "objc_exception_match");
588 /// SetJmpFn - LLVM _setjmp function.
589 llvm::Constant *getSetJmpFn() {
590 // This is specifically the prototype for x86.
591 llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
593 CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty,
596 llvm::AttributeSet::get(CGM.getLLVMContext(),
597 llvm::AttributeSet::FunctionIndex,
598 llvm::Attribute::NonLazyBind));
602 ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
605 /// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
607 class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
609 // MethodListnfABITy - LLVM for struct _method_list_t
610 llvm::StructType *MethodListnfABITy;
612 // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
613 llvm::PointerType *MethodListnfABIPtrTy;
615 // ProtocolnfABITy = LLVM for struct _protocol_t
616 llvm::StructType *ProtocolnfABITy;
618 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
619 llvm::PointerType *ProtocolnfABIPtrTy;
621 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
622 llvm::StructType *ProtocolListnfABITy;
624 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
625 llvm::PointerType *ProtocolListnfABIPtrTy;
627 // ClassnfABITy - LLVM for struct _class_t
628 llvm::StructType *ClassnfABITy;
630 // ClassnfABIPtrTy - LLVM for struct _class_t*
631 llvm::PointerType *ClassnfABIPtrTy;
633 // IvarnfABITy - LLVM for struct _ivar_t
634 llvm::StructType *IvarnfABITy;
636 // IvarListnfABITy - LLVM for struct _ivar_list_t
637 llvm::StructType *IvarListnfABITy;
639 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
640 llvm::PointerType *IvarListnfABIPtrTy;
642 // ClassRonfABITy - LLVM for struct _class_ro_t
643 llvm::StructType *ClassRonfABITy;
645 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
646 llvm::PointerType *ImpnfABITy;
648 // CategorynfABITy - LLVM for struct _category_t
649 llvm::StructType *CategorynfABITy;
651 // New types for nonfragile abi messaging.
653 // MessageRefTy - LLVM for:
654 // struct _message_ref_t {
658 llvm::StructType *MessageRefTy;
659 // MessageRefCTy - clang type for struct _message_ref_t
660 QualType MessageRefCTy;
662 // MessageRefPtrTy - LLVM for struct _message_ref_t*
663 llvm::Type *MessageRefPtrTy;
664 // MessageRefCPtrTy - clang type for struct _message_ref_t*
665 QualType MessageRefCPtrTy;
667 // SuperMessageRefTy - LLVM for:
668 // struct _super_message_ref_t {
669 // SUPER_IMP messenger;
672 llvm::StructType *SuperMessageRefTy;
674 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
675 llvm::PointerType *SuperMessageRefPtrTy;
677 llvm::Constant *getMessageSendFixupFn() {
678 // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
679 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
680 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
682 "objc_msgSend_fixup");
685 llvm::Constant *getMessageSendFpretFixupFn() {
686 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
687 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
688 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
690 "objc_msgSend_fpret_fixup");
693 llvm::Constant *getMessageSendStretFixupFn() {
694 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
695 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
696 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
698 "objc_msgSend_stret_fixup");
701 llvm::Constant *getMessageSendSuper2FixupFn() {
702 // id objc_msgSendSuper2_fixup (struct objc_super *,
703 // struct _super_message_ref_t*, ...)
704 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
705 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
707 "objc_msgSendSuper2_fixup");
710 llvm::Constant *getMessageSendSuper2StretFixupFn() {
711 // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
712 // struct _super_message_ref_t*, ...)
713 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
714 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
716 "objc_msgSendSuper2_stret_fixup");
719 llvm::Constant *getObjCEndCatchFn() {
720 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
725 llvm::Constant *getObjCBeginCatchFn() {
726 llvm::Type *params[] = { Int8PtrTy };
727 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
732 llvm::StructType *EHTypeTy;
733 llvm::Type *EHTypePtrTy;
735 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
738 enum class ObjCLabelType {
745 class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
751 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
752 : skip(_skip), scan(_scan) {}
755 /// opcode for captured block variables layout 'instructions'.
756 /// In the following descriptions, 'I' is the value of the immediate field.
757 /// (field following the opcode).
759 enum BLOCK_LAYOUT_OPCODE {
760 /// An operator which affects how the following layout should be
762 /// I == 0: Halt interpretation and treat everything else as
763 /// a non-pointer. Note that this instruction is equal
765 /// I != 0: Currently unused.
766 BLOCK_LAYOUT_OPERATOR = 0,
768 /// The next I+1 bytes do not contain a value of object pointer type.
769 /// Note that this can leave the stream unaligned, meaning that
770 /// subsequent word-size instructions do not begin at a multiple of
771 /// the pointer size.
772 BLOCK_LAYOUT_NON_OBJECT_BYTES = 1,
774 /// The next I+1 words do not contain a value of object pointer type.
775 /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
776 /// when the required skip quantity is a multiple of the pointer size.
777 BLOCK_LAYOUT_NON_OBJECT_WORDS = 2,
779 /// The next I+1 words are __strong pointers to Objective-C
780 /// objects or blocks.
781 BLOCK_LAYOUT_STRONG = 3,
783 /// The next I+1 words are pointers to __block variables.
784 BLOCK_LAYOUT_BYREF = 4,
786 /// The next I+1 words are __weak pointers to Objective-C
787 /// objects or blocks.
788 BLOCK_LAYOUT_WEAK = 5,
790 /// The next I+1 words are __unsafe_unretained pointers to
791 /// Objective-C objects or blocks.
792 BLOCK_LAYOUT_UNRETAINED = 6
794 /// The next I+1 words are block or object pointers with some
795 /// as-yet-unspecified ownership semantics. If we add more
796 /// flavors of ownership semantics, values will be taken from
799 /// This is included so that older tools can at least continue
800 /// processing the layout past such things.
801 //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
803 /// All other opcodes are reserved. Halt interpretation and
804 /// treat everything else as opaque.
809 enum BLOCK_LAYOUT_OPCODE opcode;
810 CharUnits block_var_bytepos;
811 CharUnits block_var_size;
812 RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
813 CharUnits BytePos = CharUnits::Zero(),
814 CharUnits Size = CharUnits::Zero())
815 : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {}
817 // Allow sorting based on byte pos.
818 bool operator<(const RUN_SKIP &b) const {
819 return block_var_bytepos < b.block_var_bytepos;
824 llvm::LLVMContext &VMContext;
825 // FIXME! May not be needing this after all.
828 // arc/mrr layout of captured block literal variables.
829 SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
831 /// LazySymbols - Symbols to generate a lazy reference for. See
832 /// DefinedSymbols and FinishModule().
833 llvm::SetVector<IdentifierInfo*> LazySymbols;
835 /// DefinedSymbols - External symbols which are defined by this
836 /// module. The symbols in this list and LazySymbols are used to add
837 /// special linker symbols which ensure that Objective-C modules are
839 llvm::SetVector<IdentifierInfo*> DefinedSymbols;
841 /// ClassNames - uniqued class names.
842 llvm::StringMap<llvm::GlobalVariable*> ClassNames;
844 /// MethodVarNames - uniqued method variable names.
845 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
847 /// DefinedCategoryNames - list of category names in form Class_Category.
848 llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames;
850 /// MethodVarTypes - uniqued method type signatures. We have to use
851 /// a StringMap here because have no other unique reference.
852 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
854 /// MethodDefinitions - map of methods which have been defined in
855 /// this translation unit.
856 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
858 /// PropertyNames - uniqued method variable names.
859 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
861 /// ClassReferences - uniqued class references.
862 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
864 /// SelectorReferences - uniqued selector references.
865 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
867 /// Protocols - Protocols for which an objc_protocol structure has
868 /// been emitted. Forward declarations are handled by creating an
869 /// empty structure whose initializer is filled in when/if defined.
870 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
872 /// DefinedProtocols - Protocols which have actually been
873 /// defined. We should not need this, see FIXME in GenerateProtocol.
874 llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
876 /// DefinedClasses - List of defined classes.
877 SmallVector<llvm::GlobalValue*, 16> DefinedClasses;
879 /// ImplementedClasses - List of @implemented classes.
880 SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses;
882 /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
883 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
885 /// DefinedCategories - List of defined categories.
886 SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
888 /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
889 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
891 /// Cached reference to the class for constant strings. This value has type
892 /// int * but is actually an Obj-C class pointer.
893 llvm::WeakVH ConstantStringClassRef;
895 /// \brief The LLVM type corresponding to NSConstantString.
896 llvm::StructType *NSConstantStringType = nullptr;
898 llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap;
900 /// GetNameForMethod - Return a name for the given method.
901 /// \param[out] NameOut - The return value.
902 void GetNameForMethod(const ObjCMethodDecl *OMD,
903 const ObjCContainerDecl *CD,
904 SmallVectorImpl<char> &NameOut);
906 /// GetMethodVarName - Return a unique constant for the given
907 /// selector's name. The return value has type char *.
908 llvm::Constant *GetMethodVarName(Selector Sel);
909 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
911 /// GetMethodVarType - Return a unique constant for the given
912 /// method's type encoding string. The return value has type char *.
914 // FIXME: This is a horrible name.
915 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
916 bool Extended = false);
917 llvm::Constant *GetMethodVarType(const FieldDecl *D);
919 /// GetPropertyName - Return a unique constant for the given
920 /// name. The return value has type char *.
921 llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
923 // FIXME: This can be dropped once string functions are unified.
924 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
925 const Decl *Container);
927 /// GetClassName - Return a unique constant for the given selector's
928 /// runtime name (which may change via use of objc_runtime_name attribute on
929 /// class or protocol definition. The return value has type char *.
930 llvm::Constant *GetClassName(StringRef RuntimeName);
932 llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
934 /// BuildIvarLayout - Builds ivar layout bitmap for the class
935 /// implementation for the __strong or __weak case.
937 /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there
938 /// are any weak ivars defined directly in the class. Meaningless unless
939 /// building a weak layout. Does not guarantee that the layout will
940 /// actually have any entries, because the ivar might be under-aligned.
941 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
942 CharUnits beginOffset,
944 bool forStrongLayout,
945 bool hasMRCWeakIvars);
947 llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,
948 CharUnits beginOffset,
949 CharUnits endOffset) {
950 return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
953 llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
954 CharUnits beginOffset,
956 bool hasMRCWeakIvars) {
957 return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
960 Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
962 void UpdateRunSkipBlockVars(bool IsByref,
963 Qualifiers::ObjCLifetime LifeTime,
964 CharUnits FieldOffset,
965 CharUnits FieldSize);
967 void BuildRCBlockVarRecordLayout(const RecordType *RT,
968 CharUnits BytePos, bool &HasUnion,
969 bool ByrefLayout=false);
971 void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
972 const RecordDecl *RD,
973 ArrayRef<const FieldDecl*> RecFields,
974 CharUnits BytePos, bool &HasUnion,
977 uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
979 llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
981 /// GetIvarLayoutName - Returns a unique constant for the given
982 /// ivar layout bitmap.
983 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
984 const ObjCCommonTypesHelper &ObjCTypes);
986 /// EmitPropertyList - Emit the given property list. The return
987 /// value has type PropertyListPtrTy.
988 llvm::Constant *EmitPropertyList(Twine Name,
989 const Decl *Container,
990 const ObjCContainerDecl *OCD,
991 const ObjCCommonTypesHelper &ObjCTypes,
992 bool IsClassProperty);
994 /// EmitProtocolMethodTypes - Generate the array of extended method type
995 /// strings. The return value has type Int8PtrPtrTy.
996 llvm::Constant *EmitProtocolMethodTypes(Twine Name,
997 ArrayRef<llvm::Constant*> MethodTypes,
998 const ObjCCommonTypesHelper &ObjCTypes);
1000 /// GetProtocolRef - Return a reference to the internal protocol
1001 /// description, creating an empty one if it has not been
1002 /// defined. The return value has type ProtocolPtrTy.
1003 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
1005 /// Return a reference to the given Class using runtime calls rather than
1006 /// by a symbol reference.
1007 llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,
1008 const ObjCInterfaceDecl *ID,
1009 ObjCCommonTypesHelper &ObjCTypes);
1012 /// CreateMetadataVar - Create a global variable with internal
1013 /// linkage for use by the Objective-C runtime.
1015 /// This is a convenience wrapper which not only creates the
1016 /// variable, but also sets the section and alignment and adds the
1017 /// global to the "llvm.used" list.
1019 /// \param Name - The variable name.
1020 /// \param Init - The variable initializer; this is also used to
1021 /// define the type of the variable.
1022 /// \param Section - The section the variable should go into, or empty.
1023 /// \param Align - The alignment for the variable, or 0.
1024 /// \param AddToUsed - Whether the variable should be added to
1026 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1027 ConstantStructBuilder &Init,
1028 StringRef Section, CharUnits Align,
1030 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1031 llvm::Constant *Init,
1032 StringRef Section, CharUnits Align,
1035 llvm::GlobalVariable *CreateCStringLiteral(StringRef Name,
1036 ObjCLabelType LabelType,
1037 bool ForceNonFragileABI = false,
1038 bool NullTerminate = true);
1041 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1042 ReturnValueSlot Return,
1043 QualType ResultType,
1048 const CallArgList &CallArgs,
1049 const ObjCMethodDecl *OMD,
1050 const ObjCInterfaceDecl *ClassReceiver,
1051 const ObjCCommonTypesHelper &ObjCTypes);
1053 /// EmitImageInfo - Emit the image info marker used to encode some module
1054 /// level information.
1055 void EmitImageInfo();
1058 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) :
1059 CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) { }
1061 bool isNonFragileABI() const {
1062 return ObjCABI == 2;
1065 ConstantAddress GenerateConstantString(const StringLiteral *SL) override;
1066 ConstantAddress GenerateConstantNSString(const StringLiteral *SL);
1068 llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1069 const ObjCContainerDecl *CD=nullptr) override;
1071 void GenerateProtocol(const ObjCProtocolDecl *PD) override;
1073 /// GetOrEmitProtocol - Get the protocol object for the given
1074 /// declaration, emitting it if necessary. The return value has type
1076 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
1078 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1079 /// object for the given declaration, emitting it if needed. These
1080 /// forward references will be filled in with empty bodies if no
1081 /// definition is seen. The return value has type ProtocolPtrTy.
1082 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1084 virtual llvm::Constant *getNSConstantStringClassRef() = 0;
1086 llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1087 const CGBlockInfo &blockInfo) override;
1088 llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1089 const CGBlockInfo &blockInfo) override;
1091 llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1092 QualType T) override;
1097 enum class MethodListType {
1098 CategoryInstanceMethods,
1099 CategoryClassMethods,
1102 ProtocolInstanceMethods,
1103 ProtocolClassMethods,
1104 OptionalProtocolInstanceMethods,
1105 OptionalProtocolClassMethods,
1108 /// A convenience class for splitting the methods of a protocol into
1109 /// the four interesting groups.
1110 class ProtocolMethodLists {
1113 RequiredInstanceMethods,
1114 RequiredClassMethods,
1115 OptionalInstanceMethods,
1116 OptionalClassMethods
1119 NumProtocolMethodLists = 4
1122 static MethodListType getMethodListKind(Kind kind) {
1124 case RequiredInstanceMethods:
1125 return MethodListType::ProtocolInstanceMethods;
1126 case RequiredClassMethods:
1127 return MethodListType::ProtocolClassMethods;
1128 case OptionalInstanceMethods:
1129 return MethodListType::OptionalProtocolInstanceMethods;
1130 case OptionalClassMethods:
1131 return MethodListType::OptionalProtocolClassMethods;
1133 llvm_unreachable("bad kind");
1136 SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists];
1138 static ProtocolMethodLists get(const ObjCProtocolDecl *PD) {
1139 ProtocolMethodLists result;
1141 for (auto MD : PD->methods()) {
1142 size_t index = (2 * size_t(MD->isOptional()))
1143 + (size_t(MD->isClassMethod()));
1144 result.Methods[index].push_back(MD);
1150 template <class Self>
1151 SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const {
1152 // In both ABIs, the method types list is parallel with the
1153 // concatenation of the methods arrays in the following order:
1156 // optional instance methods
1157 // optional class methods
1158 SmallVector<llvm::Constant*, 8> result;
1160 // Methods is already in the correct order for both ABIs.
1161 for (auto &list : Methods) {
1162 for (auto MD : list) {
1163 result.push_back(self->GetMethodVarType(MD, true));
1170 template <class Self>
1171 llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD,
1173 return self->emitMethodList(PD->getObjCRuntimeNameAsString(),
1174 getMethodListKind(kind), Methods[kind]);
1178 } // end anonymous namespace
1180 class CGObjCMac : public CGObjCCommonMac {
1182 friend ProtocolMethodLists;
1184 ObjCTypesHelper ObjCTypes;
1186 /// EmitModuleInfo - Another marker encoding module level
1188 void EmitModuleInfo();
1190 /// EmitModuleSymols - Emit module symbols, the list of defined
1191 /// classes and categories. The result has type SymtabPtrTy.
1192 llvm::Constant *EmitModuleSymbols();
1194 /// FinishModule - Write out global data structures at the end of
1195 /// processing a translation unit.
1196 void FinishModule();
1198 /// EmitClassExtension - Generate the class extension structure used
1199 /// to store the weak ivar layout and properties. The return value
1200 /// has type ClassExtensionPtrTy.
1201 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID,
1202 CharUnits instanceSize,
1203 bool hasMRCWeakIvars,
1206 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1207 /// for the given class.
1208 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1209 const ObjCInterfaceDecl *ID);
1211 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1212 IdentifierInfo *II);
1214 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1216 /// EmitSuperClassRef - Emits reference to class's main metadata class.
1217 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1219 /// EmitIvarList - Emit the ivar list for the given
1220 /// implementation. If ForClass is true the list of class ivars
1221 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1222 /// interface ivars will be emitted. The return value has type
1224 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1227 /// EmitMetaClass - Emit a forward reference to the class structure
1228 /// for the metaclass of the given interface. The return value has
1229 /// type ClassPtrTy.
1230 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1232 /// EmitMetaClass - Emit a class structure for the metaclass of the
1233 /// given implementation. The return value has type ClassPtrTy.
1234 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1235 llvm::Constant *Protocols,
1236 ArrayRef<const ObjCMethodDecl *> Methods);
1238 void emitMethodConstant(ConstantArrayBuilder &builder,
1239 const ObjCMethodDecl *MD);
1241 void emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
1242 const ObjCMethodDecl *MD);
1244 /// EmitMethodList - Emit the method list for the given
1245 /// implementation. The return value has type MethodListPtrTy.
1246 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1247 ArrayRef<const ObjCMethodDecl *> Methods);
1249 /// GetOrEmitProtocol - Get the protocol object for the given
1250 /// declaration, emitting it if necessary. The return value has type
1252 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1254 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1255 /// object for the given declaration, emitting it if needed. These
1256 /// forward references will be filled in with empty bodies if no
1257 /// definition is seen. The return value has type ProtocolPtrTy.
1258 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1260 /// EmitProtocolExtension - Generate the protocol extension
1261 /// structure used to store optional instance and class methods, and
1262 /// protocol properties. The return value has type
1263 /// ProtocolExtensionPtrTy.
1265 EmitProtocolExtension(const ObjCProtocolDecl *PD,
1266 const ProtocolMethodLists &methodLists);
1268 /// EmitProtocolList - Generate the list of referenced
1269 /// protocols. The return value has type ProtocolListPtrTy.
1270 llvm::Constant *EmitProtocolList(Twine Name,
1271 ObjCProtocolDecl::protocol_iterator begin,
1272 ObjCProtocolDecl::protocol_iterator end);
1274 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1275 /// for the given selector.
1276 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1277 Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1280 CGObjCMac(CodeGen::CodeGenModule &cgm);
1282 llvm::Constant *getNSConstantStringClassRef() override;
1284 llvm::Function *ModuleInitFunction() override;
1286 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1287 ReturnValueSlot Return,
1288 QualType ResultType,
1289 Selector Sel, llvm::Value *Receiver,
1290 const CallArgList &CallArgs,
1291 const ObjCInterfaceDecl *Class,
1292 const ObjCMethodDecl *Method) override;
1295 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1296 ReturnValueSlot Return, QualType ResultType,
1297 Selector Sel, const ObjCInterfaceDecl *Class,
1298 bool isCategoryImpl, llvm::Value *Receiver,
1299 bool IsClassMessage, const CallArgList &CallArgs,
1300 const ObjCMethodDecl *Method) override;
1302 llvm::Value *GetClass(CodeGenFunction &CGF,
1303 const ObjCInterfaceDecl *ID) override;
1305 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
1306 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
1308 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1310 llvm::Value *GetSelector(CodeGenFunction &CGF,
1311 const ObjCMethodDecl *Method) override;
1313 llvm::Constant *GetEHType(QualType T) override;
1315 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1317 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1319 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1321 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1322 const ObjCProtocolDecl *PD) override;
1324 llvm::Constant *GetPropertyGetFunction() override;
1325 llvm::Constant *GetPropertySetFunction() override;
1326 llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1327 bool copy) override;
1328 llvm::Constant *GetGetStructFunction() override;
1329 llvm::Constant *GetSetStructFunction() override;
1330 llvm::Constant *GetCppAtomicObjectGetFunction() override;
1331 llvm::Constant *GetCppAtomicObjectSetFunction() override;
1332 llvm::Constant *EnumerationMutationFunction() override;
1334 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1335 const ObjCAtTryStmt &S) override;
1336 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1337 const ObjCAtSynchronizedStmt &S) override;
1338 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1339 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1340 bool ClearInsertionPoint=true) override;
1341 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1342 Address AddrWeakObj) override;
1343 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1344 llvm::Value *src, Address dst) override;
1345 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1346 llvm::Value *src, Address dest,
1347 bool threadlocal = false) override;
1348 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1349 llvm::Value *src, Address dest,
1350 llvm::Value *ivarOffset) override;
1351 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1352 llvm::Value *src, Address dest) override;
1353 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1354 Address dest, Address src,
1355 llvm::Value *size) override;
1357 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1358 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1359 unsigned CVRQualifiers) override;
1360 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1361 const ObjCInterfaceDecl *Interface,
1362 const ObjCIvarDecl *Ivar) override;
1365 class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1367 friend ProtocolMethodLists;
1368 ObjCNonFragileABITypesHelper ObjCTypes;
1369 llvm::GlobalVariable* ObjCEmptyCacheVar;
1370 llvm::Constant* ObjCEmptyVtableVar;
1372 /// SuperClassReferences - uniqued super class references.
1373 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1375 /// MetaClassReferences - uniqued meta class references.
1376 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1378 /// EHTypeReferences - uniqued class ehtype references.
1379 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1381 /// VTableDispatchMethods - List of methods for which we generate
1382 /// vtable-based message dispatch.
1383 llvm::DenseSet<Selector> VTableDispatchMethods;
1385 /// DefinedMetaClasses - List of defined meta-classes.
1386 std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1388 /// isVTableDispatchedSelector - Returns true if SEL is a
1389 /// vtable-based selector.
1390 bool isVTableDispatchedSelector(Selector Sel);
1392 /// FinishNonFragileABIModule - Write out global data structures at the end of
1393 /// processing a translation unit.
1394 void FinishNonFragileABIModule();
1396 /// AddModuleClassList - Add the given list of class pointers to the
1397 /// module with the provided symbol and section names.
1398 void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container,
1399 StringRef SymbolName, StringRef SectionName);
1401 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1402 unsigned InstanceStart,
1403 unsigned InstanceSize,
1404 const ObjCImplementationDecl *ID);
1405 llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI,
1407 llvm::Constant *IsAGV,
1408 llvm::Constant *SuperClassGV,
1409 llvm::Constant *ClassRoGV,
1410 bool HiddenVisibility);
1412 void emitMethodConstant(ConstantArrayBuilder &builder,
1413 const ObjCMethodDecl *MD,
1416 /// Emit the method list for the given implementation. The return value
1417 /// has type MethodListnfABITy.
1418 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1419 ArrayRef<const ObjCMethodDecl *> Methods);
1421 /// EmitIvarList - Emit the ivar list for the given
1422 /// implementation. If ForClass is true the list of class ivars
1423 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1424 /// interface ivars will be emitted. The return value has type
1425 /// IvarListnfABIPtrTy.
1426 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
1428 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1429 const ObjCIvarDecl *Ivar,
1430 unsigned long int offset);
1432 /// GetOrEmitProtocol - Get the protocol object for the given
1433 /// declaration, emitting it if necessary. The return value has type
1435 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1437 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1438 /// object for the given declaration, emitting it if needed. These
1439 /// forward references will be filled in with empty bodies if no
1440 /// definition is seen. The return value has type ProtocolPtrTy.
1441 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1443 /// EmitProtocolList - Generate the list of referenced
1444 /// protocols. The return value has type ProtocolListPtrTy.
1445 llvm::Constant *EmitProtocolList(Twine Name,
1446 ObjCProtocolDecl::protocol_iterator begin,
1447 ObjCProtocolDecl::protocol_iterator end);
1449 CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1450 ReturnValueSlot Return,
1451 QualType ResultType,
1453 llvm::Value *Receiver,
1456 const CallArgList &CallArgs,
1457 const ObjCMethodDecl *Method);
1459 /// GetClassGlobal - Return the global variable for the Objective-C
1460 /// class of the given name.
1461 llvm::Constant *GetClassGlobal(StringRef Name,
1462 ForDefinition_t IsForDefinition,
1463 bool Weak = false, bool DLLImport = false);
1464 llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID,
1466 ForDefinition_t isForDefinition);
1468 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1469 /// for the given class reference.
1470 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1471 const ObjCInterfaceDecl *ID);
1473 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1475 const ObjCInterfaceDecl *ID);
1477 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1479 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1480 /// for the given super class reference.
1481 llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1482 const ObjCInterfaceDecl *ID);
1484 /// EmitMetaClassRef - Return a Value * of the address of _class_t
1486 llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1487 const ObjCInterfaceDecl *ID, bool Weak);
1489 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1492 llvm::GlobalVariable * ObjCIvarOffsetVariable(
1493 const ObjCInterfaceDecl *ID,
1494 const ObjCIvarDecl *Ivar);
1496 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1497 /// for the given selector.
1498 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1499 Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1501 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1502 /// interface. The return value has type EHTypePtrTy.
1503 llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1504 ForDefinition_t IsForDefinition);
1506 StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }
1508 StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; }
1510 void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1511 uint32_t &InstanceStart,
1512 uint32_t &InstanceSize);
1514 // Shamelessly stolen from Analysis/CFRefCount.cpp
1515 Selector GetNullarySelector(const char* name) const {
1516 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1517 return CGM.getContext().Selectors.getSelector(0, &II);
1520 Selector GetUnarySelector(const char* name) const {
1521 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1522 return CGM.getContext().Selectors.getSelector(1, &II);
1525 /// ImplementationIsNonLazy - Check whether the given category or
1526 /// class implementation is "non-lazy".
1527 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1529 bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1530 const ObjCIvarDecl *IV) {
1531 // Annotate the load as an invariant load iff inside an instance method
1532 // and ivar belongs to instance method's class and one of its super class.
1533 // This check is needed because the ivar offset is a lazily
1534 // initialised value that may depend on objc_msgSend to perform a fixup on
1535 // the first message dispatch.
1537 // An additional opportunity to mark the load as invariant arises when the
1538 // base of the ivar access is a parameter to an Objective C method.
1539 // However, because the parameters are not available in the current
1540 // interface, we cannot perform this check.
1541 if (const ObjCMethodDecl *MD =
1542 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1543 if (MD->isInstanceMethod())
1544 if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1545 return IV->getContainingInterface()->isSuperClassOf(ID);
1550 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1552 llvm::Constant *getNSConstantStringClassRef() override;
1554 llvm::Function *ModuleInitFunction() override;
1556 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1557 ReturnValueSlot Return,
1558 QualType ResultType, Selector Sel,
1559 llvm::Value *Receiver,
1560 const CallArgList &CallArgs,
1561 const ObjCInterfaceDecl *Class,
1562 const ObjCMethodDecl *Method) override;
1565 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1566 ReturnValueSlot Return, QualType ResultType,
1567 Selector Sel, const ObjCInterfaceDecl *Class,
1568 bool isCategoryImpl, llvm::Value *Receiver,
1569 bool IsClassMessage, const CallArgList &CallArgs,
1570 const ObjCMethodDecl *Method) override;
1572 llvm::Value *GetClass(CodeGenFunction &CGF,
1573 const ObjCInterfaceDecl *ID) override;
1575 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override
1576 { return EmitSelector(CGF, Sel); }
1577 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
1578 { return EmitSelectorAddr(CGF, Sel); }
1580 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1582 llvm::Value *GetSelector(CodeGenFunction &CGF,
1583 const ObjCMethodDecl *Method) override
1584 { return EmitSelector(CGF, Method->getSelector()); }
1586 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1588 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1590 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1592 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1593 const ObjCProtocolDecl *PD) override;
1595 llvm::Constant *GetEHType(QualType T) override;
1597 llvm::Constant *GetPropertyGetFunction() override {
1598 return ObjCTypes.getGetPropertyFn();
1600 llvm::Constant *GetPropertySetFunction() override {
1601 return ObjCTypes.getSetPropertyFn();
1604 llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1605 bool copy) override {
1606 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1609 llvm::Constant *GetSetStructFunction() override {
1610 return ObjCTypes.getCopyStructFn();
1613 llvm::Constant *GetGetStructFunction() override {
1614 return ObjCTypes.getCopyStructFn();
1617 llvm::Constant *GetCppAtomicObjectSetFunction() override {
1618 return ObjCTypes.getCppAtomicObjectFunction();
1621 llvm::Constant *GetCppAtomicObjectGetFunction() override {
1622 return ObjCTypes.getCppAtomicObjectFunction();
1625 llvm::Constant *EnumerationMutationFunction() override {
1626 return ObjCTypes.getEnumerationMutationFn();
1629 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1630 const ObjCAtTryStmt &S) override;
1631 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1632 const ObjCAtSynchronizedStmt &S) override;
1633 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1634 bool ClearInsertionPoint=true) override;
1635 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1636 Address AddrWeakObj) override;
1637 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1638 llvm::Value *src, Address edst) override;
1639 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1640 llvm::Value *src, Address dest,
1641 bool threadlocal = false) override;
1642 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1643 llvm::Value *src, Address dest,
1644 llvm::Value *ivarOffset) override;
1645 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1646 llvm::Value *src, Address dest) override;
1647 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1648 Address dest, Address src,
1649 llvm::Value *size) override;
1650 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1651 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1652 unsigned CVRQualifiers) override;
1653 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1654 const ObjCInterfaceDecl *Interface,
1655 const ObjCIvarDecl *Ivar) override;
1658 /// A helper class for performing the null-initialization of a return
1660 struct NullReturnState {
1661 llvm::BasicBlock *NullBB;
1662 NullReturnState() : NullBB(nullptr) {}
1664 /// Perform a null-check of the given receiver.
1665 void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1666 // Make blocks for the null-receiver and call edges.
1667 NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1668 llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1670 // Check for a null receiver and, if there is one, jump to the
1671 // null-receiver block. There's no point in trying to avoid it:
1672 // we're always going to put *something* there, because otherwise
1673 // we shouldn't have done this null-check in the first place.
1674 llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1675 CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1677 // Otherwise, start performing the call.
1678 CGF.EmitBlock(callBB);
1681 /// Complete the null-return operation. It is valid to call this
1682 /// regardless of whether 'init' has been called.
1683 RValue complete(CodeGenFunction &CGF, RValue result, QualType resultType,
1684 const CallArgList &CallArgs,
1685 const ObjCMethodDecl *Method) {
1686 // If we never had to do a null-check, just use the raw result.
1687 if (!NullBB) return result;
1689 // The continuation block. This will be left null if we don't have an
1690 // IP, which can happen if the method we're calling is marked noreturn.
1691 llvm::BasicBlock *contBB = nullptr;
1693 // Finish the call path.
1694 llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1696 contBB = CGF.createBasicBlock("msgSend.cont");
1697 CGF.Builder.CreateBr(contBB);
1700 // Okay, start emitting the null-receiver block.
1701 CGF.EmitBlock(NullBB);
1703 // Release any consumed arguments we've got.
1705 CallArgList::const_iterator I = CallArgs.begin();
1706 for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
1707 e = Method->param_end(); i != e; ++i, ++I) {
1708 const ParmVarDecl *ParamDecl = (*i);
1709 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1711 assert(RV.isScalar() &&
1712 "NullReturnState::complete - arg not on object");
1713 CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime);
1718 // The phi code below assumes that we haven't needed any control flow yet.
1719 assert(CGF.Builder.GetInsertBlock() == NullBB);
1721 // If we've got a void return, just jump to the continuation block.
1722 if (result.isScalar() && resultType->isVoidType()) {
1723 // No jumps required if the message-send was noreturn.
1724 if (contBB) CGF.EmitBlock(contBB);
1728 // If we've got a scalar return, build a phi.
1729 if (result.isScalar()) {
1730 // Derive the null-initialization value.
1731 llvm::Constant *null = CGF.CGM.EmitNullConstant(resultType);
1733 // If no join is necessary, just flow out.
1734 if (!contBB) return RValue::get(null);
1736 // Otherwise, build a phi.
1737 CGF.EmitBlock(contBB);
1738 llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1739 phi->addIncoming(result.getScalarVal(), callBB);
1740 phi->addIncoming(null, NullBB);
1741 return RValue::get(phi);
1744 // If we've got an aggregate return, null the buffer out.
1745 // FIXME: maybe we should be doing things differently for all the
1746 // cases where the ABI has us returning (1) non-agg values in
1747 // memory or (2) agg values in registers.
1748 if (result.isAggregate()) {
1749 assert(result.isAggregate() && "null init of non-aggregate result?");
1750 CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
1751 if (contBB) CGF.EmitBlock(contBB);
1756 CGF.EmitBlock(contBB);
1757 CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1759 // Find the scalar type and its zero value.
1760 llvm::Type *scalarTy = callResult.first->getType();
1761 llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1763 // Build phis for both coordinates.
1764 llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1765 real->addIncoming(callResult.first, callBB);
1766 real->addIncoming(scalarZero, NullBB);
1767 llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1768 imag->addIncoming(callResult.second, callBB);
1769 imag->addIncoming(scalarZero, NullBB);
1770 return RValue::getComplex(real, imag);
1774 } // end anonymous namespace
1776 /* *** Helper Functions *** */
1778 /// getConstantGEP() - Help routine to construct simple GEPs.
1779 static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1780 llvm::GlobalVariable *C, unsigned idx0,
1782 llvm::Value *Idxs[] = {
1783 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1784 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1786 return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1789 /// hasObjCExceptionAttribute - Return true if this class or any super
1790 /// class has the __objc_exception__ attribute.
1791 static bool hasObjCExceptionAttribute(ASTContext &Context,
1792 const ObjCInterfaceDecl *OID) {
1793 if (OID->hasAttr<ObjCExceptionAttr>())
1795 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1796 return hasObjCExceptionAttribute(Context, Super);
1800 /* *** CGObjCMac Public Interface *** */
1802 CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1808 /// GetClass - Return a reference to the class for the given interface
1810 llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1811 const ObjCInterfaceDecl *ID) {
1812 return EmitClassRef(CGF, ID);
1815 /// GetSelector - Return the pointer to the unique'd string for this selector.
1816 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1817 return EmitSelector(CGF, Sel);
1819 Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1820 return EmitSelectorAddr(CGF, Sel);
1822 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1824 return EmitSelector(CGF, Method->getSelector());
1827 llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1828 if (T->isObjCIdType() ||
1829 T->isObjCQualifiedIdType()) {
1830 return CGM.GetAddrOfRTTIDescriptor(
1831 CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1833 if (T->isObjCClassType() ||
1834 T->isObjCQualifiedClassType()) {
1835 return CGM.GetAddrOfRTTIDescriptor(
1836 CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1838 if (T->isObjCObjectPointerType())
1839 return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true);
1841 llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1844 /// Generate a constant CFString object.
1846 struct __builtin_CFString {
1847 const int *isa; // point to __CFConstantStringClassReference
1854 /// or Generate a constant NSString object.
1856 struct __builtin_NSString {
1857 const int *isa; // point to __NSConstantStringClassReference
1859 unsigned int length;
1864 CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) {
1865 return (!CGM.getLangOpts().NoConstantCFStrings
1866 ? CGM.GetAddrOfConstantCFString(SL)
1867 : GenerateConstantNSString(SL));
1870 static llvm::StringMapEntry<llvm::GlobalVariable *> &
1871 GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
1872 const StringLiteral *Literal, unsigned &StringLength) {
1873 StringRef String = Literal->getString();
1874 StringLength = String.size();
1875 return *Map.insert(std::make_pair(String, nullptr)).first;
1878 llvm::Constant *CGObjCMac::getNSConstantStringClassRef() {
1879 if (llvm::Value *V = ConstantStringClassRef)
1880 return cast<llvm::Constant>(V);
1882 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1884 StringClass.empty() ? "_NSConstantStringClassReference"
1885 : "_" + StringClass + "ClassReference";
1887 llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
1888 auto GV = CGM.CreateRuntimeVariable(PTy, str);
1889 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1890 ConstantStringClassRef = V;
1894 llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() {
1895 if (llvm::Value *V = ConstantStringClassRef)
1896 return cast<llvm::Constant>(V);
1898 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1900 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
1901 : "OBJC_CLASS_$_" + StringClass;
1902 auto GV = GetClassGlobal(str, NotForDefinition);
1904 // Make sure the result is of the correct type.
1905 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1907 ConstantStringClassRef = V;
1912 CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) {
1913 unsigned StringLength = 0;
1914 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
1915 GetConstantStringEntry(NSConstantStringMap, Literal, StringLength);
1917 if (auto *C = Entry.second)
1918 return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
1920 // If we don't already have it, get _NSConstantStringClassReference.
1921 llvm::Constant *Class = getNSConstantStringClassRef();
1923 // If we don't already have it, construct the type for a constant NSString.
1924 if (!NSConstantStringType) {
1925 NSConstantStringType =
1926 llvm::StructType::create({
1927 CGM.Int32Ty->getPointerTo(),
1930 }, "struct.__builtin_NSString");
1933 ConstantInitBuilder Builder(CGM);
1934 auto Fields = Builder.beginStruct(NSConstantStringType);
1941 llvm::ConstantDataArray::getString(VMContext, Entry.first());
1943 llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage;
1944 bool isConstant = !CGM.getLangOpts().WritableStrings;
1946 auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant,
1947 Linkage, C, ".str");
1948 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1949 // Don't enforce the target's minimum global alignment, since the only use
1950 // of the string is via this class initializer.
1951 GV->setAlignment(1);
1952 Fields.addBitCast(GV, CGM.Int8PtrTy);
1955 Fields.addInt(CGM.IntTy, StringLength);
1958 CharUnits Alignment = CGM.getPointerAlign();
1959 GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
1961 llvm::GlobalVariable::PrivateLinkage);
1962 const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
1963 const char *NSStringNonFragileABISection =
1964 "__DATA,__objc_stringobj,regular,no_dead_strip";
1965 // FIXME. Fix section.
1966 GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
1967 ? NSStringNonFragileABISection
1971 return ConstantAddress(GV, Alignment);
1975 kCFTaggedObjectID_Integer = (1 << 1) + 1
1978 /// Generates a message send where the super is the receiver. This is
1979 /// a message send to self with special delivery semantics indicating
1980 /// which class's method should be called.
1982 CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1983 ReturnValueSlot Return,
1984 QualType ResultType,
1986 const ObjCInterfaceDecl *Class,
1987 bool isCategoryImpl,
1988 llvm::Value *Receiver,
1989 bool IsClassMessage,
1990 const CodeGen::CallArgList &CallArgs,
1991 const ObjCMethodDecl *Method) {
1992 // Create and init a super structure; this is a (receiver, class)
1993 // pair we will pass to objc_msgSendSuper.
1995 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
1997 llvm::Value *ReceiverAsObject =
1998 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
1999 CGF.Builder.CreateStore(
2001 CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
2003 // If this is a class message the metaclass is passed as the target.
2004 llvm::Value *Target;
2005 if (IsClassMessage) {
2006 if (isCategoryImpl) {
2007 // Message sent to 'super' in a class method defined in a category
2008 // implementation requires an odd treatment.
2009 // If we are in a class method, we must retrieve the
2010 // _metaclass_ for the current class, pointed at by
2011 // the class's "isa" pointer. The following assumes that
2012 // isa" is the first ivar in a class (which it must be).
2013 Target = EmitClassRef(CGF, Class->getSuperClass());
2014 Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
2015 Target = CGF.Builder.CreateAlignedLoad(Target, CGF.getPointerAlign());
2017 llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
2018 llvm::Value *SuperPtr =
2019 CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
2020 llvm::Value *Super =
2021 CGF.Builder.CreateAlignedLoad(SuperPtr, CGF.getPointerAlign());
2024 } else if (isCategoryImpl)
2025 Target = EmitClassRef(CGF, Class->getSuperClass());
2027 llvm::Value *ClassPtr = EmitSuperClassRef(Class);
2028 ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
2029 Target = CGF.Builder.CreateAlignedLoad(ClassPtr, CGF.getPointerAlign());
2031 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
2033 llvm::Type *ClassTy =
2034 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
2035 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
2036 CGF.Builder.CreateStore(Target,
2037 CGF.Builder.CreateStructGEP(ObjCSuper, 1, CGF.getPointerSize()));
2038 return EmitMessageSend(CGF, Return, ResultType,
2039 EmitSelector(CGF, Sel),
2040 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
2041 true, CallArgs, Method, Class, ObjCTypes);
2044 /// Generate code for a message send expression.
2045 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
2046 ReturnValueSlot Return,
2047 QualType ResultType,
2049 llvm::Value *Receiver,
2050 const CallArgList &CallArgs,
2051 const ObjCInterfaceDecl *Class,
2052 const ObjCMethodDecl *Method) {
2053 return EmitMessageSend(CGF, Return, ResultType,
2054 EmitSelector(CGF, Sel),
2055 Receiver, CGF.getContext().getObjCIdType(),
2056 false, CallArgs, Method, Class, ObjCTypes);
2059 static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
2061 if (ID->isWeakImported())
2063 } while ((ID = ID->getSuperClass()));
2069 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
2070 ReturnValueSlot Return,
2071 QualType ResultType,
2076 const CallArgList &CallArgs,
2077 const ObjCMethodDecl *Method,
2078 const ObjCInterfaceDecl *ClassReceiver,
2079 const ObjCCommonTypesHelper &ObjCTypes) {
2080 CallArgList ActualArgs;
2082 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
2083 ActualArgs.add(RValue::get(Arg0), Arg0Ty);
2084 ActualArgs.add(RValue::get(Sel), CGF.getContext().getObjCSelType());
2085 ActualArgs.addFrom(CallArgs);
2087 // If we're calling a method, use the formal signature.
2088 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2091 assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==
2092 CGM.getContext().getCanonicalType(ResultType) &&
2093 "Result type mismatch!");
2095 bool ReceiverCanBeNull = true;
2097 // Super dispatch assumes that self is non-null; even the messenger
2098 // doesn't have a null check internally.
2100 ReceiverCanBeNull = false;
2102 // If this is a direct dispatch of a class method, check whether the class,
2103 // or anything in its hierarchy, was weak-linked.
2104 } else if (ClassReceiver && Method && Method->isClassMethod()) {
2105 ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);
2107 // If we're emitting a method, and self is const (meaning just ARC, for now),
2108 // and the receiver is a load of self, then self is a valid object.
2109 } else if (auto CurMethod =
2110 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
2111 auto Self = CurMethod->getSelfDecl();
2112 if (Self->getType().isConstQualified()) {
2113 if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {
2114 llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer();
2115 if (SelfAddr == LI->getPointerOperand()) {
2116 ReceiverCanBeNull = false;
2122 NullReturnState nullReturn;
2124 llvm::Constant *Fn = nullptr;
2125 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
2126 if (ReceiverCanBeNull) nullReturn.init(CGF, Arg0);
2127 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
2128 : ObjCTypes.getSendStretFn(IsSuper);
2129 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
2130 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
2131 : ObjCTypes.getSendFpretFn(IsSuper);
2132 } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
2133 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
2134 : ObjCTypes.getSendFp2retFn(IsSuper);
2136 // arm64 uses objc_msgSend for stret methods and yet null receiver check
2137 // must be made for it.
2138 if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
2139 nullReturn.init(CGF, Arg0);
2140 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
2141 : ObjCTypes.getSendFn(IsSuper);
2144 // Emit a null-check if there's a consumed argument other than the receiver.
2145 bool RequiresNullCheck = false;
2146 if (ReceiverCanBeNull && CGM.getLangOpts().ObjCAutoRefCount && Method) {
2147 for (const auto *ParamDecl : Method->parameters()) {
2148 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
2149 if (!nullReturn.NullBB)
2150 nullReturn.init(CGF, Arg0);
2151 RequiresNullCheck = true;
2157 llvm::Instruction *CallSite;
2158 Fn = llvm::ConstantExpr::getBitCast(Fn, MSI.MessengerType);
2159 CGCallee Callee = CGCallee::forDirect(Fn);
2160 RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
2163 // Mark the call as noreturn if the method is marked noreturn and the
2164 // receiver cannot be null.
2165 if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) {
2166 llvm::CallSite(CallSite).setDoesNotReturn();
2169 return nullReturn.complete(CGF, rvalue, ResultType, CallArgs,
2170 RequiresNullCheck ? Method : nullptr);
2173 static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT,
2174 bool pointee = false) {
2175 // Note that GC qualification applies recursively to C pointer types
2176 // that aren't otherwise decorated. This is weird, but it's probably
2177 // an intentional workaround to the unreliable placement of GC qualifiers.
2178 if (FQT.isObjCGCStrong())
2179 return Qualifiers::Strong;
2181 if (FQT.isObjCGCWeak())
2182 return Qualifiers::Weak;
2184 if (auto ownership = FQT.getObjCLifetime()) {
2185 // Ownership does not apply recursively to C pointer types.
2186 if (pointee) return Qualifiers::GCNone;
2187 switch (ownership) {
2188 case Qualifiers::OCL_Weak: return Qualifiers::Weak;
2189 case Qualifiers::OCL_Strong: return Qualifiers::Strong;
2190 case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone;
2191 case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?");
2192 case Qualifiers::OCL_None: llvm_unreachable("known nonzero");
2194 llvm_unreachable("bad objc ownership");
2197 // Treat unqualified retainable pointers as strong.
2198 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2199 return Qualifiers::Strong;
2201 // Walk into C pointer types, but only in GC.
2202 if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
2203 if (const PointerType *PT = FQT->getAs<PointerType>())
2204 return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
2207 return Qualifiers::GCNone;
2213 uint64_t SizeInWords;
2214 IvarInfo(CharUnits offset, uint64_t sizeInWords)
2215 : Offset(offset), SizeInWords(sizeInWords) {}
2217 // Allow sorting based on byte pos.
2218 bool operator<(const IvarInfo &other) const {
2219 return Offset < other.Offset;
2223 /// A helper class for building GC layout strings.
2224 class IvarLayoutBuilder {
2227 /// The start of the layout. Offsets will be relative to this value,
2228 /// and entries less than this value will be silently discarded.
2229 CharUnits InstanceBegin;
2231 /// The end of the layout. Offsets will never exceed this value.
2232 CharUnits InstanceEnd;
2234 /// Whether we're generating the strong layout or the weak layout.
2235 bool ForStrongLayout;
2237 /// Whether the offsets in IvarsInfo might be out-of-order.
2238 bool IsDisordered = false;
2240 llvm::SmallVector<IvarInfo, 8> IvarsInfo;
2243 IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2244 CharUnits instanceEnd, bool forStrongLayout)
2245 : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
2246 ForStrongLayout(forStrongLayout) {
2249 void visitRecord(const RecordType *RT, CharUnits offset);
2251 template <class Iterator, class GetOffsetFn>
2252 void visitAggregate(Iterator begin, Iterator end,
2253 CharUnits aggrOffset,
2254 const GetOffsetFn &getOffset);
2256 void visitField(const FieldDecl *field, CharUnits offset);
2258 /// Add the layout of a block implementation.
2259 void visitBlock(const CGBlockInfo &blockInfo);
2261 /// Is there any information for an interesting bitmap?
2262 bool hasBitmapData() const { return !IvarsInfo.empty(); }
2264 llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
2265 llvm::SmallVectorImpl<unsigned char> &buffer);
2267 static void dump(ArrayRef<unsigned char> buffer) {
2268 const unsigned char *s = buffer.data();
2269 for (unsigned i = 0, e = buffer.size(); i < e; i++)
2271 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2273 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
2277 } // end anonymous namespace
2279 llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
2280 const CGBlockInfo &blockInfo) {
2282 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2283 if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
2286 IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2287 /*for strong layout*/ true);
2289 builder.visitBlock(blockInfo);
2291 if (!builder.hasBitmapData())
2294 llvm::SmallVector<unsigned char, 32> buffer;
2295 llvm::Constant *C = builder.buildBitmap(*this, buffer);
2296 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
2297 printf("\n block variable layout for block: ");
2298 builder.dump(buffer);
2304 void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
2305 // __isa is the first field in block descriptor and must assume by runtime's
2306 // convention that it is GC'able.
2307 IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2309 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2311 // Ignore the optional 'this' capture: C++ objects are not assumed
2314 CharUnits lastFieldOffset;
2316 // Walk the captured variables.
2317 for (const auto &CI : blockDecl->captures()) {
2318 const VarDecl *variable = CI.getVariable();
2319 QualType type = variable->getType();
2321 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2323 // Ignore constant captures.
2324 if (capture.isConstant()) continue;
2326 CharUnits fieldOffset = capture.getOffset();
2328 // Block fields are not necessarily ordered; if we detect that we're
2329 // adding them out-of-order, make sure we sort later.
2330 if (fieldOffset < lastFieldOffset)
2331 IsDisordered = true;
2332 lastFieldOffset = fieldOffset;
2334 // __block variables are passed by their descriptor address.
2336 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2340 assert(!type->isArrayType() && "array variable should not be caught");
2341 if (const RecordType *record = type->getAs<RecordType>()) {
2342 visitRecord(record, fieldOffset);
2346 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);
2348 if (GCAttr == Qualifiers::Strong) {
2349 assert(CGM.getContext().getTypeSize(type)
2350 == CGM.getTarget().getPointerWidth(0));
2351 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2356 /// getBlockCaptureLifetime - This routine returns life time of the captured
2357 /// block variable for the purpose of block layout meta-data generation. FQT is
2358 /// the type of the variable captured in the block.
2359 Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2361 // If it has an ownership qualifier, we're done.
2362 if (auto lifetime = FQT.getObjCLifetime())
2365 // If it doesn't, and this is ARC, it has no ownership.
2366 if (CGM.getLangOpts().ObjCAutoRefCount)
2367 return Qualifiers::OCL_None;
2369 // In MRC, retainable pointers are owned by non-__block variables.
2370 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2371 return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong;
2373 return Qualifiers::OCL_None;
2376 void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2377 Qualifiers::ObjCLifetime LifeTime,
2378 CharUnits FieldOffset,
2379 CharUnits FieldSize) {
2380 // __block variables are passed by their descriptor address.
2382 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2384 else if (LifeTime == Qualifiers::OCL_Strong)
2385 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2387 else if (LifeTime == Qualifiers::OCL_Weak)
2388 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2390 else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2391 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2394 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2399 void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2400 const RecordDecl *RD,
2401 ArrayRef<const FieldDecl*> RecFields,
2402 CharUnits BytePos, bool &HasUnion,
2404 bool IsUnion = (RD && RD->isUnion());
2405 CharUnits MaxUnionSize = CharUnits::Zero();
2406 const FieldDecl *MaxField = nullptr;
2407 const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2408 CharUnits MaxFieldOffset = CharUnits::Zero();
2409 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2411 if (RecFields.empty())
2413 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2415 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
2416 const FieldDecl *Field = RecFields[i];
2417 // Note that 'i' here is actually the field index inside RD of Field,
2418 // although this dependency is hidden.
2419 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2420 CharUnits FieldOffset =
2421 CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i));
2423 // Skip over unnamed or bitfields
2424 if (!Field->getIdentifier() || Field->isBitField()) {
2425 LastFieldBitfieldOrUnnamed = Field;
2426 LastBitfieldOrUnnamedOffset = FieldOffset;
2430 LastFieldBitfieldOrUnnamed = nullptr;
2431 QualType FQT = Field->getType();
2432 if (FQT->isRecordType() || FQT->isUnionType()) {
2433 if (FQT->isUnionType())
2436 BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
2437 BytePos + FieldOffset, HasUnion);
2441 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2442 const ConstantArrayType *CArray =
2443 dyn_cast_or_null<ConstantArrayType>(Array);
2444 uint64_t ElCount = CArray->getSize().getZExtValue();
2445 assert(CArray && "only array with known element size is supported");
2446 FQT = CArray->getElementType();
2447 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2448 const ConstantArrayType *CArray =
2449 dyn_cast_or_null<ConstantArrayType>(Array);
2450 ElCount *= CArray->getSize().getZExtValue();
2451 FQT = CArray->getElementType();
2453 if (FQT->isRecordType() && ElCount) {
2454 int OldIndex = RunSkipBlockVars.size() - 1;
2455 const RecordType *RT = FQT->getAs<RecordType>();
2456 BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset,
2459 // Replicate layout information for each array element. Note that
2460 // one element is already done.
2462 for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2463 CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2464 for (int i = OldIndex+1; i <= FirstIndex; ++i)
2465 RunSkipBlockVars.push_back(
2466 RUN_SKIP(RunSkipBlockVars[i].opcode,
2467 RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2468 RunSkipBlockVars[i].block_var_size));
2473 CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2475 CharUnits UnionIvarSize = FieldSize;
2476 if (UnionIvarSize > MaxUnionSize) {
2477 MaxUnionSize = UnionIvarSize;
2479 MaxFieldOffset = FieldOffset;
2482 UpdateRunSkipBlockVars(false,
2483 getBlockCaptureLifetime(FQT, ByrefLayout),
2484 BytePos + FieldOffset,
2489 if (LastFieldBitfieldOrUnnamed) {
2490 if (LastFieldBitfieldOrUnnamed->isBitField()) {
2491 // Last field was a bitfield. Must update the info.
2492 uint64_t BitFieldSize
2493 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2494 unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2495 ((BitFieldSize % ByteSizeInBits) != 0);
2496 CharUnits Size = CharUnits::fromQuantity(UnsSize);
2497 Size += LastBitfieldOrUnnamedOffset;
2498 UpdateRunSkipBlockVars(false,
2499 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2501 BytePos + LastBitfieldOrUnnamedOffset,
2504 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2505 // Last field was unnamed. Must update skip info.
2507 = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2508 UpdateRunSkipBlockVars(false,
2509 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2511 BytePos + LastBitfieldOrUnnamedOffset,
2517 UpdateRunSkipBlockVars(false,
2518 getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2519 BytePos + MaxFieldOffset,
2523 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2527 const RecordDecl *RD = RT->getDecl();
2528 SmallVector<const FieldDecl*, 16> Fields(RD->fields());
2529 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2530 const llvm::StructLayout *RecLayout =
2531 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2533 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2536 /// InlineLayoutInstruction - This routine produce an inline instruction for the
2537 /// block variable layout if it can. If not, it returns 0. Rules are as follow:
2538 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2539 /// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2540 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2541 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2542 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2543 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2544 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2545 uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2546 SmallVectorImpl<unsigned char> &Layout) {
2547 uint64_t Result = 0;
2548 if (Layout.size() <= 3) {
2549 unsigned size = Layout.size();
2550 unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2552 enum BLOCK_LAYOUT_OPCODE opcode ;
2556 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2557 if (opcode == BLOCK_LAYOUT_STRONG)
2558 strong_word_count = (inst & 0xF)+1;
2562 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2563 if (opcode == BLOCK_LAYOUT_BYREF)
2564 byref_word_count = (inst & 0xF)+1;
2568 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2569 if (opcode == BLOCK_LAYOUT_WEAK)
2570 weak_word_count = (inst & 0xF)+1;
2577 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2578 if (opcode == BLOCK_LAYOUT_STRONG) {
2579 strong_word_count = (inst & 0xF)+1;
2581 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2582 if (opcode == BLOCK_LAYOUT_BYREF)
2583 byref_word_count = (inst & 0xF)+1;
2584 else if (opcode == BLOCK_LAYOUT_WEAK)
2585 weak_word_count = (inst & 0xF)+1;
2589 else if (opcode == BLOCK_LAYOUT_BYREF) {
2590 byref_word_count = (inst & 0xF)+1;
2592 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2593 if (opcode == BLOCK_LAYOUT_WEAK)
2594 weak_word_count = (inst & 0xF)+1;
2604 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2605 if (opcode == BLOCK_LAYOUT_STRONG)
2606 strong_word_count = (inst & 0xF)+1;
2607 else if (opcode == BLOCK_LAYOUT_BYREF)
2608 byref_word_count = (inst & 0xF)+1;
2609 else if (opcode == BLOCK_LAYOUT_WEAK)
2610 weak_word_count = (inst & 0xF)+1;
2619 // Cannot inline when any of the word counts is 15. Because this is one less
2620 // than the actual work count (so 15 means 16 actual word counts),
2621 // and we can only display 0 thru 15 word counts.
2622 if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2626 (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2628 if (size == count) {
2629 if (strong_word_count)
2630 Result = strong_word_count;
2632 if (byref_word_count)
2633 Result += byref_word_count;
2635 if (weak_word_count)
2636 Result += weak_word_count;
2642 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2643 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2644 if (RunSkipBlockVars.empty())
2646 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2647 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2648 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2650 // Sort on byte position; captures might not be allocated in order,
2651 // and unions can do funny things.
2652 llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2653 SmallVector<unsigned char, 16> Layout;
2655 unsigned size = RunSkipBlockVars.size();
2656 for (unsigned i = 0; i < size; i++) {
2657 enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2658 CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2659 CharUnits end_byte_pos = start_byte_pos;
2662 if (opcode == RunSkipBlockVars[j].opcode) {
2663 end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2669 CharUnits size_in_bytes =
2670 end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2673 RunSkipBlockVars[j].block_var_bytepos -
2674 RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2675 size_in_bytes += gap;
2677 CharUnits residue_in_bytes = CharUnits::Zero();
2678 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2679 residue_in_bytes = size_in_bytes % WordSizeInBytes;
2680 size_in_bytes -= residue_in_bytes;
2681 opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2684 unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2685 while (size_in_words >= 16) {
2686 // Note that value in imm. is one less that the actual
2687 // value. So, 0xf means 16 words follow!
2688 unsigned char inst = (opcode << 4) | 0xf;
2689 Layout.push_back(inst);
2690 size_in_words -= 16;
2692 if (size_in_words > 0) {
2693 // Note that value in imm. is one less that the actual
2694 // value. So, we subtract 1 away!
2695 unsigned char inst = (opcode << 4) | (size_in_words-1);
2696 Layout.push_back(inst);
2698 if (residue_in_bytes > CharUnits::Zero()) {
2699 unsigned char inst =
2700 (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2701 Layout.push_back(inst);
2705 while (!Layout.empty()) {
2706 unsigned char inst = Layout.back();
2707 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2708 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2714 uint64_t Result = InlineLayoutInstruction(Layout);
2716 // Block variable layout instruction has been inlined.
2717 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2718 if (ComputeByrefLayout)
2719 printf("\n Inline BYREF variable layout: ");
2721 printf("\n Inline block variable layout: ");
2722 printf("0x0%" PRIx64 "", Result);
2723 if (auto numStrong = (Result & 0xF00) >> 8)
2724 printf(", BL_STRONG:%d", (int) numStrong);
2725 if (auto numByref = (Result & 0x0F0) >> 4)
2726 printf(", BL_BYREF:%d", (int) numByref);
2727 if (auto numWeak = (Result & 0x00F) >> 0)
2728 printf(", BL_WEAK:%d", (int) numWeak);
2729 printf(", BL_OPERATOR:0\n");
2731 return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2734 unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2735 Layout.push_back(inst);
2737 for (unsigned i = 0, e = Layout.size(); i != e; i++)
2738 BitMap += Layout[i];
2740 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2741 if (ComputeByrefLayout)
2742 printf("\n Byref variable layout: ");
2744 printf("\n Block variable layout: ");
2745 for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2746 unsigned char inst = BitMap[i];
2747 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2750 case BLOCK_LAYOUT_OPERATOR:
2751 printf("BL_OPERATOR:");
2754 case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2755 printf("BL_NON_OBJECT_BYTES:");
2757 case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2758 printf("BL_NON_OBJECT_WORD:");
2760 case BLOCK_LAYOUT_STRONG:
2761 printf("BL_STRONG:");
2763 case BLOCK_LAYOUT_BYREF:
2764 printf("BL_BYREF:");
2766 case BLOCK_LAYOUT_WEAK:
2769 case BLOCK_LAYOUT_UNRETAINED:
2770 printf("BL_UNRETAINED:");
2773 // Actual value of word count is one more that what is in the imm.
2774 // field of the instruction
2775 printf("%d", (inst & 0xf) + delta);
2783 auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
2784 /*ForceNonFragileABI=*/true,
2785 /*NullTerminate=*/false);
2786 return getConstantGEP(VMContext, Entry, 0, 0);
2789 llvm::Constant *CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2790 const CGBlockInfo &blockInfo) {
2791 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2793 RunSkipBlockVars.clear();
2794 bool hasUnion = false;
2796 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2797 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2798 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2800 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2802 // Calculate the basic layout of the block structure.
2803 const llvm::StructLayout *layout =
2804 CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2806 // Ignore the optional 'this' capture: C++ objects are not assumed
2808 if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2809 UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2810 blockInfo.BlockHeaderForcedGapOffset,
2811 blockInfo.BlockHeaderForcedGapSize);
2812 // Walk the captured variables.
2813 for (const auto &CI : blockDecl->captures()) {
2814 const VarDecl *variable = CI.getVariable();
2815 QualType type = variable->getType();
2817 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2819 // Ignore constant captures.
2820 if (capture.isConstant()) continue;
2822 CharUnits fieldOffset =
2823 CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2825 assert(!type->isArrayType() && "array variable should not be caught");
2827 if (const RecordType *record = type->getAs<RecordType>()) {
2828 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2831 CharUnits fieldSize;
2833 fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2835 fieldSize = CGM.getContext().getTypeSizeInChars(type);
2836 UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2837 fieldOffset, fieldSize);
2839 return getBitmapBlockLayout(false);
2842 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
2844 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2845 assert(!T->isArrayType() && "__block array variable should not be caught");
2846 CharUnits fieldOffset;
2847 RunSkipBlockVars.clear();
2848 bool hasUnion = false;
2849 if (const RecordType *record = T->getAs<RecordType>()) {
2850 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
2851 llvm::Constant *Result = getBitmapBlockLayout(true);
2852 if (isa<llvm::ConstantInt>(Result))
2853 Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
2856 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2860 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
2861 const ObjCProtocolDecl *PD) {
2862 // FIXME: I don't understand why gcc generates this, or where it is
2863 // resolved. Investigate. Its also wasteful to look this up over and over.
2864 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2866 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
2867 ObjCTypes.getExternalProtocolPtrTy());
2870 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
2871 // FIXME: We shouldn't need this, the protocol decl should contain enough
2872 // information to tell us whether this was a declaration or a definition.
2873 DefinedProtocols.insert(PD->getIdentifier());
2875 // If we have generated a forward reference to this protocol, emit
2876 // it now. Otherwise do nothing, the protocol objects are lazily
2878 if (Protocols.count(PD->getIdentifier()))
2879 GetOrEmitProtocol(PD);
2882 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
2883 if (DefinedProtocols.count(PD->getIdentifier()))
2884 return GetOrEmitProtocol(PD);
2886 return GetOrEmitProtocolRef(PD);
2889 llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
2890 CodeGenFunction &CGF,
2891 const ObjCInterfaceDecl *ID,
2892 ObjCCommonTypesHelper &ObjCTypes) {
2893 llvm::Constant *lookUpClassFn = ObjCTypes.getLookUpClassFn();
2895 llvm::Value *className =
2896 CGF.CGM.GetAddrOfConstantCString(ID->getObjCRuntimeNameAsString())
2898 ASTContext &ctx = CGF.CGM.getContext();
2900 CGF.Builder.CreateBitCast(className,
2902 ctx.getPointerType(ctx.CharTy.withConst())));
2903 llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
2904 call->setDoesNotThrow();
2909 // Objective-C 1.0 extensions
2910 struct _objc_protocol {
2911 struct _objc_protocol_extension *isa;
2912 char *protocol_name;
2913 struct _objc_protocol_list *protocol_list;
2914 struct _objc__method_prototype_list *instance_methods;
2915 struct _objc__method_prototype_list *class_methods
2918 See EmitProtocolExtension().
2920 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
2921 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
2923 // Early exit if a defining object has already been generated.
2924 if (Entry && Entry->hasInitializer())
2927 // Use the protocol definition, if there is one.
2928 if (const ObjCProtocolDecl *Def = PD->getDefinition())
2931 // FIXME: I don't understand why gcc generates this, or where it is
2932 // resolved. Investigate. Its also wasteful to look this up over and over.
2933 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2935 // Construct method lists.
2936 auto methodLists = ProtocolMethodLists::get(PD);
2938 ConstantInitBuilder builder(CGM);
2939 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
2940 values.add(EmitProtocolExtension(PD, methodLists));
2941 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
2942 values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
2943 PD->protocol_begin(), PD->protocol_end()));
2944 values.add(methodLists.emitMethodList(this, PD,
2945 ProtocolMethodLists::RequiredInstanceMethods));
2946 values.add(methodLists.emitMethodList(this, PD,
2947 ProtocolMethodLists::RequiredClassMethods));
2950 // Already created, update the initializer.
2951 assert(Entry->hasPrivateLinkage());
2952 values.finishAndSetAsInitializer(Entry);
2954 Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
2955 CGM.getPointerAlign(),
2957 llvm::GlobalValue::PrivateLinkage);
2958 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
2960 Protocols[PD->getIdentifier()] = Entry;
2962 CGM.addCompilerUsedGlobal(Entry);
2967 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
2968 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
2971 // We use the initializer as a marker of whether this is a forward
2972 // reference or not. At module finalization we add the empty
2973 // contents for protocols which were referenced but never defined.
2974 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
2975 false, llvm::GlobalValue::PrivateLinkage,
2976 nullptr, "OBJC_PROTOCOL_" + PD->getName());
2977 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
2978 // FIXME: Is this necessary? Why only for protocol?
2979 Entry->setAlignment(4);
2986 struct _objc_protocol_extension {
2988 struct objc_method_description_list *optional_instance_methods;
2989 struct objc_method_description_list *optional_class_methods;
2990 struct objc_property_list *instance_properties;
2991 const char ** extendedMethodTypes;
2992 struct objc_property_list *class_properties;
2996 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
2997 const ProtocolMethodLists &methodLists) {
2998 auto optInstanceMethods =
2999 methodLists.emitMethodList(this, PD,
3000 ProtocolMethodLists::OptionalInstanceMethods);
3001 auto optClassMethods =
3002 methodLists.emitMethodList(this, PD,
3003 ProtocolMethodLists::OptionalClassMethods);
3005 auto extendedMethodTypes =
3006 EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3007 methodLists.emitExtendedTypesArray(this),
3010 auto instanceProperties =
3011 EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3013 auto classProperties =
3014 EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3015 PD, ObjCTypes, true);
3017 // Return null if no extension bits are used.
3018 if (optInstanceMethods->isNullValue() &&
3019 optClassMethods->isNullValue() &&
3020 extendedMethodTypes->isNullValue() &&
3021 instanceProperties->isNullValue() &&
3022 classProperties->isNullValue()) {
3023 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3027 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3029 ConstantInitBuilder builder(CGM);
3030 auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3031 values.addInt(ObjCTypes.IntTy, size);
3032 values.add(optInstanceMethods);
3033 values.add(optClassMethods);
3034 values.add(instanceProperties);
3035 values.add(extendedMethodTypes);
3036 values.add(classProperties);
3038 // No special section, but goes in llvm.used
3039 return CreateMetadataVar("\01l_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3040 StringRef(), CGM.getPointerAlign(), true);
3044 struct objc_protocol_list {
3045 struct objc_protocol_list *next;
3051 CGObjCMac::EmitProtocolList(Twine name,
3052 ObjCProtocolDecl::protocol_iterator begin,
3053 ObjCProtocolDecl::protocol_iterator end) {
3054 // Just return null for empty protocol lists
3056 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3058 ConstantInitBuilder builder(CGM);
3059 auto values = builder.beginStruct();
3061 // This field is only used by the runtime.
3062 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3064 // Reserve a slot for the count.
3065 auto countSlot = values.addPlaceholder();
3067 auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3068 for (; begin != end; ++begin) {
3069 refsArray.add(GetProtocolRef(*begin));
3071 auto count = refsArray.size();
3073 // This list is null terminated.
3074 refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3076 refsArray.finishAndAddTo(values);
3077 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3080 if (CGM.getTriple().isOSBinFormatMachO())
3081 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3083 llvm::GlobalVariable *GV =
3084 CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3085 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3089 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
3090 SmallVectorImpl<const ObjCPropertyDecl *> &Properties,
3091 const ObjCProtocolDecl *Proto,
3092 bool IsClassProperty) {
3093 for (const auto *P : Proto->protocols())
3094 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3096 for (const auto *PD : Proto->properties()) {
3097 if (IsClassProperty != PD->isClassProperty())
3099 if (!PropertySet.insert(PD->getIdentifier()).second)
3101 Properties.push_back(PD);
3106 struct _objc_property {
3107 const char * const name;
3108 const char * const attributes;
3111 struct _objc_property_list {
3112 uint32_t entsize; // sizeof (struct _objc_property)
3113 uint32_t prop_count;
3114 struct _objc_property[prop_count];
3117 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3118 const Decl *Container,
3119 const ObjCContainerDecl *OCD,
3120 const ObjCCommonTypesHelper &ObjCTypes,
3121 bool IsClassProperty) {
3122 if (IsClassProperty) {
3123 // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3124 // with deployment target < 9.0.
3125 const llvm::Triple &Triple = CGM.getTarget().getTriple();
3126 if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
3127 (Triple.isiOS() && Triple.isOSVersionLT(9)))
3128 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3131 SmallVector<const ObjCPropertyDecl *, 16> Properties;
3132 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3134 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3135 for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3136 for (auto *PD : ClassExt->properties()) {
3137 if (IsClassProperty != PD->isClassProperty())
3139 PropertySet.insert(PD->getIdentifier());
3140 Properties.push_back(PD);
3143 for (const auto *PD : OCD->properties()) {
3144 if (IsClassProperty != PD->isClassProperty())
3146 // Don't emit duplicate metadata for properties that were already in a
3148 if (!PropertySet.insert(PD->getIdentifier()).second)
3150 Properties.push_back(PD);
3153 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3154 for (const auto *P : OID->all_referenced_protocols())
3155 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3157 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3158 for (const auto *P : CD->protocols())
3159 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3162 // Return null for empty list.
3163 if (Properties.empty())
3164 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3166 unsigned propertySize =
3167 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3169 ConstantInitBuilder builder(CGM);
3170 auto values = builder.beginStruct();
3171 values.addInt(ObjCTypes.IntTy, propertySize);
3172 values.addInt(ObjCTypes.IntTy, Properties.size());
3173 auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3174 for (auto PD : Properties) {
3175 auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3176 property.add(GetPropertyName(PD->getIdentifier()));
3177 property.add(GetPropertyTypeString(PD, Container));
3178 property.finishAndAddTo(propertiesArray);
3180 propertiesArray.finishAndAddTo(values);
3183 if (CGM.getTriple().isOSBinFormatMachO())
3184 Section = (ObjCABI == 2) ? "__DATA, __objc_const"
3185 : "__OBJC,__property,regular,no_dead_strip";
3187 llvm::GlobalVariable *GV =
3188 CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3189 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3193 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3194 ArrayRef<llvm::Constant*> MethodTypes,
3195 const ObjCCommonTypesHelper &ObjCTypes) {
3196 // Return null for empty list.
3197 if (MethodTypes.empty())
3198 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3200 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3201 MethodTypes.size());
3202 llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3205 if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
3206 Section = "__DATA, __objc_const";
3208 llvm::GlobalVariable *GV =
3209 CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3210 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3214 struct _objc_category {
3215 char *category_name;
3217 struct _objc_method_list *instance_methods;
3218 struct _objc_method_list *class_methods;
3219 struct _objc_protocol_list *protocols;
3220 uint32_t size; // <rdar://4585769>
3221 struct _objc_property_list *instance_properties;
3222 struct _objc_property_list *class_properties;
3225 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3226 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3228 // FIXME: This is poor design, the OCD should have a pointer to the category
3229 // decl. Additionally, note that Category can be null for the @implementation
3230 // w/o an @interface case. Sema should just create one for us as it does for
3231 // @implementation so everyone else can live life under a clear blue sky.
3232 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3233 const ObjCCategoryDecl *Category =
3234 Interface->FindCategoryDeclaration(OCD->getIdentifier());
3236 SmallString<256> ExtName;
3237 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3240 ConstantInitBuilder Builder(CGM);
3241 auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3248 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3249 for (const auto *MD : OCD->methods()) {
3250 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3253 Values.add(GetClassName(OCD->getName()));
3254 Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3255 LazySymbols.insert(Interface->getIdentifier());
3257 Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3258 Methods[InstanceMethods]));
3259 Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3260 Methods[ClassMethods]));
3263 EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3264 Category->protocol_begin(), Category->protocol_end()));
3266 Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3268 Values.addInt(ObjCTypes.IntTy, Size);
3270 // If there is no category @interface then there can be no properties.
3272 Values.add(EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
3273 OCD, Category, ObjCTypes, false));
3274 Values.add(EmitPropertyList("\01l_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3275 OCD, Category, ObjCTypes, true));
3277 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3278 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3281 llvm::GlobalVariable *GV =
3282 CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3283 "__OBJC,__category,regular,no_dead_strip",
3284 CGM.getPointerAlign(), true);
3285 DefinedCategories.push_back(GV);
3286 DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3287 // method definition entries must be clear for next implementation.
3288 MethodDefinitions.clear();
3291 enum FragileClassFlags {
3292 /// Apparently: is not a meta-class.
3293 FragileABI_Class_Factory = 0x00001,
3295 /// Is a meta-class.
3296 FragileABI_Class_Meta = 0x00002,
3298 /// Has a non-trivial constructor or destructor.
3299 FragileABI_Class_HasCXXStructors = 0x02000,
3301 /// Has hidden visibility.
3302 FragileABI_Class_Hidden = 0x20000,
3304 /// Class implementation was compiled under ARC.
3305 FragileABI_Class_CompiledByARC = 0x04000000,
3307 /// Class implementation was compiled under MRC and has MRC weak ivars.
3308 /// Exclusive with CompiledByARC.
3309 FragileABI_Class_HasMRCWeakIvars = 0x08000000,
3312 enum NonFragileClassFlags {
3313 /// Is a meta-class.
3314 NonFragileABI_Class_Meta = 0x00001,
3316 /// Is a root class.
3317 NonFragileABI_Class_Root = 0x00002,
3319 /// Has a non-trivial constructor or destructor.
3320 NonFragileABI_Class_HasCXXStructors = 0x00004,
3322 /// Has hidden visibility.
3323 NonFragileABI_Class_Hidden = 0x00010,
3325 /// Has the exception attribute.
3326 NonFragileABI_Class_Exception = 0x00020,
3328 /// (Obsolete) ARC-specific: this class has a .release_ivars method
3329 NonFragileABI_Class_HasIvarReleaser = 0x00040,
3331 /// Class implementation was compiled under ARC.
3332 NonFragileABI_Class_CompiledByARC = 0x00080,
3334 /// Class has non-trivial destructors, but zero-initialization is okay.
3335 NonFragileABI_Class_HasCXXDestructorOnly = 0x00100,
3337 /// Class implementation was compiled under MRC and has MRC weak ivars.
3338 /// Exclusive with CompiledByARC.
3339 NonFragileABI_Class_HasMRCWeakIvars = 0x00200,
3342 static bool hasWeakMember(QualType type) {
3343 if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3347 if (auto recType = type->getAs<RecordType>()) {
3348 for (auto field : recType->getDecl()->fields()) {
3349 if (hasWeakMember(field->getType()))
3357 /// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3358 /// (and actually fill in a layout string) if we really do have any
3360 static bool hasMRCWeakIvars(CodeGenModule &CGM,
3361 const ObjCImplementationDecl *ID) {
3362 if (!CGM.getLangOpts().ObjCWeak) return false;
3363 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3365 for (const ObjCIvarDecl *ivar =
3366 ID->getClassInterface()->all_declared_ivar_begin();
3367 ivar; ivar = ivar->getNextIvar()) {
3368 if (hasWeakMember(ivar->getType()))
3376 struct _objc_class {
3383 struct _objc_ivar_list *ivars;
3384 struct _objc_method_list *methods;
3385 struct _objc_cache *cache;
3386 struct _objc_protocol_list *protocols;
3387 // Objective-C 1.0 extensions (<rdr://4585769>)
3388 const char *ivar_layout;
3389 struct _objc_class_ext *ext;
3392 See EmitClassExtension();
3394 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3395 DefinedSymbols.insert(ID->getIdentifier());
3397 std::string ClassName = ID->getNameAsString();
3399 ObjCInterfaceDecl *Interface =
3400 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3401 llvm::Constant *Protocols =
3402 EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3403 Interface->all_referenced_protocol_begin(),
3404 Interface->all_referenced_protocol_end());
3405 unsigned Flags = FragileABI_Class_Factory;
3406 if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3407 Flags |= FragileABI_Class_HasCXXStructors;
3409 bool hasMRCWeak = false;
3411 if (CGM.getLangOpts().ObjCAutoRefCount)
3412 Flags |= FragileABI_Class_CompiledByARC;
3413 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3414 Flags |= FragileABI_Class_HasMRCWeakIvars;
3417 CGM.getContext().getASTObjCImplementationLayout(ID).getSize();
3419 // FIXME: Set CXX-structors flag.
3420 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3421 Flags |= FragileABI_Class_Hidden;
3428 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3429 for (const auto *MD : ID->methods()) {
3430 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3433 for (const auto *PID : ID->property_impls()) {
3434 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3435 ObjCPropertyDecl *PD = PID->getPropertyDecl();
3437 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
3438 if (GetMethodDefinition(MD))
3439 Methods[InstanceMethods].push_back(MD);
3440 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
3441 if (GetMethodDefinition(MD))
3442 Methods[InstanceMethods].push_back(MD);
3446 ConstantInitBuilder builder(CGM);
3447 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3448 values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3449 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3450 // Record a reference to the super class.
3451 LazySymbols.insert(Super->getIdentifier());
3453 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3454 ObjCTypes.ClassPtrTy);
3456 values.addNullPointer(ObjCTypes.ClassPtrTy);
3458 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3459 // Version is always 0.
3460 values.addInt(ObjCTypes.LongTy, 0);
3461 values.addInt(ObjCTypes.LongTy, Flags);
3462 values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3463 values.add(EmitIvarList(ID, false));
3464 values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3465 Methods[InstanceMethods]));
3466 // cache is always NULL.
3467 values.addNullPointer(ObjCTypes.CachePtrTy);
3468 values.add(Protocols);
3469 values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3470 values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3471 /*isMetaclass*/ false));
3473 std::string Name("OBJC_CLASS_");
3475 const char *Section = "__OBJC,__class,regular,no_dead_strip";
3476 // Check for a forward reference.
3477 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3479 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3480 "Forward metaclass reference has incorrect type.");
3481 values.finishAndSetAsInitializer(GV);
3482 GV->setSection(Section);
3483 GV->setAlignment(CGM.getPointerAlign().getQuantity());
3484 CGM.addCompilerUsedGlobal(GV);
3486 GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3487 DefinedClasses.push_back(GV);
3488 ImplementedClasses.push_back(Interface);
3489 // method definition entries must be clear for next implementation.
3490 MethodDefinitions.clear();
3493 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3494 llvm::Constant *Protocols,
3495 ArrayRef<const ObjCMethodDecl*> Methods) {
3496 unsigned Flags = FragileABI_Class_Meta;
3497 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3499 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3500 Flags |= FragileABI_Class_Hidden;
3502 ConstantInitBuilder builder(CGM);
3503 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3504 // The isa for the metaclass is the root of the hierarchy.
3505 const ObjCInterfaceDecl *Root = ID->getClassInterface();
3506 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3508 values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3509 ObjCTypes.ClassPtrTy);
3510 // The super class for the metaclass is emitted as the name of the
3511 // super class. The runtime fixes this up to point to the
3512 // *metaclass* for the super class.
3513 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3514 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3515 ObjCTypes.ClassPtrTy);
3517 values.addNullPointer(ObjCTypes.ClassPtrTy);
3519 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3520 // Version is always 0.
3521 values.addInt(ObjCTypes.LongTy, 0);
3522 values.addInt(ObjCTypes.LongTy, Flags);
3523 values.addInt(ObjCTypes.LongTy, Size);
3524 values.add(EmitIvarList(ID, true));
3525 values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3527 // cache is always NULL.
3528 values.addNullPointer(ObjCTypes.CachePtrTy);
3529 values.add(Protocols);
3530 // ivar_layout for metaclass is always NULL.
3531 values.addNullPointer(ObjCTypes.Int8PtrTy);
3532 // The class extension is used to store class properties for metaclasses.
3533 values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3534 /*isMetaclass*/true));
3536 std::string Name("OBJC_METACLASS_");
3537 Name += ID->getName();
3539 // Check for a forward reference.
3540 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3542 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3543 "Forward metaclass reference has incorrect type.");
3544 values.finishAndSetAsInitializer(GV);
3546 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3548 llvm::GlobalValue::PrivateLinkage);
3550 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3551 CGM.addCompilerUsedGlobal(GV);
3556 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3557 std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3559 // FIXME: Should we look these up somewhere other than the module. Its a bit
3560 // silly since we only generate these while processing an implementation, so
3561 // exactly one pointer would work if know when we entered/exitted an
3562 // implementation block.
3564 // Check for an existing forward reference.
3565 // Previously, metaclass with internal linkage may have been defined.
3566 // pass 'true' as 2nd argument so it is returned.
3567 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3569 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3570 llvm::GlobalValue::PrivateLinkage, nullptr,
3573 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3574 "Forward metaclass reference has incorrect type.");
3578 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3579 std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3580 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3583 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3584 llvm::GlobalValue::PrivateLinkage, nullptr,
3587 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3588 "Forward class metadata reference has incorrect type.");
3593 Emit a "class extension", which in this specific context means extra
3594 data that doesn't fit in the normal fragile-ABI class structure, and
3595 has nothing to do with the language concept of a class extension.
3597 struct objc_class_ext {
3599 const char *weak_ivar_layout;
3600 struct _objc_property_list *properties;
3604 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3605 CharUnits InstanceSize, bool hasMRCWeakIvars,
3607 // Weak ivar layout.
3608 llvm::Constant *layout;
3610 layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3612 layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3617 llvm::Constant *propertyList =
3618 EmitPropertyList((isMetaclass ? Twine("\01l_OBJC_$_CLASS_PROP_LIST_")
3619 : Twine("\01l_OBJC_$_PROP_LIST_"))
3621 ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3623 // Return null if no extension bits are used.
3624 if (layout->isNullValue() && propertyList->isNullValue()) {
3625 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3629 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3631 ConstantInitBuilder builder(CGM);
3632 auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3633 values.addInt(ObjCTypes.IntTy, size);
3635 values.add(propertyList);
3637 return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3638 "__OBJC,__class_ext,regular,no_dead_strip",
3639 CGM.getPointerAlign(), true);
3649 struct objc_ivar_list {
3651 struct objc_ivar list[count];
3654 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3656 // When emitting the root class GCC emits ivar entries for the
3657 // actual class structure. It is not clear if we need to follow this
3658 // behavior; for now lets try and get away with not doing it. If so,
3659 // the cleanest solution would be to make up an ObjCInterfaceDecl
3662 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3664 const ObjCInterfaceDecl *OID = ID->getClassInterface();
3666 ConstantInitBuilder builder(CGM);
3667 auto ivarList = builder.beginStruct();
3668 auto countSlot = ivarList.addPlaceholder();
3669 auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3671 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3672 IVD; IVD = IVD->getNextIvar()) {
3673 // Ignore unnamed bit-fields.
3674 if (!IVD->getDeclName())
3677 auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3678 ivar.add(GetMethodVarName(IVD->getIdentifier()));
3679 ivar.add(GetMethodVarType(IVD));
3680 ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3681 ivar.finishAndAddTo(ivars);
3684 // Return null for empty list.
3685 auto count = ivars.size();
3689 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3692 ivars.finishAndAddTo(ivarList);
3693 ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3695 llvm::GlobalVariable *GV;
3698 CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3699 "__OBJC,__class_vars,regular,no_dead_strip",
3700 CGM.getPointerAlign(), true);
3702 GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3703 "__OBJC,__instance_vars,regular,no_dead_strip",
3704 CGM.getPointerAlign(), true);
3705 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3708 /// Build a struct objc_method_description constant for the given method.
3710 /// struct objc_method_description {
3711 /// SEL method_name;
3712 /// char *method_types;
3714 void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3715 const ObjCMethodDecl *MD) {
3716 auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3717 description.addBitCast(GetMethodVarName(MD->getSelector()),
3718 ObjCTypes.SelectorPtrTy);
3719 description.add(GetMethodVarType(MD));
3720 description.finishAndAddTo(builder);
3723 /// Build a struct objc_method constant for the given method.
3725 /// struct objc_method {
3726 /// SEL method_name;
3727 /// char *method_types;
3730 void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3731 const ObjCMethodDecl *MD) {
3732 llvm::Function *fn = GetMethodDefinition(MD);
3733 assert(fn && "no definition registered for method");
3735 auto method = builder.beginStruct(ObjCTypes.MethodTy);
3736 method.addBitCast(GetMethodVarName(MD->getSelector()),
3737 ObjCTypes.SelectorPtrTy);
3738 method.add(GetMethodVarType(MD));
3739 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3740 method.finishAndAddTo(builder);
3743 /// Build a struct objc_method_list or struct objc_method_description_list,
3746 /// struct objc_method_list {
3747 /// struct objc_method_list *obsolete;
3749 /// struct objc_method methods_list[count];
3752 /// struct objc_method_description_list {
3754 /// struct objc_method_description list[count];
3756 llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3757 ArrayRef<const ObjCMethodDecl *> methods) {
3760 bool forProtocol = false;
3762 case MethodListType::CategoryInstanceMethods:
3763 prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3764 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3765 forProtocol = false;
3767 case MethodListType::CategoryClassMethods:
3768 prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3769 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3770 forProtocol = false;
3772 case MethodListType::InstanceMethods:
3773 prefix = "OBJC_INSTANCE_METHODS_";
3774 section = "__OBJC,__inst_meth,regular,no_dead_strip";
3775 forProtocol = false;
3777 case MethodListType::ClassMethods:
3778 prefix = "OBJC_CLASS_METHODS_";
3779 section = "__OBJC,__cls_meth,regular,no_dead_strip";
3780 forProtocol = false;
3782 case MethodListType::ProtocolInstanceMethods:
3783 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3784 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3787 case MethodListType::ProtocolClassMethods:
3788 prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3789 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3792 case MethodListType::OptionalProtocolInstanceMethods:
3793 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3794 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3797 case MethodListType::OptionalProtocolClassMethods:
3798 prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3799 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3804 // Return null for empty list.
3805 if (methods.empty())
3806 return llvm::Constant::getNullValue(forProtocol
3807 ? ObjCTypes.MethodDescriptionListPtrTy
3808 : ObjCTypes.MethodListPtrTy);
3810 // For protocols, this is an objc_method_description_list, which has
3811 // a slightly different structure.
3813 ConstantInitBuilder builder(CGM);
3814 auto values = builder.beginStruct();
3815 values.addInt(ObjCTypes.IntTy, methods.size());
3816 auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3817 for (auto MD : methods) {
3818 emitMethodDescriptionConstant(methodArray, MD);
3820 methodArray.finishAndAddTo(values);
3822 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3823 CGM.getPointerAlign(), true);
3824 return llvm::ConstantExpr::getBitCast(GV,
3825 ObjCTypes.MethodDescriptionListPtrTy);
3828 // Otherwise, it's an objc_method_list.
3829 ConstantInitBuilder builder(CGM);
3830 auto values = builder.beginStruct();
3831 values.addNullPointer(ObjCTypes.Int8PtrTy);
3832 values.addInt(ObjCTypes.IntTy, methods.size());
3833 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
3834 for (auto MD : methods) {
3835 emitMethodConstant(methodArray, MD);
3837 methodArray.finishAndAddTo(values);
3839 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3840 CGM.getPointerAlign(), true);
3841 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
3844 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
3845 const ObjCContainerDecl *CD) {
3846 SmallString<256> Name;
3847 GetNameForMethod(OMD, CD, Name);
3849 CodeGenTypes &Types = CGM.getTypes();
3850 llvm::FunctionType *MethodTy =
3851 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
3852 llvm::Function *Method =
3853 llvm::Function::Create(MethodTy,
3854 llvm::GlobalValue::InternalLinkage,
3857 MethodDefinitions.insert(std::make_pair(OMD, Method));
3862 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3863 ConstantStructBuilder &Init,
3867 llvm::GlobalVariable *GV =
3868 Init.finishAndCreateGlobal(Name, Align, /*constant*/ false,
3869 llvm::GlobalValue::PrivateLinkage);
3870 if (!Section.empty())
3871 GV->setSection(Section);
3873 CGM.addCompilerUsedGlobal(GV);
3877 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3878 llvm::Constant *Init,
3882 llvm::Type *Ty = Init->getType();
3883 llvm::GlobalVariable *GV =
3884 new llvm::GlobalVariable(CGM.getModule(), Ty, false,
3885 llvm::GlobalValue::PrivateLinkage, Init, Name);
3886 if (!Section.empty())
3887 GV->setSection(Section);
3888 GV->setAlignment(Align.getQuantity());
3890 CGM.addCompilerUsedGlobal(GV);
3894 llvm::GlobalVariable *
3895 CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
3896 bool ForceNonFragileABI,
3897 bool NullTerminate) {
3900 case ObjCLabelType::ClassName: Label = "OBJC_CLASS_NAME_"; break;
3901 case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
3902 case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
3903 case ObjCLabelType::PropertyName: Label = "OBJC_PROP_NAME_ATTR_"; break;
3906 bool NonFragile = ForceNonFragileABI || isNonFragileABI();
3910 case ObjCLabelType::ClassName:
3911 Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
3912 : "__TEXT,__cstring,cstring_literals";
3914 case ObjCLabelType::MethodVarName:
3915 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
3916 : "__TEXT,__cstring,cstring_literals";
3918 case ObjCLabelType::MethodVarType:
3919 Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
3920 : "__TEXT,__cstring,cstring_literals";
3922 case ObjCLabelType::PropertyName:
3923 Section = "__TEXT,__cstring,cstring_literals";
3927 llvm::Constant *Value =
3928 llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
3929 llvm::GlobalVariable *GV =
3930 new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
3931 /*isConstant=*/true,
3932 llvm::GlobalValue::PrivateLinkage, Value, Label);
3933 if (CGM.getTriple().isOSBinFormatMachO())
3934 GV->setSection(Section);
3935 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3936 GV->setAlignment(CharUnits::One().getQuantity());
3937 CGM.addCompilerUsedGlobal(GV);
3942 llvm::Function *CGObjCMac::ModuleInitFunction() {
3943 // Abuse this interface function as a place to finalize.
3948 llvm::Constant *CGObjCMac::GetPropertyGetFunction() {
3949 return ObjCTypes.getGetPropertyFn();
3952 llvm::Constant *CGObjCMac::GetPropertySetFunction() {
3953 return ObjCTypes.getSetPropertyFn();
3956 llvm::Constant *CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
3958 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
3961 llvm::Constant *CGObjCMac::GetGetStructFunction() {
3962 return ObjCTypes.getCopyStructFn();
3965 llvm::Constant *CGObjCMac::GetSetStructFunction() {
3966 return ObjCTypes.getCopyStructFn();
3969 llvm::Constant *CGObjCMac::GetCppAtomicObjectGetFunction() {
3970 return ObjCTypes.getCppAtomicObjectFunction();
3973 llvm::Constant *CGObjCMac::GetCppAtomicObjectSetFunction() {
3974 return ObjCTypes.getCppAtomicObjectFunction();
3977 llvm::Constant *CGObjCMac::EnumerationMutationFunction() {
3978 return ObjCTypes.getEnumerationMutationFn();
3981 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
3982 return EmitTryOrSynchronizedStmt(CGF, S);
3985 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
3986 const ObjCAtSynchronizedStmt &S) {
3987 return EmitTryOrSynchronizedStmt(CGF, S);
3991 struct PerformFragileFinally final : EHScopeStack::Cleanup {
3993 Address SyncArgSlot;
3994 Address CallTryExitVar;
3995 Address ExceptionData;
3996 ObjCTypesHelper &ObjCTypes;
3997 PerformFragileFinally(const Stmt *S,
3998 Address SyncArgSlot,
3999 Address CallTryExitVar,
4000 Address ExceptionData,
4001 ObjCTypesHelper *ObjCTypes)
4002 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4003 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4005 void Emit(CodeGenFunction &CGF, Flags flags) override {
4006 // Check whether we need to call objc_exception_try_exit.
4007 // In optimized code, this branch will always be folded.
4008 llvm::BasicBlock *FinallyCallExit =
4009 CGF.createBasicBlock("finally.call_exit");
4010 llvm::BasicBlock *FinallyNoCallExit =
4011 CGF.createBasicBlock("finally.no_call_exit");
4012 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4013 FinallyCallExit, FinallyNoCallExit);
4015 CGF.EmitBlock(FinallyCallExit);
4016 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4017 ExceptionData.getPointer());
4019 CGF.EmitBlock(FinallyNoCallExit);
4021 if (isa<ObjCAtTryStmt>(S)) {
4022 if (const ObjCAtFinallyStmt* FinallyStmt =
4023 cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4024 // Don't try to do the @finally if this is an EH cleanup.
4025 if (flags.isForEHCleanup()) return;
4027 // Save the current cleanup destination in case there's
4028 // control flow inside the finally statement.
4029 llvm::Value *CurCleanupDest =
4030 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
4032 CGF.EmitStmt(FinallyStmt->getFinallyBody());
4034 if (CGF.HaveInsertPoint()) {
4035 CGF.Builder.CreateStore(CurCleanupDest,
4036 CGF.getNormalCleanupDestSlot());
4038 // Currently, the end of the cleanup must always exist.
4039 CGF.EnsureInsertPoint();
4043 // Emit objc_sync_exit(expr); as finally's sole statement for
4045 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4046 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4051 class FragileHazards {
4052 CodeGenFunction &CGF;
4053 SmallVector<llvm::Value*, 20> Locals;
4054 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4056 llvm::InlineAsm *ReadHazard;
4057 llvm::InlineAsm *WriteHazard;
4059 llvm::FunctionType *GetAsmFnType();
4061 void collectLocals();
4062 void emitReadHazard(CGBuilderTy &Builder);
4065 FragileHazards(CodeGenFunction &CGF);
4067 void emitWriteHazard();
4068 void emitHazardsInNewBlocks();
4070 } // end anonymous namespace
4072 /// Create the fragile-ABI read and write hazards based on the current
4073 /// state of the function, which is presumed to be immediately prior
4074 /// to a @try block. These hazards are used to maintain correct
4075 /// semantics in the face of optimization and the fragile ABI's
4076 /// cavalier use of setjmp/longjmp.
4077 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4080 if (Locals.empty()) return;
4082 // Collect all the blocks in the function.
4083 for (llvm::Function::iterator
4084 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
4085 BlocksBeforeTry.insert(&*I);
4087 llvm::FunctionType *AsmFnTy = GetAsmFnType();
4089 // Create a read hazard for the allocas. This inhibits dead-store
4090 // optimizations and forces the values to memory. This hazard is
4091 // inserted before any 'throwing' calls in the protected scope to
4092 // reflect the possibility that the variables might be read from the
4093 // catch block if the call throws.
4095 std::string Constraint;
4096 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4097 if (I) Constraint += ',';
4101 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4104 // Create a write hazard for the allocas. This inhibits folding
4105 // loads across the hazard. This hazard is inserted at the
4106 // beginning of the catch path to reflect the possibility that the
4107 // variables might have been written within the protected scope.
4109 std::string Constraint;
4110 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4111 if (I) Constraint += ',';
4112 Constraint += "=*m";
4115 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4119 /// Emit a write hazard at the current location.
4120 void FragileHazards::emitWriteHazard() {
4121 if (Locals.empty()) return;
4123 CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4126 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4127 assert(!Locals.empty());
4128 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4129 call->setDoesNotThrow();
4130 call->setCallingConv(CGF.getRuntimeCC());
4133 /// Emit read hazards in all the protected blocks, i.e. all the blocks
4134 /// which have been inserted since the beginning of the try.
4135 void FragileHazards::emitHazardsInNewBlocks() {
4136 if (Locals.empty()) return;
4138 CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4140 // Iterate through all blocks, skipping those prior to the try.
4141 for (llvm::Function::iterator
4142 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
4143 llvm::BasicBlock &BB = *FI;
4144 if (BlocksBeforeTry.count(&BB)) continue;
4146 // Walk through all the calls in the block.
4147 for (llvm::BasicBlock::iterator
4148 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
4149 llvm::Instruction &I = *BI;
4151 // Ignore instructions that aren't non-intrinsic calls.
4152 // These are the only calls that can possibly call longjmp.
4153 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) continue;
4154 if (isa<llvm::IntrinsicInst>(I))
4157 // Ignore call sites marked nounwind. This may be questionable,
4158 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4159 llvm::CallSite CS(&I);
4160 if (CS.doesNotThrow()) continue;
4162 // Insert a read hazard before the call. This will ensure that
4163 // any writes to the locals are performed before making the
4164 // call. If the call throws, then this is sufficient to
4165 // guarantee correctness as long as it doesn't also write to any
4167 Builder.SetInsertPoint(&BB, BI);
4168 emitReadHazard(Builder);
4173 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, llvm::Value *V) {
4177 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
4178 if (V.isValid()) S.insert(V.getPointer());
4181 void FragileHazards::collectLocals() {
4182 // Compute a set of allocas to ignore.
4183 llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4184 addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4185 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4187 // Collect all the allocas currently in the function. This is
4188 // probably way too aggressive.
4189 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4190 for (llvm::BasicBlock::iterator
4191 I = Entry.begin(), E = Entry.end(); I != E; ++I)
4192 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
4193 Locals.push_back(&*I);
4196 llvm::FunctionType *FragileHazards::GetAsmFnType() {
4197 SmallVector<llvm::Type *, 16> tys(Locals.size());
4198 for (unsigned i = 0, e = Locals.size(); i != e; ++i)
4199 tys[i] = Locals[i]->getType();
4200 return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4205 Objective-C setjmp-longjmp (sjlj) Exception Handling
4208 A catch buffer is a setjmp buffer plus:
4209 - a pointer to the exception that was caught
4210 - a pointer to the previous exception data buffer
4211 - two pointers of reserved storage
4212 Therefore catch buffers form a stack, with a pointer to the top
4213 of the stack kept in thread-local storage.
4215 objc_exception_try_enter pushes a catch buffer onto the EH stack.
4216 objc_exception_try_exit pops the given catch buffer, which is
4217 required to be the top of the EH stack.
4218 objc_exception_throw pops the top of the EH stack, writes the
4219 thrown exception into the appropriate field, and longjmps
4220 to the setjmp buffer. It crashes the process (with a printf
4221 and an abort()) if there are no catch buffers on the stack.
4222 objc_exception_extract just reads the exception pointer out of the
4225 There's no reason an implementation couldn't use a light-weight
4226 setjmp here --- something like __builtin_setjmp, but API-compatible
4227 with the heavyweight setjmp. This will be more important if we ever
4228 want to implement correct ObjC/C++ exception interactions for the
4231 Note that for this use of setjmp/longjmp to be correct, we may need
4232 to mark some local variables volatile: if a non-volatile local
4233 variable is modified between the setjmp and the longjmp, it has
4234 indeterminate value. For the purposes of LLVM IR, it may be
4235 sufficient to make loads and stores within the @try (to variables
4236 declared outside the @try) volatile. This is necessary for
4237 optimized correctness, but is not currently being done; this is
4238 being tracked as rdar://problem/8160285
4240 The basic framework for a @try-catch-finally is as follows:
4242 objc_exception_data d;
4244 bool _call_try_exit = true;
4246 objc_exception_try_enter(&d);
4247 if (!setjmp(d.jmp_buf)) {
4251 id _caught = objc_exception_extract(&d);
4253 // enter new try scope for handlers
4254 if (!setjmp(d.jmp_buf)) {
4255 ... match exception and execute catch blocks ...
4257 // fell off end, rethrow.
4259 ... jump-through-finally to finally_rethrow ...
4261 // exception in catch block
4262 _rethrow = objc_exception_extract(&d);
4263 _call_try_exit = false;
4264 ... jump-through-finally to finally_rethrow ...
4267 ... jump-through-finally to finally_end ...
4271 objc_exception_try_exit(&d);
4273 ... finally block ....
4274 ... dispatch to finally destination ...
4277 objc_exception_throw(_rethrow);
4282 This framework differs slightly from the one gcc uses, in that gcc
4283 uses _rethrow to determine if objc_exception_try_exit should be called
4284 and if the object should be rethrown. This breaks in the face of
4285 throwing nil and introduces unnecessary branches.
4287 We specialize this framework for a few particular circumstances:
4289 - If there are no catch blocks, then we avoid emitting the second
4290 exception handling context.
4292 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4293 e)) we avoid emitting the code to rethrow an uncaught exception.
4295 - FIXME: If there is no @finally block we can do a few more
4298 Rethrows and Jumps-Through-Finally
4301 '@throw;' is supported by pushing the currently-caught exception
4302 onto ObjCEHStack while the @catch blocks are emitted.
4304 Branches through the @finally block are handled with an ordinary
4305 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
4306 exceptions are not compatible with C++ exceptions, and this is
4307 hardly the only place where this will go wrong.
4309 @synchronized(expr) { stmt; } is emitted as if it were:
4310 id synch_value = expr;
4311 objc_sync_enter(synch_value);
4312 @try { stmt; } @finally { objc_sync_exit(synch_value); }
4315 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4317 bool isTry = isa<ObjCAtTryStmt>(S);
4319 // A destination for the fall-through edges of the catch handlers to
4321 CodeGenFunction::JumpDest FinallyEnd =
4322 CGF.getJumpDestInCurrentScope("finally.end");
4324 // A destination for the rethrow edge of the catch handlers to jump
4326 CodeGenFunction::JumpDest FinallyRethrow =
4327 CGF.getJumpDestInCurrentScope("finally.rethrow");
4329 // For @synchronized, call objc_sync_enter(sync.expr). The
4330 // evaluation of the expression must occur before we enter the
4331 // @synchronized. We can't avoid a temp here because we need the
4332 // value to be preserved. If the backend ever does liveness
4333 // correctly after setjmp, this will be unnecessary.
4334 Address SyncArgSlot = Address::invalid();
4336 llvm::Value *SyncArg =
4337 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4338 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4339 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4341 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4342 CGF.getPointerAlign(), "sync.arg");
4343 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4346 // Allocate memory for the setjmp buffer. This needs to be kept
4347 // live throughout the try and catch blocks.
4348 Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4349 CGF.getPointerAlign(),
4350 "exceptiondata.ptr");
4352 // Create the fragile hazards. Note that this will not capture any
4353 // of the allocas required for exception processing, but will
4354 // capture the current basic block (which extends all the way to the
4355 // setjmp call) as "before the @try".
4356 FragileHazards Hazards(CGF);
4358 // Create a flag indicating whether the cleanup needs to call
4359 // objc_exception_try_exit. This is true except when
4360 // - no catches match and we're branching through the cleanup
4361 // just to rethrow the exception, or
4362 // - a catch matched and we're falling out of the catch handler.
4363 // The setjmp-safety rule here is that we should always store to this
4364 // variable in a place that dominates the branch through the cleanup
4365 // without passing through any setjmps.
4366 Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4370 // A slot containing the exception to rethrow. Only needed when we
4371 // have both a @catch and a @finally.
4372 Address PropagatingExnVar = Address::invalid();
4374 // Push a normal cleanup to leave the try scope.
4375 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4381 // Enter a try block:
4382 // - Call objc_exception_try_enter to push ExceptionData on top of
4384 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4385 ExceptionData.getPointer());
4387 // - Call setjmp on the exception data buffer.
4388 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4389 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4390 llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4391 ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4393 llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4394 ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4395 SetJmpResult->setCanReturnTwice();
4397 // If setjmp returned 0, enter the protected block; otherwise,
4398 // branch to the handler.
4399 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4400 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4401 llvm::Value *DidCatch =
4402 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4403 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4405 // Emit the protected block.
4406 CGF.EmitBlock(TryBlock);
4407 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4408 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4409 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4411 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4413 // Emit the exception handler block.
4414 CGF.EmitBlock(TryHandler);
4416 // Don't optimize loads of the in-scope locals across this point.
4417 Hazards.emitWriteHazard();
4419 // For a @synchronized (or a @try with no catches), just branch
4420 // through the cleanup to the rethrow block.
4421 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4422 // Tell the cleanup not to re-pop the exit.
4423 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4424 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4426 // Otherwise, we have to match against the caught exceptions.
4428 // Retrieve the exception object. We may emit multiple blocks but
4429 // nothing can cross this so the value is already in SSA form.
4430 llvm::CallInst *Caught =
4431 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4432 ExceptionData.getPointer(), "caught");
4434 // Push the exception to rethrow onto the EH value stack for the
4435 // benefit of any @throws in the handlers.
4436 CGF.ObjCEHValueStack.push_back(Caught);
4438 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4440 bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4442 llvm::BasicBlock *CatchBlock = nullptr;
4443 llvm::BasicBlock *CatchHandler = nullptr;
4445 // Save the currently-propagating exception before
4446 // objc_exception_try_enter clears the exception slot.
4447 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4448 CGF.getPointerAlign(),
4449 "propagating_exception");
4450 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4452 // Enter a new exception try block (in case a @catch block
4453 // throws an exception).
4454 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4455 ExceptionData.getPointer());
4457 llvm::CallInst *SetJmpResult =
4458 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4459 SetJmpBuffer, "setjmp.result");
4460 SetJmpResult->setCanReturnTwice();
4462 llvm::Value *Threw =
4463 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4465 CatchBlock = CGF.createBasicBlock("catch");
4466 CatchHandler = CGF.createBasicBlock("catch_for_catch");
4467 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4469 CGF.EmitBlock(CatchBlock);
4472 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4474 // Handle catch list. As a special case we check if everything is
4475 // matched and avoid generating code for falling off the end if
4477 bool AllMatched = false;
4478 for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
4479 const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4481 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4482 const ObjCObjectPointerType *OPT = nullptr;
4484 // catch(...) always matches.
4488 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4490 // catch(id e) always matches under this ABI, since only
4491 // ObjC exceptions end up here in the first place.
4492 // FIXME: For the time being we also match id<X>; this should
4493 // be rejected by Sema instead.
4494 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4498 // If this is a catch-all, we don't need to test anything.
4500 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4503 CGF.EmitAutoVarDecl(*CatchParam);
4504 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4506 // These types work out because ConvertType(id) == i8*.
4507 EmitInitOfCatchParam(CGF, Caught, CatchParam);
4510 CGF.EmitStmt(CatchStmt->getCatchBody());
4512 // The scope of the catch variable ends right here.
4513 CatchVarCleanups.ForceCleanup();
4515 CGF.EmitBranchThroughCleanup(FinallyEnd);
4519 assert(OPT && "Unexpected non-object pointer type in @catch");
4520 const ObjCObjectType *ObjTy = OPT->getObjectType();
4522 // FIXME: @catch (Class c) ?
4523 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4524 assert(IDecl && "Catch parameter must have Objective-C type!");
4526 // Check if the @catch block matches the exception object.
4527 llvm::Value *Class = EmitClassRef(CGF, IDecl);
4529 llvm::Value *matchArgs[] = { Class, Caught };
4530 llvm::CallInst *Match =
4531 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4532 matchArgs, "match");
4534 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4535 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4537 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4538 MatchedBlock, NextCatchBlock);
4540 // Emit the @catch block.
4541 CGF.EmitBlock(MatchedBlock);
4543 // Collect any cleanups for the catch variable. The scope lasts until
4544 // the end of the catch body.
4545 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4547 CGF.EmitAutoVarDecl(*CatchParam);
4548 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4550 // Initialize the catch variable.
4552 CGF.Builder.CreateBitCast(Caught,
4553 CGF.ConvertType(CatchParam->getType()));
4554 EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4556 CGF.EmitStmt(CatchStmt->getCatchBody());
4558 // We're done with the catch variable.
4559 CatchVarCleanups.ForceCleanup();
4561 CGF.EmitBranchThroughCleanup(FinallyEnd);
4563 CGF.EmitBlock(NextCatchBlock);
4566 CGF.ObjCEHValueStack.pop_back();
4568 // If nothing wanted anything to do with the caught exception,
4569 // kill the extract call.
4570 if (Caught->use_empty())
4571 Caught->eraseFromParent();
4574 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4577 // Emit the exception handler for the @catch blocks.
4578 CGF.EmitBlock(CatchHandler);
4580 // In theory we might now need a write hazard, but actually it's
4581 // unnecessary because there's no local-accessing code between
4582 // the try's write hazard and here.
4583 //Hazards.emitWriteHazard();
4585 // Extract the new exception and save it to the
4586 // propagating-exception slot.
4587 assert(PropagatingExnVar.isValid());
4588 llvm::CallInst *NewCaught =
4589 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4590 ExceptionData.getPointer(), "caught");
4591 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4593 // Don't pop the catch handler; the throw already did.
4594 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4595 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4599 // Insert read hazards as required in the new blocks.
4600 Hazards.emitHazardsInNewBlocks();
4603 CGF.Builder.restoreIP(TryFallthroughIP);
4604 if (CGF.HaveInsertPoint())
4605 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4606 CGF.PopCleanupBlock();
4607 CGF.EmitBlock(FinallyEnd.getBlock(), true);
4609 // Emit the rethrow block.
4610 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4611 CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4612 if (CGF.HaveInsertPoint()) {
4613 // If we have a propagating-exception variable, check it.
4614 llvm::Value *PropagatingExn;
4615 if (PropagatingExnVar.isValid()) {
4616 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4618 // Otherwise, just look in the buffer for the exception to throw.
4620 llvm::CallInst *Caught =
4621 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4622 ExceptionData.getPointer());
4623 PropagatingExn = Caught;
4626 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4628 CGF.Builder.CreateUnreachable();
4631 CGF.Builder.restoreIP(SavedIP);
4634 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4635 const ObjCAtThrowStmt &S,
4636 bool ClearInsertionPoint) {
4637 llvm::Value *ExceptionAsObject;
4639 if (const Expr *ThrowExpr = S.getThrowExpr()) {
4640 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4642 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4644 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4645 "Unexpected rethrow outside @catch block.");
4646 ExceptionAsObject = CGF.ObjCEHValueStack.back();
4649 CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4650 ->setDoesNotReturn();
4651 CGF.Builder.CreateUnreachable();
4653 // Clear the insertion point to indicate we are in unreachable code.
4654 if (ClearInsertionPoint)
4655 CGF.Builder.ClearInsertionPoint();
4658 /// EmitObjCWeakRead - Code gen for loading value of a __weak
4659 /// object: objc_read_weak (id *src)
4661 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4662 Address AddrWeakObj) {
4663 llvm::Type* DestTy = AddrWeakObj.getElementType();
4664 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4665 ObjCTypes.PtrObjectPtrTy);
4666 llvm::Value *read_weak =
4667 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4668 AddrWeakObj.getPointer(), "weakread");
4669 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4673 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4674 /// objc_assign_weak (id src, id *dst)
4676 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4677 llvm::Value *src, Address dst) {
4678 llvm::Type * SrcTy = src->getType();
4679 if (!isa<llvm::PointerType>(SrcTy)) {
4680 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4681 assert(Size <= 8 && "does not support size > 8");
4682 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4683 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4684 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4686 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4687 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4688 llvm::Value *args[] = { src, dst.getPointer() };
4689 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4690 args, "weakassign");
4693 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4694 /// objc_assign_global (id src, id *dst)
4696 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4697 llvm::Value *src, Address dst,
4699 llvm::Type * SrcTy = src->getType();
4700 if (!isa<llvm::PointerType>(SrcTy)) {
4701 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4702 assert(Size <= 8 && "does not support size > 8");
4703 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4704 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4705 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4707 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4708 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4709 llvm::Value *args[] = { src, dst.getPointer() };
4711 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4712 args, "globalassign");
4714 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4715 args, "threadlocalassign");
4718 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4719 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4721 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4722 llvm::Value *src, Address dst,
4723 llvm::Value *ivarOffset) {
4724 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
4725 llvm::Type * SrcTy = src->getType();
4726 if (!isa<llvm::PointerType>(SrcTy)) {
4727 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4728 assert(Size <= 8 && "does not support size > 8");
4729 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4730 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4731 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4733 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4734 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4735 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
4736 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
4739 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
4740 /// objc_assign_strongCast (id src, id *dst)
4742 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
4743 llvm::Value *src, Address dst) {
4744 llvm::Type * SrcTy = src->getType();
4745 if (!isa<llvm::PointerType>(SrcTy)) {
4746 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4747 assert(Size <= 8 && "does not support size > 8");
4748 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4749 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4750 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4752 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4753 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4754 llvm::Value *args[] = { src, dst.getPointer() };
4755 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
4756 args, "strongassign");
4759 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
4762 llvm::Value *size) {
4763 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
4764 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
4765 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
4766 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
4769 /// EmitObjCValueForIvar - Code Gen for ivar reference.
4771 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
4773 llvm::Value *BaseValue,
4774 const ObjCIvarDecl *Ivar,
4775 unsigned CVRQualifiers) {
4776 const ObjCInterfaceDecl *ID =
4777 ObjectTy->getAs<ObjCObjectType>()->getInterface();
4778 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
4779 EmitIvarOffset(CGF, ID, Ivar));
4782 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
4783 const ObjCInterfaceDecl *Interface,
4784 const ObjCIvarDecl *Ivar) {
4785 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
4786 return llvm::ConstantInt::get(
4787 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
4791 /* *** Private Interface *** */
4793 /// EmitImageInfo - Emit the image info marker used to encode some module
4794 /// level information.
4796 /// See: <rdr://4810609&4810587&4810587>
4797 /// struct IMAGE_INFO {
4798 /// unsigned version;
4801 enum ImageInfoFlags {
4802 eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang.
4803 eImageInfo_GarbageCollected = (1 << 1),
4804 eImageInfo_GCOnly = (1 << 2),
4805 eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache.
4807 // A flag indicating that the module has no instances of a @synthesize of a
4808 // superclass variable. <rdar://problem/6803242>
4809 eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
4810 eImageInfo_ImageIsSimulated = (1 << 5),
4811 eImageInfo_ClassProperties = (1 << 6)
4814 void CGObjCCommonMac::EmitImageInfo() {
4815 unsigned version = 0; // Version is unused?
4816 const char *Section = (ObjCABI == 1) ?
4817 "__OBJC, __image_info,regular" :
4818 "__DATA, __objc_imageinfo, regular, no_dead_strip";
4820 // Generate module-level named metadata to convey this information to the
4821 // linker and code-gen.
4822 llvm::Module &Mod = CGM.getModule();
4824 // Add the ObjC ABI version to the module flags.
4825 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
4826 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
4828 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
4829 llvm::MDString::get(VMContext,Section));
4831 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
4832 // Non-GC overrides those files which specify GC.
4833 Mod.addModuleFlag(llvm::Module::Override,
4834 "Objective-C Garbage Collection", (uint32_t)0);
4836 // Add the ObjC garbage collection value.
4837 Mod.addModuleFlag(llvm::Module::Error,
4838 "Objective-C Garbage Collection",
4839 eImageInfo_GarbageCollected);
4841 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
4842 // Add the ObjC GC Only value.
4843 Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
4846 // Require that GC be specified and set to eImageInfo_GarbageCollected.
4847 llvm::Metadata *Ops[2] = {
4848 llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
4849 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
4850 llvm::Type::getInt32Ty(VMContext), eImageInfo_GarbageCollected))};
4851 Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
4852 llvm::MDNode::get(VMContext, Ops));
4856 // Indicate whether we're compiling this to run on a simulator.
4857 const llvm::Triple &Triple = CGM.getTarget().getTriple();
4858 if ((Triple.isiOS() || Triple.isWatchOS()) &&
4859 (Triple.getArch() == llvm::Triple::x86 ||
4860 Triple.getArch() == llvm::Triple::x86_64))
4861 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
4862 eImageInfo_ImageIsSimulated);
4864 // Indicate whether we are generating class properties.
4865 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
4866 eImageInfo_ClassProperties);
4869 // struct objc_module {
4870 // unsigned long version;
4871 // unsigned long size;
4872 // const char *name;
4876 // FIXME: Get from somewhere
4877 static const int ModuleVersion = 7;
4879 void CGObjCMac::EmitModuleInfo() {
4880 uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
4882 ConstantInitBuilder builder(CGM);
4883 auto values = builder.beginStruct(ObjCTypes.ModuleTy);
4884 values.addInt(ObjCTypes.LongTy, ModuleVersion);
4885 values.addInt(ObjCTypes.LongTy, Size);
4886 // This used to be the filename, now it is unused. <rdr://4327263>
4887 values.add(GetClassName(StringRef("")));
4888 values.add(EmitModuleSymbols());
4889 CreateMetadataVar("OBJC_MODULES", values,
4890 "__OBJC,__module_info,regular,no_dead_strip",
4891 CGM.getPointerAlign(), true);
4894 llvm::Constant *CGObjCMac::EmitModuleSymbols() {
4895 unsigned NumClasses = DefinedClasses.size();
4896 unsigned NumCategories = DefinedCategories.size();
4898 // Return null if no symbols were defined.
4899 if (!NumClasses && !NumCategories)
4900 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
4902 ConstantInitBuilder builder(CGM);
4903 auto values = builder.beginStruct();
4904 values.addInt(ObjCTypes.LongTy, 0);
4905 values.addNullPointer(ObjCTypes.SelectorPtrTy);
4906 values.addInt(ObjCTypes.ShortTy, NumClasses);
4907 values.addInt(ObjCTypes.ShortTy, NumCategories);
4909 // The runtime expects exactly the list of defined classes followed
4910 // by the list of defined categories, in a single array.
4911 auto array = values.beginArray(ObjCTypes.Int8PtrTy);
4912 for (unsigned i=0; i<NumClasses; i++) {
4913 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
4915 if (ObjCImplementationDecl *IMP = ID->getImplementation())
4916 // We are implementing a weak imported interface. Give it external linkage
4917 if (ID->isWeakImported() && !IMP->isWeakImported())
4918 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
4920 array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy);
4922 for (unsigned i=0; i<NumCategories; i++)
4923 array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy);
4925 array.finishAndAddTo(values);
4927 llvm::GlobalVariable *GV = CreateMetadataVar(
4928 "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip",
4929 CGM.getPointerAlign(), true);
4930 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
4933 llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
4934 IdentifierInfo *II) {
4935 LazySymbols.insert(II);
4937 llvm::GlobalVariable *&Entry = ClassReferences[II];
4940 llvm::Constant *Casted =
4941 llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
4942 ObjCTypes.ClassPtrTy);
4943 Entry = CreateMetadataVar(
4944 "OBJC_CLASS_REFERENCES_", Casted,
4945 "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
4946 CGM.getPointerAlign(), true);
4949 return CGF.Builder.CreateAlignedLoad(Entry, CGF.getPointerAlign());
4952 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
4953 const ObjCInterfaceDecl *ID) {
4954 // If the class has the objc_runtime_visible attribute, we need to
4955 // use the Objective-C runtime to get the class.
4956 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
4957 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
4959 return EmitClassRefFromId(CGF, ID->getIdentifier());
4962 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
4963 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
4964 return EmitClassRefFromId(CGF, II);
4967 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
4968 return CGF.Builder.CreateLoad(EmitSelectorAddr(CGF, Sel));
4971 Address CGObjCMac::EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel) {
4972 CharUnits Align = CGF.getPointerAlign();
4974 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
4976 llvm::Constant *Casted =
4977 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
4978 ObjCTypes.SelectorPtrTy);
4979 Entry = CreateMetadataVar(
4980 "OBJC_SELECTOR_REFERENCES_", Casted,
4981 "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
4982 Entry->setExternallyInitialized(true);
4985 return Address(Entry, Align);
4988 llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
4989 llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
4991 Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
4992 return getConstantGEP(VMContext, Entry, 0, 0);
4995 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
4996 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
4997 I = MethodDefinitions.find(MD);
4998 if (I != MethodDefinitions.end())
5004 /// GetIvarLayoutName - Returns a unique constant for the given
5005 /// ivar layout bitmap.
5006 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
5007 const ObjCCommonTypesHelper &ObjCTypes) {
5008 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5011 void IvarLayoutBuilder::visitRecord(const RecordType *RT,
5013 const RecordDecl *RD = RT->getDecl();
5015 // If this is a union, remember that we had one, because it might mess
5016 // up the ordering of layout entries.
5018 IsDisordered = true;
5020 const ASTRecordLayout *recLayout = nullptr;
5021 visitAggregate(RD->field_begin(), RD->field_end(), offset,
5022 [&](const FieldDecl *field) -> CharUnits {
5024 recLayout = &CGM.getContext().getASTRecordLayout(RD);
5025 auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
5026 return CGM.getContext().toCharUnitsFromBits(offsetInBits);
5030 template <class Iterator, class GetOffsetFn>
5031 void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
5032 CharUnits aggregateOffset,
5033 const GetOffsetFn &getOffset) {
5034 for (; begin != end; ++begin) {
5035 auto field = *begin;
5037 // Skip over bitfields.
5038 if (field->isBitField()) {
5042 // Compute the offset of the field within the aggregate.
5043 CharUnits fieldOffset = aggregateOffset + getOffset(field);
5045 visitField(field, fieldOffset);
5049 /// Collect layout information for the given fields into IvarsInfo.
5050 void IvarLayoutBuilder::visitField(const FieldDecl *field,
5051 CharUnits fieldOffset) {
5052 QualType fieldType = field->getType();
5054 // Drill down into arrays.
5055 uint64_t numElts = 1;
5056 while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
5057 numElts *= arrayType->getSize().getZExtValue();
5058 fieldType = arrayType->getElementType();
5061 assert(!fieldType->isArrayType() && "ivar of non-constant array type?");
5063 // If we ended up with a zero-sized array, we've done what we can do within
5064 // the limits of this layout encoding.
5065 if (numElts == 0) return;
5067 // Recurse if the base element type is a record type.
5068 if (auto recType = fieldType->getAs<RecordType>()) {
5069 size_t oldEnd = IvarsInfo.size();
5071 visitRecord(recType, fieldOffset);
5073 // If we have an array, replicate the first entry's layout information.
5074 auto numEltEntries = IvarsInfo.size() - oldEnd;
5075 if (numElts != 1 && numEltEntries != 0) {
5076 CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5077 for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
5078 // Copy the last numEltEntries onto the end of the array, adjusting
5079 // each for the element size.
5080 for (size_t i = 0; i != numEltEntries; ++i) {
5081 auto firstEntry = IvarsInfo[oldEnd + i];
5082 IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
5083 firstEntry.SizeInWords));
5091 // Classify the element type.
5092 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
5094 // If it matches what we're looking for, add an entry.
5095 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
5096 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
5097 assert(CGM.getContext().getTypeSizeInChars(fieldType)
5098 == CGM.getPointerSize());
5099 IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
5103 /// buildBitmap - This routine does the horsework of taking the offsets of
5104 /// strong/weak references and creating a bitmap. The bitmap is also
5105 /// returned in the given buffer, suitable for being passed to \c dump().
5106 llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
5107 llvm::SmallVectorImpl<unsigned char> &buffer) {
5108 // The bitmap is a series of skip/scan instructions, aligned to word
5109 // boundaries. The skip is performed first.
5110 const unsigned char MaxNibble = 0xF;
5111 const unsigned char SkipMask = 0xF0, SkipShift = 4;
5112 const unsigned char ScanMask = 0x0F, ScanShift = 0;
5114 assert(!IvarsInfo.empty() && "generating bitmap for no data");
5116 // Sort the ivar info on byte position in case we encounterred a
5117 // union nested in the ivar list.
5119 // This isn't a stable sort, but our algorithm should handle it fine.
5120 llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
5122 assert(std::is_sorted(IvarsInfo.begin(), IvarsInfo.end()));
5124 assert(IvarsInfo.back().Offset < InstanceEnd);
5126 assert(buffer.empty());
5128 // Skip the next N words.
5129 auto skip = [&](unsigned numWords) {
5130 assert(numWords > 0);
5132 // Try to merge into the previous byte. Since scans happen second, we
5133 // can't do this if it includes a scan.
5134 if (!buffer.empty() && !(buffer.back() & ScanMask)) {
5135 unsigned lastSkip = buffer.back() >> SkipShift;
5136 if (lastSkip < MaxNibble) {
5137 unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
5138 numWords -= claimed;
5139 lastSkip += claimed;
5140 buffer.back() = (lastSkip << SkipShift);
5144 while (numWords >= MaxNibble) {
5145 buffer.push_back(MaxNibble << SkipShift);
5146 numWords -= MaxNibble;
5149 buffer.push_back(numWords << SkipShift);
5153 // Scan the next N words.
5154 auto scan = [&](unsigned numWords) {
5155 assert(numWords > 0);
5157 // Try to merge into the previous byte. Since scans happen second, we can
5158 // do this even if it includes a skip.
5159 if (!buffer.empty()) {
5160 unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
5161 if (lastScan < MaxNibble) {
5162 unsigned claimed = std::min(MaxNibble - lastScan, numWords);
5163 numWords -= claimed;
5164 lastScan += claimed;
5165 buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
5169 while (numWords >= MaxNibble) {
5170 buffer.push_back(MaxNibble << ScanShift);
5171 numWords -= MaxNibble;
5174 buffer.push_back(numWords << ScanShift);
5178 // One past the end of the last scan.
5179 unsigned endOfLastScanInWords = 0;
5180 const CharUnits WordSize = CGM.getPointerSize();
5182 // Consider all the scan requests.
5183 for (auto &request : IvarsInfo) {
5184 CharUnits beginOfScan = request.Offset - InstanceBegin;
5186 // Ignore scan requests that don't start at an even multiple of the
5187 // word size. We can't encode them.
5188 if ((beginOfScan % WordSize) != 0) continue;
5190 // Ignore scan requests that start before the instance start.
5191 // This assumes that scans never span that boundary. The boundary
5192 // isn't the true start of the ivars, because in the fragile-ARC case
5193 // it's rounded up to word alignment, but the test above should leave
5194 // us ignoring that possibility.
5195 if (beginOfScan.isNegative()) {
5196 assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin);
5200 unsigned beginOfScanInWords = beginOfScan / WordSize;
5201 unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
5203 // If the scan starts some number of words after the last one ended,
5205 if (beginOfScanInWords > endOfLastScanInWords) {
5206 skip(beginOfScanInWords - endOfLastScanInWords);
5208 // Otherwise, start scanning where the last left off.
5210 beginOfScanInWords = endOfLastScanInWords;
5212 // If that leaves us with nothing to scan, ignore this request.
5213 if (beginOfScanInWords >= endOfScanInWords) continue;
5216 // Scan to the end of the request.
5217 assert(beginOfScanInWords < endOfScanInWords);
5218 scan(endOfScanInWords - beginOfScanInWords);
5219 endOfLastScanInWords = endOfScanInWords;
5223 return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
5225 // For GC layouts, emit a skip to the end of the allocation so that we
5226 // have precise information about the entire thing. This isn't useful
5227 // or necessary for the ARC-style layout strings.
5228 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5229 unsigned lastOffsetInWords =
5230 (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5231 if (lastOffsetInWords > endOfLastScanInWords) {
5232 skip(lastOffsetInWords - endOfLastScanInWords);
5236 // Null terminate the string.
5237 buffer.push_back(0);
5239 auto *Entry = CGObjC.CreateCStringLiteral(
5240 reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
5241 return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5244 /// BuildIvarLayout - Builds ivar layout bitmap for the class
5245 /// implementation for the __strong or __weak case.
5246 /// The layout map displays which words in ivar list must be skipped
5247 /// and which must be scanned by GC (see below). String is built of bytes.
5248 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5249 /// of words to skip and right nibble is count of words to scan. So, each
5250 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5251 /// represented by a 0x00 byte which also ends the string.
5252 /// 1. when ForStrongLayout is true, following ivars are scanned:
5255 /// - __strong anything
5257 /// 2. When ForStrongLayout is false, following ivars are scanned:
5258 /// - __weak anything
5261 CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
5262 CharUnits beginOffset, CharUnits endOffset,
5263 bool ForStrongLayout, bool HasMRCWeakIvars) {
5264 // If this is MRC, and we're either building a strong layout or there
5265 // are no weak ivars, bail out early.
5266 llvm::Type *PtrTy = CGM.Int8PtrTy;
5267 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5268 !CGM.getLangOpts().ObjCAutoRefCount &&
5269 (ForStrongLayout || !HasMRCWeakIvars))
5270 return llvm::Constant::getNullValue(PtrTy);
5272 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5273 SmallVector<const ObjCIvarDecl*, 32> ivars;
5275 // GC layout strings include the complete object layout, possibly
5276 // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5279 // ARC layout strings only include the class's ivars. In non-fragile
5280 // runtimes, that means starting at InstanceStart, rounded up to word
5281 // alignment. In fragile runtimes, there's no InstanceStart, so it means
5282 // starting at the offset of the first ivar, rounded up to word alignment.
5284 // MRC weak layout strings follow the ARC style.
5285 CharUnits baseOffset;
5286 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5287 for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5288 IVD; IVD = IVD->getNextIvar())
5289 ivars.push_back(IVD);
5291 if (isNonFragileABI()) {
5292 baseOffset = beginOffset; // InstanceStart
5293 } else if (!ivars.empty()) {
5295 CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5297 baseOffset = CharUnits::Zero();
5300 baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5303 CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5305 baseOffset = CharUnits::Zero();
5309 return llvm::Constant::getNullValue(PtrTy);
5311 IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5313 builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5314 [&](const ObjCIvarDecl *ivar) -> CharUnits {
5315 return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5318 if (!builder.hasBitmapData())
5319 return llvm::Constant::getNullValue(PtrTy);
5321 llvm::SmallVector<unsigned char, 4> buffer;
5322 llvm::Constant *C = builder.buildBitmap(*this, buffer);
5324 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5325 printf("\n%s ivar layout for class '%s': ",
5326 ForStrongLayout ? "strong" : "weak",
5327 OMD->getClassInterface()->getName().str().c_str());
5328 builder.dump(buffer);
5333 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5334 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5335 // FIXME: Avoid std::string in "Sel.getAsString()"
5337 Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
5338 return getConstantGEP(VMContext, Entry, 0, 0);
5341 // FIXME: Merge into a single cstring creation function.
5342 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5343 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5346 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5347 std::string TypeStr;
5348 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5350 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5352 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5353 return getConstantGEP(VMContext, Entry, 0, 0);
5356 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5358 std::string TypeStr =
5359 CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);
5361 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5363 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5364 return getConstantGEP(VMContext, Entry, 0, 0);
5367 // FIXME: Merge into a single cstring creation function.
5368 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5369 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5371 Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
5372 return getConstantGEP(VMContext, Entry, 0, 0);
5375 // FIXME: Merge into a single cstring creation function.
5376 // FIXME: This Decl should be more precise.
5378 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5379 const Decl *Container) {
5380 std::string TypeStr =
5381 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
5382 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5385 void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
5386 const ObjCContainerDecl *CD,
5387 SmallVectorImpl<char> &Name) {
5388 llvm::raw_svector_ostream OS(Name);
5389 assert (CD && "Missing container decl in GetNameForMethod");
5390 OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
5391 << '[' << CD->getName();
5392 if (const ObjCCategoryImplDecl *CID =
5393 dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
5394 OS << '(' << *CID << ')';
5395 OS << ' ' << D->getSelector().getAsString() << ']';
5398 void CGObjCMac::FinishModule() {
5401 // Emit the dummy bodies for any protocols which were referenced but
5403 for (auto &entry : Protocols) {
5404 llvm::GlobalVariable *global = entry.second;
5405 if (global->hasInitializer())
5408 ConstantInitBuilder builder(CGM);
5409 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
5410 values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
5411 values.add(GetClassName(entry.first->getName()));
5412 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
5413 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5414 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5415 values.finishAndSetAsInitializer(global);
5416 CGM.addCompilerUsedGlobal(global);
5419 // Add assembler directives to add lazy undefined symbol references
5420 // for classes which are referenced but not defined. This is
5421 // important for correct linker interaction.
5423 // FIXME: It would be nice if we had an LLVM construct for this.
5424 if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
5425 CGM.getTriple().isOSBinFormatMachO()) {
5426 SmallString<256> Asm;
5427 Asm += CGM.getModule().getModuleInlineAsm();
5428 if (!Asm.empty() && Asm.back() != '\n')
5431 llvm::raw_svector_ostream OS(Asm);
5432 for (const auto *Sym : DefinedSymbols)
5433 OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
5434 << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
5435 for (const auto *Sym : LazySymbols)
5436 OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
5437 for (const auto &Category : DefinedCategoryNames)
5438 OS << "\t.objc_category_name_" << Category << "=0\n"
5439 << "\t.globl .objc_category_name_" << Category << "\n";
5441 CGM.getModule().setModuleInlineAsm(OS.str());
5445 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5446 : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
5447 ObjCEmptyVtableVar(nullptr) {
5453 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5454 : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5456 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5457 ASTContext &Ctx = CGM.getContext();
5459 ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
5461 LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
5462 Int8PtrTy = CGM.Int8PtrTy;
5463 Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5465 // arm64 targets use "int" ivar offset variables. All others,
5466 // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5467 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5468 IvarOffsetVarTy = IntTy;
5470 IvarOffsetVarTy = LongTy;
5473 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
5475 llvm::PointerType::getUnqual(ObjectPtrTy);
5477 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
5479 // I'm not sure I like this. The implicit coordination is a bit
5480 // gross. We should solve this in a reasonable fashion because this
5481 // is a pretty common task (match some runtime data structure with
5482 // an LLVM data structure).
5484 // FIXME: This is leaked.
5485 // FIXME: Merge with rewriter code?
5487 // struct _objc_super {
5491 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5492 Ctx.getTranslationUnitDecl(),
5493 SourceLocation(), SourceLocation(),
5494 &Ctx.Idents.get("_objc_super"));
5495 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5496 nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5497 false, ICIS_NoInit));
5498 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5499 nullptr, Ctx.getObjCClassType(), nullptr,
5500 nullptr, false, ICIS_NoInit));
5501 RD->completeDefinition();
5503 SuperCTy = Ctx.getTagDeclType(RD);
5504 SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5506 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5507 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5511 // char *attributes;
5513 PropertyTy = llvm::StructType::create("struct._prop_t",
5514 Int8PtrTy, Int8PtrTy, nullptr);
5516 // struct _prop_list_t {
5517 // uint32_t entsize; // sizeof(struct _prop_t)
5518 // uint32_t count_of_properties;
5519 // struct _prop_t prop_list[count_of_properties];
5522 llvm::StructType::create("struct._prop_list_t", IntTy, IntTy,
5523 llvm::ArrayType::get(PropertyTy, 0), nullptr);
5524 // struct _prop_list_t *
5525 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5527 // struct _objc_method {
5529 // char *method_type;
5532 MethodTy = llvm::StructType::create("struct._objc_method",
5533 SelectorPtrTy, Int8PtrTy, Int8PtrTy,
5536 // struct _objc_cache *
5537 CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5538 CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5541 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5542 : ObjCCommonTypesHelper(cgm) {
5543 // struct _objc_method_description {
5547 MethodDescriptionTy =
5548 llvm::StructType::create("struct._objc_method_description",
5549 SelectorPtrTy, Int8PtrTy, nullptr);
5551 // struct _objc_method_description_list {
5553 // struct _objc_method_description[1];
5555 MethodDescriptionListTy = llvm::StructType::create(
5556 "struct._objc_method_description_list", IntTy,
5557 llvm::ArrayType::get(MethodDescriptionTy, 0), nullptr);
5559 // struct _objc_method_description_list *
5560 MethodDescriptionListPtrTy =
5561 llvm::PointerType::getUnqual(MethodDescriptionListTy);
5563 // Protocol description structures
5565 // struct _objc_protocol_extension {
5566 // uint32_t size; // sizeof(struct _objc_protocol_extension)
5567 // struct _objc_method_description_list *optional_instance_methods;
5568 // struct _objc_method_description_list *optional_class_methods;
5569 // struct _objc_property_list *instance_properties;
5570 // const char ** extendedMethodTypes;
5571 // struct _objc_property_list *class_properties;
5573 ProtocolExtensionTy =
5574 llvm::StructType::create("struct._objc_protocol_extension",
5575 IntTy, MethodDescriptionListPtrTy,
5576 MethodDescriptionListPtrTy, PropertyListPtrTy,
5577 Int8PtrPtrTy, PropertyListPtrTy, nullptr);
5579 // struct _objc_protocol_extension *
5580 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5582 // Handle recursive construction of Protocol and ProtocolList types
5585 llvm::StructType::create(VMContext, "struct._objc_protocol");
5588 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5589 ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy),
5591 llvm::ArrayType::get(ProtocolTy, 0),
5594 // struct _objc_protocol {
5595 // struct _objc_protocol_extension *isa;
5596 // char *protocol_name;
5597 // struct _objc_protocol **_objc_protocol_list;
5598 // struct _objc_method_description_list *instance_methods;
5599 // struct _objc_method_description_list *class_methods;
5601 ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5602 llvm::PointerType::getUnqual(ProtocolListTy),
5603 MethodDescriptionListPtrTy,
5604 MethodDescriptionListPtrTy,
5607 // struct _objc_protocol_list *
5608 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5610 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5612 // Class description structures
5614 // struct _objc_ivar {
5619 IvarTy = llvm::StructType::create("struct._objc_ivar",
5620 Int8PtrTy, Int8PtrTy, IntTy, nullptr);
5622 // struct _objc_ivar_list *
5624 llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5625 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5627 // struct _objc_method_list *
5629 llvm::StructType::create(VMContext, "struct._objc_method_list");
5630 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5632 // struct _objc_class_extension *
5634 llvm::StructType::create("struct._objc_class_extension",
5635 IntTy, Int8PtrTy, PropertyListPtrTy, nullptr);
5636 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5638 ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5640 // struct _objc_class {
5642 // Class super_class;
5646 // long instance_size;
5647 // struct _objc_ivar_list *ivars;
5648 // struct _objc_method_list *methods;
5649 // struct _objc_cache *cache;
5650 // struct _objc_protocol_list *protocols;
5651 // char *ivar_layout;
5652 // struct _objc_class_ext *ext;
5654 ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5655 llvm::PointerType::getUnqual(ClassTy),
5665 ClassExtensionPtrTy,
5668 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5670 // struct _objc_category {
5671 // char *category_name;
5672 // char *class_name;
5673 // struct _objc_method_list *instance_method;
5674 // struct _objc_method_list *class_method;
5675 // struct _objc_protocol_list *protocols;
5676 // uint32_t size; // sizeof(struct _objc_category)
5677 // struct _objc_property_list *instance_properties;// category's @property
5678 // struct _objc_property_list *class_properties;
5681 llvm::StructType::create("struct._objc_category",
5682 Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5683 MethodListPtrTy, ProtocolListPtrTy,
5684 IntTy, PropertyListPtrTy, PropertyListPtrTy,
5687 // Global metadata structures
5689 // struct _objc_symtab {
5690 // long sel_ref_cnt;
5692 // short cls_def_cnt;
5693 // short cat_def_cnt;
5694 // char *defs[cls_def_cnt + cat_def_cnt];
5697 llvm::StructType::create("struct._objc_symtab",
5698 LongTy, SelectorPtrTy, ShortTy, ShortTy,
5699 llvm::ArrayType::get(Int8PtrTy, 0), nullptr);
5700 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
5702 // struct _objc_module {
5704 // long size; // sizeof(struct _objc_module)
5706 // struct _objc_symtab* symtab;
5709 llvm::StructType::create("struct._objc_module",
5710 LongTy, LongTy, Int8PtrTy, SymtabPtrTy, nullptr);
5713 // FIXME: This is the size of the setjmp buffer and should be target
5714 // specific. 18 is what's used on 32-bit X86.
5715 uint64_t SetJmpBufferSize = 18;
5718 llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
5721 llvm::StructType::create("struct._objc_exception_data",
5722 llvm::ArrayType::get(CGM.Int32Ty,SetJmpBufferSize),
5723 StackPtrTy, nullptr);
5726 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
5727 : ObjCCommonTypesHelper(cgm) {
5728 // struct _method_list_t {
5729 // uint32_t entsize; // sizeof(struct _objc_method)
5730 // uint32_t method_count;
5731 // struct _objc_method method_list[method_count];
5734 llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
5735 llvm::ArrayType::get(MethodTy, 0), nullptr);
5736 // struct method_list_t *
5737 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
5739 // struct _protocol_t {
5741 // const char * const protocol_name;
5742 // const struct _protocol_list_t * protocol_list; // super protocols
5743 // const struct method_list_t * const instance_methods;
5744 // const struct method_list_t * const class_methods;
5745 // const struct method_list_t *optionalInstanceMethods;
5746 // const struct method_list_t *optionalClassMethods;
5747 // const struct _prop_list_t * properties;
5748 // const uint32_t size; // sizeof(struct _protocol_t)
5749 // const uint32_t flags; // = 0
5750 // const char ** extendedMethodTypes;
5751 // const char *demangledName;
5752 // const struct _prop_list_t * class_properties;
5755 // Holder for struct _protocol_list_t *
5756 ProtocolListnfABITy =
5757 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5760 llvm::StructType::create("struct._protocol_t", ObjectPtrTy, Int8PtrTy,
5761 llvm::PointerType::getUnqual(ProtocolListnfABITy),
5762 MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5763 MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5764 PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy,
5765 Int8PtrTy, PropertyListPtrTy,
5768 // struct _protocol_t*
5769 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
5771 // struct _protocol_list_t {
5772 // long protocol_count; // Note, this is 32/64 bit
5773 // struct _protocol_t *[protocol_count];
5775 ProtocolListnfABITy->setBody(LongTy,
5776 llvm::ArrayType::get(ProtocolnfABIPtrTy, 0),
5779 // struct _objc_protocol_list*
5780 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
5783 // unsigned [long] int *offset; // pointer to ivar offset location
5786 // uint32_t alignment;
5789 IvarnfABITy = llvm::StructType::create(
5790 "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
5791 Int8PtrTy, Int8PtrTy, IntTy, IntTy, nullptr);
5793 // struct _ivar_list_t {
5794 // uint32 entsize; // sizeof(struct _ivar_t)
5796 // struct _iver_t list[count];
5799 llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
5800 llvm::ArrayType::get(IvarnfABITy, 0), nullptr);
5802 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
5804 // struct _class_ro_t {
5805 // uint32_t const flags;
5806 // uint32_t const instanceStart;
5807 // uint32_t const instanceSize;
5808 // uint32_t const reserved; // only when building for 64bit targets
5809 // const uint8_t * const ivarLayout;
5810 // const char *const name;
5811 // const struct _method_list_t * const baseMethods;
5812 // const struct _objc_protocol_list *const baseProtocols;
5813 // const struct _ivar_list_t *const ivars;
5814 // const uint8_t * const weakIvarLayout;
5815 // const struct _prop_list_t * const properties;
5818 // FIXME. Add 'reserved' field in 64bit abi mode!
5819 ClassRonfABITy = llvm::StructType::create("struct._class_ro_t",
5820 IntTy, IntTy, IntTy, Int8PtrTy,
5821 Int8PtrTy, MethodListnfABIPtrTy,
5822 ProtocolListnfABIPtrTy,
5824 Int8PtrTy, PropertyListPtrTy,
5827 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
5828 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
5829 ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
5832 // struct _class_t {
5833 // struct _class_t *isa;
5834 // struct _class_t * const superclass;
5837 // struct class_ro_t *ro;
5840 ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
5841 ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
5842 llvm::PointerType::getUnqual(ClassnfABITy),
5844 llvm::PointerType::getUnqual(ImpnfABITy),
5845 llvm::PointerType::getUnqual(ClassRonfABITy),
5848 // LLVM for struct _class_t *
5849 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
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;
5861 CategorynfABITy = llvm::StructType::create("struct._category_t",
5862 Int8PtrTy, ClassnfABIPtrTy,
5863 MethodListnfABIPtrTy,
5864 MethodListnfABIPtrTy,
5865 ProtocolListnfABIPtrTy,
5871 // New types for nonfragile abi messaging.
5872 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5873 ASTContext &Ctx = CGM.getContext();
5875 // MessageRefTy - LLVM for:
5876 // struct _message_ref_t {
5881 // First the clang type for struct _message_ref_t
5882 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5883 Ctx.getTranslationUnitDecl(),
5884 SourceLocation(), SourceLocation(),
5885 &Ctx.Idents.get("_message_ref_t"));
5886 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5887 nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
5889 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5890 nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
5891 false, ICIS_NoInit));
5892 RD->completeDefinition();
5894 MessageRefCTy = Ctx.getTagDeclType(RD);
5895 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
5896 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
5898 // MessageRefPtrTy - LLVM for struct _message_ref_t*
5899 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
5901 // SuperMessageRefTy - LLVM for:
5902 // struct _super_message_ref_t {
5903 // SUPER_IMP messenger;
5907 llvm::StructType::create("struct._super_message_ref_t",
5908 ImpnfABITy, SelectorPtrTy, nullptr);
5910 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
5911 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
5914 // struct objc_typeinfo {
5915 // const void** vtable; // objc_ehtype_vtable + 2
5916 // const char* name; // c++ typeinfo string
5920 llvm::StructType::create("struct._objc_typeinfo",
5921 llvm::PointerType::getUnqual(Int8PtrTy),
5922 Int8PtrTy, ClassnfABIPtrTy, nullptr);
5923 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
5926 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
5927 FinishNonFragileABIModule();
5932 void CGObjCNonFragileABIMac::AddModuleClassList(
5933 ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName,
5934 StringRef SectionName) {
5935 unsigned NumClasses = Container.size();
5940 SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
5941 for (unsigned i=0; i<NumClasses; i++)
5942 Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
5943 ObjCTypes.Int8PtrTy);
5944 llvm::Constant *Init =
5945 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
5949 llvm::GlobalVariable *GV =
5950 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
5951 llvm::GlobalValue::PrivateLinkage,
5954 GV->setAlignment(CGM.getDataLayout().getABITypeAlignment(Init->getType()));
5955 GV->setSection(SectionName);
5956 CGM.addCompilerUsedGlobal(GV);
5959 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
5960 // nonfragile abi has no module definition.
5962 // Build list of all implemented class addresses in array
5963 // L_OBJC_LABEL_CLASS_$.
5965 for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
5966 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
5968 if (ObjCImplementationDecl *IMP = ID->getImplementation())
5969 // We are implementing a weak imported interface. Give it external linkage
5970 if (ID->isWeakImported() && !IMP->isWeakImported()) {
5971 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5972 DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5976 AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
5977 "__DATA, __objc_classlist, regular, no_dead_strip");
5979 AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$",
5980 "__DATA, __objc_nlclslist, regular, no_dead_strip");
5982 // Build list of all implemented category addresses in array
5983 // L_OBJC_LABEL_CATEGORY_$.
5984 AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$",
5985 "__DATA, __objc_catlist, regular, no_dead_strip");
5986 AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$",
5987 "__DATA, __objc_nlcatlist, regular, no_dead_strip");
5992 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of
5993 /// VTableDispatchMethods; false otherwise. What this means is that
5994 /// except for the 19 selectors in the list, we generate 32bit-style
5995 /// message dispatch call for all the rest.
5996 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
5997 // At various points we've experimented with using vtable-based
5998 // dispatch for all methods.
5999 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
6000 case CodeGenOptions::Legacy:
6002 case CodeGenOptions::NonLegacy:
6004 case CodeGenOptions::Mixed:
6008 // If so, see whether this selector is in the white-list of things which must
6009 // use the new dispatch convention. We lazily build a dense set for this.
6010 if (VTableDispatchMethods.empty()) {
6011 VTableDispatchMethods.insert(GetNullarySelector("alloc"));
6012 VTableDispatchMethods.insert(GetNullarySelector("class"));
6013 VTableDispatchMethods.insert(GetNullarySelector("self"));
6014 VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
6015 VTableDispatchMethods.insert(GetNullarySelector("length"));
6016 VTableDispatchMethods.insert(GetNullarySelector("count"));
6018 // These are vtable-based if GC is disabled.
6019 // Optimistically use vtable dispatch for hybrid compiles.
6020 if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
6021 VTableDispatchMethods.insert(GetNullarySelector("retain"));
6022 VTableDispatchMethods.insert(GetNullarySelector("release"));
6023 VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
6026 VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
6027 VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
6028 VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
6029 VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
6030 VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
6031 VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
6032 VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
6034 // These are vtable-based if GC is enabled.
6035 // Optimistically use vtable dispatch for hybrid compiles.
6036 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
6037 VTableDispatchMethods.insert(GetNullarySelector("hash"));
6038 VTableDispatchMethods.insert(GetUnarySelector("addObject"));
6040 // "countByEnumeratingWithState:objects:count"
6041 IdentifierInfo *KeyIdents[] = {
6042 &CGM.getContext().Idents.get("countByEnumeratingWithState"),
6043 &CGM.getContext().Idents.get("objects"),
6044 &CGM.getContext().Idents.get("count")
6046 VTableDispatchMethods.insert(
6047 CGM.getContext().Selectors.getSelector(3, KeyIdents));
6051 return VTableDispatchMethods.count(Sel);
6054 /// BuildClassRoTInitializer - generate meta-data for:
6055 /// struct _class_ro_t {
6056 /// uint32_t const flags;
6057 /// uint32_t const instanceStart;
6058 /// uint32_t const instanceSize;
6059 /// uint32_t const reserved; // only when building for 64bit targets
6060 /// const uint8_t * const ivarLayout;
6061 /// const char *const name;
6062 /// const struct _method_list_t * const baseMethods;
6063 /// const struct _protocol_list_t *const baseProtocols;
6064 /// const struct _ivar_list_t *const ivars;
6065 /// const uint8_t * const weakIvarLayout;
6066 /// const struct _prop_list_t * const properties;
6069 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
6071 unsigned InstanceStart,
6072 unsigned InstanceSize,
6073 const ObjCImplementationDecl *ID) {
6074 std::string ClassName = ID->getObjCRuntimeNameAsString();
6076 CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
6077 CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
6079 bool hasMRCWeak = false;
6080 if (CGM.getLangOpts().ObjCAutoRefCount)
6081 flags |= NonFragileABI_Class_CompiledByARC;
6082 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
6083 flags |= NonFragileABI_Class_HasMRCWeakIvars;
6085 ConstantInitBuilder builder(CGM);
6086 auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy);
6088 values.addInt(ObjCTypes.IntTy, flags);
6089 values.addInt(ObjCTypes.IntTy, InstanceStart);
6090 values.addInt(ObjCTypes.IntTy, InstanceSize);
6091 values.add((flags & NonFragileABI_Class_Meta)
6092 ? GetIvarLayoutName(nullptr, ObjCTypes)
6093 : BuildStrongIvarLayout(ID, beginInstance, endInstance));
6094 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
6096 // const struct _method_list_t * const baseMethods;
6097 SmallVector<const ObjCMethodDecl*, 16> methods;
6098 if (flags & NonFragileABI_Class_Meta) {
6099 for (const auto *MD : ID->class_methods())
6100 methods.push_back(MD);
6102 for (const auto *MD : ID->instance_methods())
6103 methods.push_back(MD);
6105 for (const auto *PID : ID->property_impls()) {
6106 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
6107 ObjCPropertyDecl *PD = PID->getPropertyDecl();
6109 if (auto MD = PD->getGetterMethodDecl())
6110 if (GetMethodDefinition(MD))
6111 methods.push_back(MD);
6112 if (auto MD = PD->getSetterMethodDecl())
6113 if (GetMethodDefinition(MD))
6114 methods.push_back(MD);
6119 values.add(emitMethodList(ID->getObjCRuntimeNameAsString(),
6120 (flags & NonFragileABI_Class_Meta)
6121 ? MethodListType::ClassMethods
6122 : MethodListType::InstanceMethods,
6125 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6126 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
6127 values.add(EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_"
6128 + OID->getObjCRuntimeNameAsString(),
6129 OID->all_referenced_protocol_begin(),
6130 OID->all_referenced_protocol_end()));
6132 if (flags & NonFragileABI_Class_Meta) {
6133 values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy);
6134 values.add(GetIvarLayoutName(nullptr, ObjCTypes));
6135 values.add(EmitPropertyList(
6136 "\01l_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6137 ID, ID->getClassInterface(), ObjCTypes, true));
6139 values.add(EmitIvarList(ID));
6140 values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak));
6141 values.add(EmitPropertyList(
6142 "\01l_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6143 ID, ID->getClassInterface(), ObjCTypes, false));
6146 llvm::SmallString<64> roLabel;
6147 llvm::raw_svector_ostream(roLabel)
6148 << ((flags & NonFragileABI_Class_Meta) ? "\01l_OBJC_METACLASS_RO_$_"
6149 : "\01l_OBJC_CLASS_RO_$_")
6152 llvm::GlobalVariable *CLASS_RO_GV =
6153 values.finishAndCreateGlobal(roLabel, CGM.getPointerAlign(),
6155 llvm::GlobalValue::PrivateLinkage);
6156 if (CGM.getTriple().isOSBinFormatMachO())
6157 CLASS_RO_GV->setSection("__DATA, __objc_const");
6161 /// Build the metaclass object for a class.
6163 /// struct _class_t {
6164 /// struct _class_t *isa;
6165 /// struct _class_t * const superclass;
6168 /// struct class_ro_t *ro;
6171 llvm::GlobalVariable *
6172 CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI,
6174 llvm::Constant *IsAGV,
6175 llvm::Constant *SuperClassGV,
6176 llvm::Constant *ClassRoGV,
6177 bool HiddenVisibility) {
6178 ConstantInitBuilder builder(CGM);
6179 auto values = builder.beginStruct(ObjCTypes.ClassnfABITy);
6182 values.add(SuperClassGV);
6184 values.addNullPointer(ObjCTypes.ClassnfABIPtrTy);
6186 values.add(ObjCEmptyCacheVar);
6187 values.add(ObjCEmptyVtableVar);
6188 values.add(ClassRoGV);
6190 llvm::GlobalVariable *GV =
6191 cast<llvm::GlobalVariable>(GetClassGlobal(CI, isMetaclass, ForDefinition));
6192 values.finishAndSetAsInitializer(GV);
6194 if (CGM.getTriple().isOSBinFormatMachO())
6195 GV->setSection("__DATA, __objc_data");
6197 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy));
6198 if (!CGM.getTriple().isOSBinFormatCOFF())
6199 if (HiddenVisibility)
6200 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6205 CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
6206 return OD->getClassMethod(GetNullarySelector("load")) != nullptr;
6209 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
6210 uint32_t &InstanceStart,
6211 uint32_t &InstanceSize) {
6212 const ASTRecordLayout &RL =
6213 CGM.getContext().getASTObjCImplementationLayout(OID);
6215 // InstanceSize is really instance end.
6216 InstanceSize = RL.getDataSize().getQuantity();
6218 // If there are no fields, the start is the same as the end.
6219 if (!RL.getFieldCount())
6220 InstanceStart = InstanceSize;
6222 InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
6225 static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM,
6227 IdentifierInfo &II = CGM.getContext().Idents.get(Name);
6228 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
6229 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
6231 const VarDecl *VD = nullptr;
6232 for (const auto &Result : DC->lookup(&II))
6233 if ((VD = dyn_cast<VarDecl>(Result)))
6237 return llvm::GlobalValue::DLLImportStorageClass;
6238 if (VD->hasAttr<DLLExportAttr>())
6239 return llvm::GlobalValue::DLLExportStorageClass;
6240 if (VD->hasAttr<DLLImportAttr>())
6241 return llvm::GlobalValue::DLLImportStorageClass;
6242 return llvm::GlobalValue::DefaultStorageClass;
6245 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
6246 if (!ObjCEmptyCacheVar) {
6248 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false,
6249 llvm::GlobalValue::ExternalLinkage, nullptr,
6250 "_objc_empty_cache");
6251 if (CGM.getTriple().isOSBinFormatCOFF())
6252 ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache"));
6254 // Only OS X with deployment version <10.9 use the empty vtable symbol
6255 const llvm::Triple &Triple = CGM.getTarget().getTriple();
6256 if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9))
6257 ObjCEmptyVtableVar =
6258 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false,
6259 llvm::GlobalValue::ExternalLinkage, nullptr,
6260 "_objc_empty_vtable");
6262 ObjCEmptyVtableVar =
6263 llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo());
6266 // FIXME: Is this correct (that meta class size is never computed)?
6267 uint32_t InstanceStart =
6268 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
6269 uint32_t InstanceSize = InstanceStart;
6270 uint32_t flags = NonFragileABI_Class_Meta;
6272 llvm::Constant *SuperClassGV, *IsAGV;
6274 const auto *CI = ID->getClassInterface();
6275 assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0");
6277 // Build the flags for the metaclass.
6278 bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF())
6279 ? !CI->hasAttr<DLLExportAttr>()
6280 : CI->getVisibility() == HiddenVisibility;
6282 flags |= NonFragileABI_Class_Hidden;
6284 // FIXME: why is this flag set on the metaclass?
6285 // ObjC metaclasses have no fields and don't really get constructed.
6286 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6287 flags |= NonFragileABI_Class_HasCXXStructors;
6288 if (!ID->hasNonZeroConstructors())
6289 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6292 if (!CI->getSuperClass()) {
6294 flags |= NonFragileABI_Class_Root;
6296 SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition);
6297 IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition);
6299 // Has a root. Current class is not a root.
6300 const ObjCInterfaceDecl *Root = ID->getClassInterface();
6301 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
6304 const auto *Super = CI->getSuperClass();
6305 IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition);
6306 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition);
6309 llvm::GlobalVariable *CLASS_RO_GV =
6310 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6312 llvm::GlobalVariable *MetaTClass =
6313 BuildClassObject(CI, /*metaclass*/ true,
6314 IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden);
6315 if (CGM.getTriple().isOSBinFormatCOFF())
6316 if (CI->hasAttr<DLLExportAttr>())
6317 MetaTClass->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6318 DefinedMetaClasses.push_back(MetaTClass);
6320 // Metadata for the class
6323 flags |= NonFragileABI_Class_Hidden;
6325 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6326 flags |= NonFragileABI_Class_HasCXXStructors;
6328 // Set a flag to enable a runtime optimization when a class has
6329 // fields that require destruction but which don't require
6330 // anything except zero-initialization during construction. This
6331 // is most notably true of __strong and __weak types, but you can
6332 // also imagine there being C++ types with non-trivial default
6333 // constructors that merely set all fields to null.
6334 if (!ID->hasNonZeroConstructors())
6335 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6338 if (hasObjCExceptionAttribute(CGM.getContext(), CI))
6339 flags |= NonFragileABI_Class_Exception;
6341 if (!CI->getSuperClass()) {
6342 flags |= NonFragileABI_Class_Root;
6343 SuperClassGV = nullptr;
6345 // Has a root. Current class is not a root.
6346 const auto *Super = CI->getSuperClass();
6347 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition);
6350 GetClassSizeInfo(ID, InstanceStart, InstanceSize);
6352 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6354 llvm::GlobalVariable *ClassMD =
6355 BuildClassObject(CI, /*metaclass*/ false,
6356 MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden);
6357 if (CGM.getTriple().isOSBinFormatCOFF())
6358 if (CI->hasAttr<DLLExportAttr>())
6359 ClassMD->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6360 DefinedClasses.push_back(ClassMD);
6361 ImplementedClasses.push_back(CI);
6363 // Determine if this class is also "non-lazy".
6364 if (ImplementationIsNonLazy(ID))
6365 DefinedNonLazyClasses.push_back(ClassMD);
6367 // Force the definition of the EHType if necessary.
6368 if (flags & NonFragileABI_Class_Exception)
6369 (void) GetInterfaceEHType(CI, ForDefinition);
6370 // Make sure method definition entries are all clear for next implementation.
6371 MethodDefinitions.clear();
6374 /// GenerateProtocolRef - This routine is called to generate code for
6375 /// a protocol reference expression; as in:
6377 /// @protocol(Proto1);
6379 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
6380 /// which will hold address of the protocol meta-data.
6382 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
6383 const ObjCProtocolDecl *PD) {
6385 // This routine is called for @protocol only. So, we must build definition
6386 // of protocol's meta-data (not a reference to it!)
6388 llvm::Constant *Init =
6389 llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
6390 ObjCTypes.getExternalProtocolPtrTy());
6392 std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_");
6393 ProtocolName += PD->getObjCRuntimeNameAsString();
6395 CharUnits Align = CGF.getPointerAlign();
6397 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
6399 return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6400 PTGV = new llvm::GlobalVariable(
6402 Init->getType(), false,
6403 llvm::GlobalValue::WeakAnyLinkage,
6406 PTGV->setSection("__DATA, __objc_protorefs, coalesced, no_dead_strip");
6407 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6408 PTGV->setAlignment(Align.getQuantity());
6409 CGM.addCompilerUsedGlobal(PTGV);
6410 return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6413 /// GenerateCategory - Build metadata for a category implementation.
6414 /// struct _category_t {
6415 /// const char * const name;
6416 /// struct _class_t *const cls;
6417 /// const struct _method_list_t * const instance_methods;
6418 /// const struct _method_list_t * const class_methods;
6419 /// const struct _protocol_list_t * const protocols;
6420 /// const struct _prop_list_t * const properties;
6421 /// const struct _prop_list_t * const class_properties;
6422 /// const uint32_t size;
6425 void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
6426 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
6427 const char *Prefix = "\01l_OBJC_$_CATEGORY_";
6429 llvm::SmallString<64> ExtCatName(Prefix);
6430 ExtCatName += Interface->getObjCRuntimeNameAsString();
6431 ExtCatName += "_$_";
6432 ExtCatName += OCD->getNameAsString();
6434 ConstantInitBuilder builder(CGM);
6435 auto values = builder.beginStruct(ObjCTypes.CategorynfABITy);
6436 values.add(GetClassName(OCD->getIdentifier()->getName()));
6437 // meta-class entry symbol
6438 values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition));
6439 std::string listName =
6440 (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str();
6442 SmallVector<const ObjCMethodDecl *, 16> instanceMethods;
6443 SmallVector<const ObjCMethodDecl *, 8> classMethods;
6444 for (const auto *MD : OCD->methods()) {
6445 if (MD->isInstanceMethod()) {
6446 instanceMethods.push_back(MD);
6448 classMethods.push_back(MD);
6452 values.add(emitMethodList(listName, MethodListType::CategoryInstanceMethods,
6454 values.add(emitMethodList(listName, MethodListType::CategoryClassMethods,
6457 const ObjCCategoryDecl *Category =
6458 Interface->FindCategoryDeclaration(OCD->getIdentifier());
6460 SmallString<256> ExtName;
6461 llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
6463 values.add(EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_"
6464 + Interface->getObjCRuntimeNameAsString() + "_$_"
6465 + Category->getName(),
6466 Category->protocol_begin(),
6467 Category->protocol_end()));
6468 values.add(EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
6469 OCD, Category, ObjCTypes, false));
6470 values.add(EmitPropertyList("\01l_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
6471 OCD, Category, ObjCTypes, true));
6473 values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy);
6474 values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6475 values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6478 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy);
6479 values.addInt(ObjCTypes.IntTy, Size);
6481 llvm::GlobalVariable *GCATV =
6482 values.finishAndCreateGlobal(ExtCatName.str(), CGM.getPointerAlign(),
6484 llvm::GlobalValue::PrivateLinkage);
6485 if (CGM.getTriple().isOSBinFormatMachO())
6486 GCATV->setSection("__DATA, __objc_const");
6487 CGM.addCompilerUsedGlobal(GCATV);
6488 DefinedCategories.push_back(GCATV);
6490 // Determine if this category is also "non-lazy".
6491 if (ImplementationIsNonLazy(OCD))
6492 DefinedNonLazyCategories.push_back(GCATV);
6493 // method definition entries must be clear for next implementation.
6494 MethodDefinitions.clear();
6497 /// emitMethodConstant - Return a struct objc_method constant. If
6498 /// forProtocol is true, the implementation will be null; otherwise,
6499 /// the method must have a definition registered with the runtime.
6501 /// struct _objc_method {
6503 /// char *method_type;
6506 void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
6507 const ObjCMethodDecl *MD,
6509 auto method = builder.beginStruct(ObjCTypes.MethodTy);
6510 method.addBitCast(GetMethodVarName(MD->getSelector()),
6511 ObjCTypes.SelectorPtrTy);
6512 method.add(GetMethodVarType(MD));
6515 // Protocol methods have no implementation. So, this entry is always NULL.
6516 method.addNullPointer(ObjCTypes.Int8PtrTy);
6518 llvm::Function *fn = GetMethodDefinition(MD);
6519 assert(fn && "no definition for method?");
6520 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
6523 method.finishAndAddTo(builder);
6526 /// Build meta-data for method declarations.
6528 /// struct _method_list_t {
6529 /// uint32_t entsize; // sizeof(struct _objc_method)
6530 /// uint32_t method_count;
6531 /// struct _objc_method method_list[method_count];
6535 CGObjCNonFragileABIMac::emitMethodList(Twine name, MethodListType kind,
6536 ArrayRef<const ObjCMethodDecl *> methods) {
6537 // Return null for empty list.
6538 if (methods.empty())
6539 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
6544 case MethodListType::CategoryInstanceMethods:
6545 prefix = "\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_";
6546 forProtocol = false;
6548 case MethodListType::CategoryClassMethods:
6549 prefix = "\01l_OBJC_$_CATEGORY_CLASS_METHODS_";
6550 forProtocol = false;
6552 case MethodListType::InstanceMethods:
6553 prefix = "\01l_OBJC_$_INSTANCE_METHODS_";
6554 forProtocol = false;
6556 case MethodListType::ClassMethods:
6557 prefix = "\01l_OBJC_$_CLASS_METHODS_";
6558 forProtocol = false;
6561 case MethodListType::ProtocolInstanceMethods:
6562 prefix = "\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_";
6565 case MethodListType::ProtocolClassMethods:
6566 prefix = "\01l_OBJC_$_PROTOCOL_CLASS_METHODS_";
6569 case MethodListType::OptionalProtocolInstanceMethods:
6570 prefix = "\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_";
6573 case MethodListType::OptionalProtocolClassMethods:
6574 prefix = "\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_";
6579 ConstantInitBuilder builder(CGM);
6580 auto values = builder.beginStruct();
6582 // sizeof(struct _objc_method)
6583 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
6584 values.addInt(ObjCTypes.IntTy, Size);
6586 values.addInt(ObjCTypes.IntTy, methods.size());
6587 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
6588 for (auto MD : methods) {
6589 emitMethodConstant(methodArray, MD, forProtocol);
6591 methodArray.finishAndAddTo(values);
6593 auto *GV = values.finishAndCreateGlobal(prefix + name, CGM.getPointerAlign(),
6595 llvm::GlobalValue::PrivateLinkage);
6596 if (CGM.getTriple().isOSBinFormatMachO())
6597 GV->setSection("__DATA, __objc_const");
6598 CGM.addCompilerUsedGlobal(GV);
6599 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6602 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6604 llvm::GlobalVariable *
6605 CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
6606 const ObjCIvarDecl *Ivar) {
6607 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
6608 llvm::SmallString<64> Name("OBJC_IVAR_$_");
6609 Name += Container->getObjCRuntimeNameAsString();
6611 Name += Ivar->getName();
6612 llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name);
6613 if (!IvarOffsetGV) {
6615 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.IvarOffsetVarTy,
6616 false, llvm::GlobalValue::ExternalLinkage,
6617 nullptr, Name.str());
6618 if (CGM.getTriple().isOSBinFormatCOFF()) {
6619 bool IsPrivateOrPackage =
6620 Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6621 Ivar->getAccessControl() == ObjCIvarDecl::Package;
6623 if (ID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage)
6624 IvarOffsetGV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6625 else if (ID->hasAttr<DLLImportAttr>())
6626 IvarOffsetGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6629 return IvarOffsetGV;
6633 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
6634 const ObjCIvarDecl *Ivar,
6635 unsigned long int Offset) {
6636 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
6637 IvarOffsetGV->setInitializer(
6638 llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
6639 IvarOffsetGV->setAlignment(
6640 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy));
6642 if (!CGM.getTriple().isOSBinFormatCOFF()) {
6643 // FIXME: This matches gcc, but shouldn't the visibility be set on the use
6644 // as well (i.e., in ObjCIvarOffsetVariable).
6645 if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6646 Ivar->getAccessControl() == ObjCIvarDecl::Package ||
6647 ID->getVisibility() == HiddenVisibility)
6648 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6650 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
6653 if (CGM.getTriple().isOSBinFormatMachO())
6654 IvarOffsetGV->setSection("__DATA, __objc_ivar");
6655 return IvarOffsetGV;
6658 /// EmitIvarList - Emit the ivar list for the given
6659 /// implementation. The return value has type
6660 /// IvarListnfABIPtrTy.
6661 /// struct _ivar_t {
6662 /// unsigned [long] int *offset; // pointer to ivar offset location
6665 /// uint32_t alignment;
6668 /// struct _ivar_list_t {
6669 /// uint32 entsize; // sizeof(struct _ivar_t)
6671 /// struct _iver_t list[count];
6675 llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
6676 const ObjCImplementationDecl *ID) {
6678 ConstantInitBuilder builder(CGM);
6679 auto ivarList = builder.beginStruct();
6680 ivarList.addInt(ObjCTypes.IntTy,
6681 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy));
6682 auto ivarCountSlot = ivarList.addPlaceholder();
6683 auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy);
6685 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6686 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
6688 // FIXME. Consolidate this with similar code in GenerateClass.
6690 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
6691 IVD; IVD = IVD->getNextIvar()) {
6692 // Ignore unnamed bit-fields.
6693 if (!IVD->getDeclName())
6696 auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy);
6697 ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD,
6698 ComputeIvarBaseOffset(CGM, ID, IVD)));
6699 ivar.add(GetMethodVarName(IVD->getIdentifier()));
6700 ivar.add(GetMethodVarType(IVD));
6701 llvm::Type *FieldTy =
6702 CGM.getTypes().ConvertTypeForMem(IVD->getType());
6703 unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
6704 unsigned Align = CGM.getContext().getPreferredTypeAlign(
6705 IVD->getType().getTypePtr()) >> 3;
6706 Align = llvm::Log2_32(Align);
6707 ivar.addInt(ObjCTypes.IntTy, Align);
6708 // NOTE. Size of a bitfield does not match gcc's, because of the
6709 // way bitfields are treated special in each. But I am told that
6710 // 'size' for bitfield ivars is ignored by the runtime so it does
6711 // not matter. If it matters, there is enough info to get the
6713 ivar.addInt(ObjCTypes.IntTy, Size);
6714 ivar.finishAndAddTo(ivars);
6716 // Return null for empty list.
6717 if (ivars.empty()) {
6720 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
6723 auto ivarCount = ivars.size();
6724 ivars.finishAndAddTo(ivarList);
6725 ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount);
6727 const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_";
6728 llvm::GlobalVariable *GV =
6729 ivarList.finishAndCreateGlobal(Prefix + OID->getObjCRuntimeNameAsString(),
6730 CGM.getPointerAlign(), /*constant*/ false,
6731 llvm::GlobalValue::PrivateLinkage);
6732 if (CGM.getTriple().isOSBinFormatMachO())
6733 GV->setSection("__DATA, __objc_const");
6734 CGM.addCompilerUsedGlobal(GV);
6735 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
6738 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
6739 const ObjCProtocolDecl *PD) {
6740 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
6743 // We use the initializer as a marker of whether this is a forward
6744 // reference or not. At module finalization we add the empty
6745 // contents for protocols which were referenced but never defined.
6746 llvm::SmallString<64> Protocol;
6747 llvm::raw_svector_ostream(Protocol) << "\01l_OBJC_PROTOCOL_$_"
6748 << PD->getObjCRuntimeNameAsString();
6750 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
6751 false, llvm::GlobalValue::ExternalLinkage,
6753 if (!CGM.getTriple().isOSBinFormatMachO())
6754 Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol));
6760 /// GetOrEmitProtocol - Generate the protocol meta-data:
6762 /// struct _protocol_t {
6764 /// const char * const protocol_name;
6765 /// const struct _protocol_list_t * protocol_list; // super protocols
6766 /// const struct method_list_t * const instance_methods;
6767 /// const struct method_list_t * const class_methods;
6768 /// const struct method_list_t *optionalInstanceMethods;
6769 /// const struct method_list_t *optionalClassMethods;
6770 /// const struct _prop_list_t * properties;
6771 /// const uint32_t size; // sizeof(struct _protocol_t)
6772 /// const uint32_t flags; // = 0
6773 /// const char ** extendedMethodTypes;
6774 /// const char *demangledName;
6775 /// const struct _prop_list_t * class_properties;
6780 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
6781 const ObjCProtocolDecl *PD) {
6782 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
6784 // Early exit if a defining object has already been generated.
6785 if (Entry && Entry->hasInitializer())
6788 // Use the protocol definition, if there is one.
6789 if (const ObjCProtocolDecl *Def = PD->getDefinition())
6792 auto methodLists = ProtocolMethodLists::get(PD);
6794 ConstantInitBuilder builder(CGM);
6795 auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy);
6798 values.addNullPointer(ObjCTypes.ObjectPtrTy);
6799 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
6800 values.add(EmitProtocolList("\01l_OBJC_$_PROTOCOL_REFS_"
6801 + PD->getObjCRuntimeNameAsString(),
6802 PD->protocol_begin(),
6803 PD->protocol_end()));
6804 values.add(methodLists.emitMethodList(this, PD,
6805 ProtocolMethodLists::RequiredInstanceMethods));
6806 values.add(methodLists.emitMethodList(this, PD,
6807 ProtocolMethodLists::RequiredClassMethods));
6808 values.add(methodLists.emitMethodList(this, PD,
6809 ProtocolMethodLists::OptionalInstanceMethods));
6810 values.add(methodLists.emitMethodList(this, PD,
6811 ProtocolMethodLists::OptionalClassMethods));
6812 values.add(EmitPropertyList(
6813 "\01l_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6814 nullptr, PD, ObjCTypes, false));
6816 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
6817 values.addInt(ObjCTypes.IntTy, Size);
6818 values.addInt(ObjCTypes.IntTy, 0);
6819 values.add(EmitProtocolMethodTypes("\01l_OBJC_$_PROTOCOL_METHOD_TYPES_"
6820 + PD->getObjCRuntimeNameAsString(),
6821 methodLists.emitExtendedTypesArray(this),
6824 // const char *demangledName;
6825 values.addNullPointer(ObjCTypes.Int8PtrTy);
6827 values.add(EmitPropertyList(
6828 "\01l_OBJC_$_CLASS_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6829 nullptr, PD, ObjCTypes, true));
6832 // Already created, fix the linkage and update the initializer.
6833 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
6834 values.finishAndSetAsInitializer(Entry);
6836 llvm::SmallString<64> symbolName;
6837 llvm::raw_svector_ostream(symbolName)
6838 << "\01l_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString();
6840 Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(),
6842 llvm::GlobalValue::WeakAnyLinkage);
6843 if (!CGM.getTriple().isOSBinFormatMachO())
6844 Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName));
6846 Protocols[PD->getIdentifier()] = Entry;
6848 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
6849 CGM.addCompilerUsedGlobal(Entry);
6851 // Use this protocol meta-data to build protocol list table in section
6852 // __DATA, __objc_protolist
6853 llvm::SmallString<64> ProtocolRef;
6854 llvm::raw_svector_ostream(ProtocolRef) << "\01l_OBJC_LABEL_PROTOCOL_$_"
6855 << PD->getObjCRuntimeNameAsString();
6857 llvm::GlobalVariable *PTGV =
6858 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
6859 false, llvm::GlobalValue::WeakAnyLinkage, Entry,
6861 if (!CGM.getTriple().isOSBinFormatMachO())
6862 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef));
6864 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy));
6865 if (CGM.getTriple().isOSBinFormatMachO())
6866 PTGV->setSection("__DATA, __objc_protolist, coalesced, no_dead_strip");
6867 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6868 CGM.addCompilerUsedGlobal(PTGV);
6872 /// EmitProtocolList - Generate protocol list meta-data:
6874 /// struct _protocol_list_t {
6875 /// long protocol_count; // Note, this is 32/64 bit
6876 /// struct _protocol_t[protocol_count];
6881 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
6882 ObjCProtocolDecl::protocol_iterator begin,
6883 ObjCProtocolDecl::protocol_iterator end) {
6884 SmallVector<llvm::Constant *, 16> ProtocolRefs;
6886 // Just return null for empty protocol lists
6888 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
6890 // FIXME: We shouldn't need to do this lookup here, should we?
6891 SmallString<256> TmpName;
6892 Name.toVector(TmpName);
6893 llvm::GlobalVariable *GV =
6894 CGM.getModule().getGlobalVariable(TmpName.str(), true);
6896 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
6898 ConstantInitBuilder builder(CGM);
6899 auto values = builder.beginStruct();
6900 auto countSlot = values.addPlaceholder();
6902 // A null-terminated array of protocols.
6903 auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy);
6904 for (; begin != end; ++begin)
6905 array.add(GetProtocolRef(*begin)); // Implemented???
6906 auto count = array.size();
6907 array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy);
6909 array.finishAndAddTo(values);
6910 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
6912 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
6914 llvm::GlobalValue::PrivateLinkage);
6915 if (CGM.getTriple().isOSBinFormatMachO())
6916 GV->setSection("__DATA, __objc_const");
6917 CGM.addCompilerUsedGlobal(GV);
6918 return llvm::ConstantExpr::getBitCast(GV,
6919 ObjCTypes.ProtocolListnfABIPtrTy);
6922 /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
6923 /// This code gen. amounts to generating code for:
6925 /// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
6928 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
6929 CodeGen::CodeGenFunction &CGF,
6931 llvm::Value *BaseValue,
6932 const ObjCIvarDecl *Ivar,
6933 unsigned CVRQualifiers) {
6934 ObjCInterfaceDecl *ID = ObjectTy->getAs<ObjCObjectType>()->getInterface();
6935 llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
6936 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
6940 llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset(
6941 CodeGen::CodeGenFunction &CGF,
6942 const ObjCInterfaceDecl *Interface,
6943 const ObjCIvarDecl *Ivar) {
6944 llvm::Value *IvarOffsetValue = ObjCIvarOffsetVariable(Interface, Ivar);
6945 IvarOffsetValue = CGF.Builder.CreateAlignedLoad(IvarOffsetValue,
6946 CGF.getSizeAlign(), "ivar");
6947 if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
6948 cast<llvm::LoadInst>(IvarOffsetValue)
6949 ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
6950 llvm::MDNode::get(VMContext, None));
6952 // This could be 32bit int or 64bit integer depending on the architecture.
6953 // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
6954 // as this is what caller always expectes.
6955 if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
6956 IvarOffsetValue = CGF.Builder.CreateIntCast(
6957 IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
6958 return IvarOffsetValue;
6961 static void appendSelectorForMessageRefTable(std::string &buffer,
6962 Selector selector) {
6963 if (selector.isUnarySelector()) {
6964 buffer += selector.getNameForSlot(0);
6968 for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
6969 buffer += selector.getNameForSlot(i);
6974 /// Emit a "vtable" message send. We emit a weak hidden-visibility
6975 /// struct, initially containing the selector pointer and a pointer to
6976 /// a "fixup" variant of the appropriate objc_msgSend. To call, we
6977 /// load and call the function pointer, passing the address of the
6978 /// struct as the second parameter. The runtime determines whether
6979 /// the selector is currently emitted using vtable dispatch; if so, it
6980 /// substitutes a stub function which simply tail-calls through the
6981 /// appropriate vtable slot, and if not, it substitues a stub function
6982 /// which tail-calls objc_msgSend. Both stubs adjust the selector
6983 /// argument to correctly point to the selector.
6985 CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
6986 ReturnValueSlot returnSlot,
6987 QualType resultType,
6992 const CallArgList &formalArgs,
6993 const ObjCMethodDecl *method) {
6994 // Compute the actual arguments.
6997 // First argument: the receiver / super-call structure.
6999 arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
7000 args.add(RValue::get(arg0), arg0Type);
7002 // Second argument: a pointer to the message ref structure. Leave
7003 // the actual argument value blank for now.
7004 args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);
7006 args.insert(args.end(), formalArgs.begin(), formalArgs.end());
7008 MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);
7010 NullReturnState nullReturn;
7012 // Find the function to call and the mangled name for the message
7013 // ref structure. Using a different mangled name wouldn't actually
7014 // be a problem; it would just be a waste.
7016 // The runtime currently never uses vtable dispatch for anything
7017 // except normal, non-super message-sends.
7018 // FIXME: don't use this for that.
7019 llvm::Constant *fn = nullptr;
7020 std::string messageRefName("\01l_");
7021 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
7023 fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
7024 messageRefName += "objc_msgSendSuper2_stret_fixup";
7026 nullReturn.init(CGF, arg0);
7027 fn = ObjCTypes.getMessageSendStretFixupFn();
7028 messageRefName += "objc_msgSend_stret_fixup";
7030 } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
7031 fn = ObjCTypes.getMessageSendFpretFixupFn();
7032 messageRefName += "objc_msgSend_fpret_fixup";
7035 fn = ObjCTypes.getMessageSendSuper2FixupFn();
7036 messageRefName += "objc_msgSendSuper2_fixup";
7038 fn = ObjCTypes.getMessageSendFixupFn();
7039 messageRefName += "objc_msgSend_fixup";
7042 assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend");
7043 messageRefName += '_';
7045 // Append the selector name, except use underscores anywhere we
7046 // would have used colons.
7047 appendSelectorForMessageRefTable(messageRefName, selector);
7049 llvm::GlobalVariable *messageRef
7050 = CGM.getModule().getGlobalVariable(messageRefName);
7052 // Build the message ref structure.
7053 ConstantInitBuilder builder(CGM);
7054 auto values = builder.beginStruct();
7056 values.add(GetMethodVarName(selector));
7057 messageRef = values.finishAndCreateGlobal(messageRefName,
7058 CharUnits::fromQuantity(16),
7060 llvm::GlobalValue::WeakAnyLinkage);
7061 messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
7062 messageRef->setSection("__DATA, __objc_msgrefs, coalesced");
7065 bool requiresnullCheck = false;
7066 if (CGM.getLangOpts().ObjCAutoRefCount && method)
7067 for (const auto *ParamDecl : method->parameters()) {
7068 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
7069 if (!nullReturn.NullBB)
7070 nullReturn.init(CGF, arg0);
7071 requiresnullCheck = true;
7077 Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
7078 CGF.getPointerAlign());
7080 // Update the message ref argument.
7081 args[1].RV = RValue::get(mref.getPointer());
7083 // Load the function to call from the message ref table.
7084 Address calleeAddr =
7085 CGF.Builder.CreateStructGEP(mref, 0, CharUnits::Zero());
7086 llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn");
7088 calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
7089 CGCallee callee(CGCalleeInfo(), calleePtr);
7091 RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
7092 return nullReturn.complete(CGF, result, resultType, formalArgs,
7093 requiresnullCheck ? method : nullptr);
7096 /// Generate code for a message send expression in the nonfragile abi.
7098 CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
7099 ReturnValueSlot Return,
7100 QualType ResultType,
7102 llvm::Value *Receiver,
7103 const CallArgList &CallArgs,
7104 const ObjCInterfaceDecl *Class,
7105 const ObjCMethodDecl *Method) {
7106 return isVTableDispatchedSelector(Sel)
7107 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7108 Receiver, CGF.getContext().getObjCIdType(),
7109 false, CallArgs, Method)
7110 : EmitMessageSend(CGF, Return, ResultType,
7111 EmitSelector(CGF, Sel),
7112 Receiver, CGF.getContext().getObjCIdType(),
7113 false, CallArgs, Method, Class, ObjCTypes);
7117 CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID,
7119 ForDefinition_t isForDefinition) {
7121 (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix());
7122 return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(),
7124 ID->isWeakImported(),
7126 && CGM.getTriple().isOSBinFormatCOFF()
7127 && ID->hasAttr<DLLImportAttr>());
7131 CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
7132 ForDefinition_t IsForDefinition,
7133 bool Weak, bool DLLImport) {
7134 llvm::GlobalValue::LinkageTypes L =
7135 Weak ? llvm::GlobalValue::ExternalWeakLinkage
7136 : llvm::GlobalValue::ExternalLinkage;
7140 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
7142 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
7143 false, L, nullptr, Name);
7146 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
7149 assert(GV->getLinkage() == L);
7154 CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
7156 const ObjCInterfaceDecl *ID) {
7157 CharUnits Align = CGF.getPointerAlign();
7158 llvm::GlobalVariable *&Entry = ClassReferences[II];
7161 llvm::Constant *ClassGV;
7163 ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7165 ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(),
7169 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7170 false, llvm::GlobalValue::PrivateLinkage,
7171 ClassGV, "OBJC_CLASSLIST_REFERENCES_$_");
7172 Entry->setAlignment(Align.getQuantity());
7173 Entry->setSection("__DATA, __objc_classrefs, regular, no_dead_strip");
7174 CGM.addCompilerUsedGlobal(Entry);
7176 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7179 llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
7180 const ObjCInterfaceDecl *ID) {
7181 // If the class has the objc_runtime_visible attribute, we need to
7182 // use the Objective-C runtime to get the class.
7183 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
7184 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
7186 return EmitClassRefFromId(CGF, ID->getIdentifier(), ID);
7189 llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
7190 CodeGenFunction &CGF) {
7191 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
7192 return EmitClassRefFromId(CGF, II, nullptr);
7196 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
7197 const ObjCInterfaceDecl *ID) {
7198 CharUnits Align = CGF.getPointerAlign();
7199 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
7202 auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7203 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7204 false, llvm::GlobalValue::PrivateLinkage,
7205 ClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
7206 Entry->setAlignment(Align.getQuantity());
7207 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
7208 CGM.addCompilerUsedGlobal(Entry);
7210 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7213 /// EmitMetaClassRef - Return a Value * of the address of _class_t
7216 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
7217 const ObjCInterfaceDecl *ID,
7219 CharUnits Align = CGF.getPointerAlign();
7220 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
7222 auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition);
7224 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7225 false, llvm::GlobalValue::PrivateLinkage,
7226 MetaClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
7227 Entry->setAlignment(Align.getQuantity());
7229 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
7230 CGM.addCompilerUsedGlobal(Entry);
7233 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7236 /// GetClass - Return a reference to the class for the given interface
7238 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
7239 const ObjCInterfaceDecl *ID) {
7240 if (ID->isWeakImported()) {
7241 auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7243 assert(!isa<llvm::GlobalVariable>(ClassGV) ||
7244 cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage());
7247 return EmitClassRef(CGF, ID);
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.
7254 CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
7255 ReturnValueSlot Return,
7256 QualType ResultType,
7258 const ObjCInterfaceDecl *Class,
7259 bool isCategoryImpl,
7260 llvm::Value *Receiver,
7261 bool IsClassMessage,
7262 const CodeGen::CallArgList &CallArgs,
7263 const ObjCMethodDecl *Method) {
7265 // Create and init a super structure; this is a (receiver, class)
7266 // pair we will pass to objc_msgSendSuper.
7268 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
7271 llvm::Value *ReceiverAsObject =
7272 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
7273 CGF.Builder.CreateStore(
7275 CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
7277 // If this is a class message the metaclass is passed as the target.
7278 llvm::Value *Target;
7280 Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported());
7282 Target = EmitSuperClassRef(CGF, Class);
7284 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
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()));
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);
7302 llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
7304 Address Addr = EmitSelectorAddr(CGF, Sel);
7306 llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr);
7307 LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7308 llvm::MDNode::get(VMContext, None));
7312 Address CGObjCNonFragileABIMac::EmitSelectorAddr(CodeGenFunction &CGF,
7314 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
7316 CharUnits Align = CGF.getPointerAlign();
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("__DATA, __objc_selrefs, literal_pointers, no_dead_strip");
7326 Entry->setAlignment(Align.getQuantity());
7327 CGM.addCompilerUsedGlobal(Entry);
7330 return Address(Entry, Align);
7333 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
7334 /// objc_assign_ivar (id src, id *dst, ptrdiff_t)
7336 void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
7339 llvm::Value *ivarOffset) {
7340 llvm::Type * SrcTy = src->getType();
7341 if (!isa<llvm::PointerType>(SrcTy)) {
7342 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7343 assert(Size <= 8 && "does not support size > 8");
7344 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7345 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7346 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7348 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7349 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7350 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
7351 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
7354 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
7355 /// objc_assign_strongCast (id src, id *dst)
7357 void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
7358 CodeGen::CodeGenFunction &CGF,
7359 llvm::Value *src, Address dst) {
7360 llvm::Type * SrcTy = src->getType();
7361 if (!isa<llvm::PointerType>(SrcTy)) {
7362 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7363 assert(Size <= 8 && "does not support size > 8");
7364 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7365 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7366 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7368 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7369 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7370 llvm::Value *args[] = { src, dst.getPointer() };
7371 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
7372 args, "weakassign");
7375 void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
7376 CodeGen::CodeGenFunction &CGF,
7379 llvm::Value *Size) {
7380 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
7381 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
7382 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), Size };
7383 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
7386 /// EmitObjCWeakRead - Code gen for loading value of a __weak
7387 /// object: objc_read_weak (id *src)
7389 llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
7390 CodeGen::CodeGenFunction &CGF,
7391 Address AddrWeakObj) {
7392 llvm::Type *DestTy = AddrWeakObj.getElementType();
7393 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
7394 llvm::Value *read_weak =
7395 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
7396 AddrWeakObj.getPointer(), "weakread");
7397 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
7401 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
7402 /// objc_assign_weak (id src, id *dst)
7404 void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
7405 llvm::Value *src, Address dst) {
7406 llvm::Type * SrcTy = src->getType();
7407 if (!isa<llvm::PointerType>(SrcTy)) {
7408 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7409 assert(Size <= 8 && "does not support size > 8");
7410 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7411 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7412 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7414 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7415 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7416 llvm::Value *args[] = { src, dst.getPointer() };
7417 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
7418 args, "weakassign");
7421 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
7422 /// objc_assign_global (id src, id *dst)
7424 void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
7425 llvm::Value *src, Address dst,
7427 llvm::Type * SrcTy = src->getType();
7428 if (!isa<llvm::PointerType>(SrcTy)) {
7429 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7430 assert(Size <= 8 && "does not support size > 8");
7431 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7432 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7433 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7435 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7436 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7437 llvm::Value *args[] = { src, dst.getPointer() };
7439 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
7440 args, "globalassign");
7442 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
7443 args, "threadlocalassign");
7447 CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
7448 const ObjCAtSynchronizedStmt &S) {
7449 EmitAtSynchronizedStmt(CGF, S,
7450 cast<llvm::Function>(ObjCTypes.getSyncEnterFn()),
7451 cast<llvm::Function>(ObjCTypes.getSyncExitFn()));
7455 CGObjCNonFragileABIMac::GetEHType(QualType T) {
7456 // There's a particular fixed type info for 'id'.
7457 if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
7458 auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
7461 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7462 llvm::GlobalValue::ExternalLinkage, nullptr,
7464 if (CGM.getTriple().isOSBinFormatCOFF())
7465 IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id"));
7470 // All other types should be Objective-C interface pointer types.
7471 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
7472 assert(PT && "Invalid @catch type.");
7474 const ObjCInterfaceType *IT = PT->getInterfaceType();
7475 assert(IT && "Invalid @catch type.");
7477 return GetInterfaceEHType(IT->getDecl(), NotForDefinition);
7480 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
7481 const ObjCAtTryStmt &S) {
7482 EmitTryCatchStmt(CGF, S,
7483 cast<llvm::Function>(ObjCTypes.getObjCBeginCatchFn()),
7484 cast<llvm::Function>(ObjCTypes.getObjCEndCatchFn()),
7485 cast<llvm::Function>(ObjCTypes.getExceptionRethrowFn()));
7488 /// EmitThrowStmt - Generate code for a throw statement.
7489 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
7490 const ObjCAtThrowStmt &S,
7491 bool ClearInsertionPoint) {
7492 if (const Expr *ThrowExpr = S.getThrowExpr()) {
7493 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
7494 Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7495 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception)
7496 .setDoesNotReturn();
7498 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn())
7499 .setDoesNotReturn();
7502 CGF.Builder.CreateUnreachable();
7503 if (ClearInsertionPoint)
7504 CGF.Builder.ClearInsertionPoint();
7508 CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
7509 ForDefinition_t IsForDefinition) {
7510 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
7511 StringRef ClassName = ID->getObjCRuntimeNameAsString();
7513 // If we don't need a definition, return the entry if found or check
7514 // if we use an external reference.
7515 if (!IsForDefinition) {
7519 // If this type (or a super class) has the __objc_exception__
7520 // attribute, emit an external reference.
7521 if (hasObjCExceptionAttribute(CGM.getContext(), ID)) {
7522 std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str();
7523 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
7524 false, llvm::GlobalValue::ExternalLinkage,
7525 nullptr, EHTypeName);
7526 if (CGM.getTriple().isOSBinFormatCOFF()) {
7527 if (ID->hasAttr<DLLExportAttr>())
7528 Entry->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
7529 else if (ID->hasAttr<DLLImportAttr>())
7530 Entry->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
7536 // Otherwise we need to either make a new entry or fill in the initializer.
7537 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
7539 std::string VTableName = "objc_ehtype_vtable";
7540 auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName);
7543 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false,
7544 llvm::GlobalValue::ExternalLinkage, nullptr,
7546 if (CGM.getTriple().isOSBinFormatCOFF())
7547 VTableGV->setDLLStorageClass(getStorage(CGM, VTableName));
7550 llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
7551 ConstantInitBuilder builder(CGM);
7552 auto values = builder.beginStruct(ObjCTypes.EHTypeTy);
7553 values.add(llvm::ConstantExpr::getGetElementPtr(VTableGV->getValueType(),
7554 VTableGV, VTableIdx));
7555 values.add(GetClassName(ClassName));
7556 values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition));
7558 llvm::GlobalValue::LinkageTypes L = IsForDefinition
7559 ? llvm::GlobalValue::ExternalLinkage
7560 : llvm::GlobalValue::WeakAnyLinkage;
7562 values.finishAndSetAsInitializer(Entry);
7563 Entry->setAlignment(CGM.getPointerAlign().getQuantity());
7565 Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName,
7566 CGM.getPointerAlign(),
7569 if (CGM.getTriple().isOSBinFormatCOFF())
7570 if (hasObjCExceptionAttribute(CGM.getContext(), ID))
7571 if (ID->hasAttr<DLLExportAttr>())
7572 Entry->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
7574 assert(Entry->getLinkage() == L);
7576 if (!CGM.getTriple().isOSBinFormatCOFF())
7577 if (ID->getVisibility() == HiddenVisibility)
7578 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7580 if (IsForDefinition)
7581 if (CGM.getTriple().isOSBinFormatMachO())
7582 Entry->setSection("__DATA,__objc_const");
7589 CodeGen::CGObjCRuntime *
7590 CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
7591 switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
7592 case ObjCRuntime::FragileMacOSX:
7593 return new CGObjCMac(CGM);
7595 case ObjCRuntime::MacOSX:
7596 case ObjCRuntime::iOS:
7597 case ObjCRuntime::WatchOS:
7598 return new CGObjCNonFragileABIMac(CGM);
7600 case ObjCRuntime::GNUstep:
7601 case ObjCRuntime::GCC:
7602 case ObjCRuntime::ObjFW:
7603 llvm_unreachable("these runtimes are not Mac runtimes");
7605 llvm_unreachable("bad runtime");