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 "clang/CodeGen/ConstantInitBuilder.h"
21 #include "clang/AST/ASTContext.h"
22 #include "clang/AST/Decl.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/AST/RecordLayout.h"
25 #include "clang/AST/StmtObjC.h"
26 #include "clang/Basic/CodeGenOptions.h"
27 #include "clang/Basic/LangOptions.h"
28 #include "clang/CodeGen/CGFunctionInfo.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/ScopedPrinter.h"
41 #include "llvm/Support/raw_ostream.h"
44 using namespace clang;
45 using namespace CodeGen;
49 // FIXME: We should find a nicer way to make the labels for metadata, string
50 // concatenation is lame.
52 class ObjCCommonTypesHelper {
54 llvm::LLVMContext &VMContext;
57 // The types of these functions don't really matter because we
58 // should always bitcast before calling them.
60 /// id objc_msgSend (id, SEL, ...)
62 /// The default messenger, used for sends whose ABI is unchanged from
63 /// the all-integer/pointer case.
64 llvm::Constant *getMessageSendFn() const {
65 // Add the non-lazy-bind attribute, since objc_msgSend is likely to
67 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
68 return CGM.CreateRuntimeFunction(
69 llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend",
70 llvm::AttributeList::get(CGM.getLLVMContext(),
71 llvm::AttributeList::FunctionIndex,
72 llvm::Attribute::NonLazyBind));
75 /// void objc_msgSend_stret (id, SEL, ...)
77 /// The messenger used when the return value is an aggregate returned
78 /// by indirect reference in the first argument, and therefore the
79 /// self and selector parameters are shifted over by one.
80 llvm::Constant *getMessageSendStretFn() const {
81 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
82 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
84 "objc_msgSend_stret");
88 /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
90 /// The messenger used when the return value is returned on the x87
91 /// floating-point stack; without a special entrypoint, the nil case
92 /// would be unbalanced.
93 llvm::Constant *getMessageSendFpretFn() const {
94 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
95 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
97 "objc_msgSend_fpret");
101 /// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
103 /// The messenger used when the return value is returned in two values on the
104 /// x87 floating point stack; without a special entrypoint, the nil case
105 /// would be unbalanced. Only used on 64-bit X86.
106 llvm::Constant *getMessageSendFp2retFn() const {
107 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
108 llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext);
109 llvm::Type *resultType =
110 llvm::StructType::get(longDoubleType, longDoubleType);
112 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType,
114 "objc_msgSend_fp2ret");
117 /// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
119 /// The messenger used for super calls, which have different dispatch
120 /// semantics. The class passed is the superclass of the current
122 llvm::Constant *getMessageSendSuperFn() const {
123 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
124 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
126 "objc_msgSendSuper");
129 /// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
131 /// A slightly different messenger used for super calls. The class
132 /// passed is the current class.
133 llvm::Constant *getMessageSendSuperFn2() const {
134 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
135 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
137 "objc_msgSendSuper2");
140 /// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super,
143 /// The messenger used for super calls which return an aggregate indirectly.
144 llvm::Constant *getMessageSendSuperStretFn() const {
145 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
146 return CGM.CreateRuntimeFunction(
147 llvm::FunctionType::get(CGM.VoidTy, params, true),
148 "objc_msgSendSuper_stret");
151 /// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
154 /// objc_msgSendSuper_stret with the super2 semantics.
155 llvm::Constant *getMessageSendSuperStretFn2() const {
156 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
157 return CGM.CreateRuntimeFunction(
158 llvm::FunctionType::get(CGM.VoidTy, params, true),
159 "objc_msgSendSuper2_stret");
162 llvm::Constant *getMessageSendSuperFpretFn() const {
163 // There is no objc_msgSendSuper_fpret? How can that work?
164 return getMessageSendSuperFn();
167 llvm::Constant *getMessageSendSuperFpretFn2() const {
168 // There is no objc_msgSendSuper_fpret? How can that work?
169 return getMessageSendSuperFn2();
173 CodeGen::CodeGenModule &CGM;
176 llvm::IntegerType *ShortTy, *IntTy, *LongTy;
177 llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy;
178 llvm::Type *IvarOffsetVarTy;
180 /// ObjectPtrTy - LLVM type for object handles (typeof(id))
181 llvm::PointerType *ObjectPtrTy;
183 /// PtrObjectPtrTy - LLVM type for id *
184 llvm::PointerType *PtrObjectPtrTy;
186 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
187 llvm::PointerType *SelectorPtrTy;
190 /// ProtocolPtrTy - LLVM type for external protocol handles
191 /// (typeof(Protocol))
192 llvm::Type *ExternalProtocolPtrTy;
195 llvm::Type *getExternalProtocolPtrTy() {
196 if (!ExternalProtocolPtrTy) {
197 // FIXME: It would be nice to unify this with the opaque type, so that the
198 // IR comes out a bit cleaner.
199 CodeGen::CodeGenTypes &Types = CGM.getTypes();
200 ASTContext &Ctx = CGM.getContext();
201 llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
202 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
205 return ExternalProtocolPtrTy;
208 // SuperCTy - clang type for struct objc_super.
210 // SuperPtrCTy - clang type for struct objc_super *.
211 QualType SuperPtrCTy;
213 /// SuperTy - LLVM type for struct objc_super.
214 llvm::StructType *SuperTy;
215 /// SuperPtrTy - LLVM type for struct objc_super *.
216 llvm::PointerType *SuperPtrTy;
218 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
219 /// in GCC parlance).
220 llvm::StructType *PropertyTy;
222 /// PropertyListTy - LLVM type for struct objc_property_list
223 /// (_prop_list_t in GCC parlance).
224 llvm::StructType *PropertyListTy;
225 /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
226 llvm::PointerType *PropertyListPtrTy;
228 // MethodTy - LLVM type for struct objc_method.
229 llvm::StructType *MethodTy;
231 /// CacheTy - LLVM type for struct objc_cache.
233 /// CachePtrTy - LLVM type for struct objc_cache *.
234 llvm::PointerType *CachePtrTy;
236 llvm::Constant *getGetPropertyFn() {
237 CodeGen::CodeGenTypes &Types = CGM.getTypes();
238 ASTContext &Ctx = CGM.getContext();
239 // id objc_getProperty (id, SEL, ptrdiff_t, bool)
240 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
241 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
242 CanQualType Params[] = {
244 Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), Ctx.BoolTy};
245 llvm::FunctionType *FTy =
246 Types.GetFunctionType(
247 Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
248 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
251 llvm::Constant *getSetPropertyFn() {
252 CodeGen::CodeGenTypes &Types = CGM.getTypes();
253 ASTContext &Ctx = CGM.getContext();
254 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
255 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
256 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
257 CanQualType Params[] = {
260 Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(),
264 llvm::FunctionType *FTy =
265 Types.GetFunctionType(
266 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
267 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
270 llvm::Constant *getOptimizedSetPropertyFn(bool atomic, bool copy) {
271 CodeGen::CodeGenTypes &Types = CGM.getTypes();
272 ASTContext &Ctx = CGM.getContext();
273 // void objc_setProperty_atomic(id self, SEL _cmd,
274 // id newValue, ptrdiff_t offset);
275 // void objc_setProperty_nonatomic(id self, SEL _cmd,
276 // id newValue, ptrdiff_t offset);
277 // void objc_setProperty_atomic_copy(id self, SEL _cmd,
278 // id newValue, ptrdiff_t offset);
279 // void objc_setProperty_nonatomic_copy(id self, SEL _cmd,
280 // id newValue, ptrdiff_t offset);
282 SmallVector<CanQualType,4> Params;
283 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
284 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
285 Params.push_back(IdType);
286 Params.push_back(SelType);
287 Params.push_back(IdType);
288 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
289 llvm::FunctionType *FTy =
290 Types.GetFunctionType(
291 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
294 name = "objc_setProperty_atomic_copy";
295 else if (atomic && !copy)
296 name = "objc_setProperty_atomic";
297 else if (!atomic && copy)
298 name = "objc_setProperty_nonatomic_copy";
300 name = "objc_setProperty_nonatomic";
302 return CGM.CreateRuntimeFunction(FTy, name);
305 llvm::Constant *getCopyStructFn() {
306 CodeGen::CodeGenTypes &Types = CGM.getTypes();
307 ASTContext &Ctx = CGM.getContext();
308 // void objc_copyStruct (void *, const void *, size_t, bool, bool)
309 SmallVector<CanQualType,5> Params;
310 Params.push_back(Ctx.VoidPtrTy);
311 Params.push_back(Ctx.VoidPtrTy);
312 Params.push_back(Ctx.getSizeType());
313 Params.push_back(Ctx.BoolTy);
314 Params.push_back(Ctx.BoolTy);
315 llvm::FunctionType *FTy =
316 Types.GetFunctionType(
317 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
318 return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
321 /// This routine declares and returns address of:
322 /// void objc_copyCppObjectAtomic(
323 /// void *dest, const void *src,
324 /// void (*copyHelper) (void *dest, const void *source));
325 llvm::Constant *getCppAtomicObjectFunction() {
326 CodeGen::CodeGenTypes &Types = CGM.getTypes();
327 ASTContext &Ctx = CGM.getContext();
328 /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
329 SmallVector<CanQualType,3> Params;
330 Params.push_back(Ctx.VoidPtrTy);
331 Params.push_back(Ctx.VoidPtrTy);
332 Params.push_back(Ctx.VoidPtrTy);
333 llvm::FunctionType *FTy =
334 Types.GetFunctionType(
335 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
336 return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
339 llvm::Constant *getEnumerationMutationFn() {
340 CodeGen::CodeGenTypes &Types = CGM.getTypes();
341 ASTContext &Ctx = CGM.getContext();
342 // void objc_enumerationMutation (id)
343 SmallVector<CanQualType,1> Params;
344 Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
345 llvm::FunctionType *FTy =
346 Types.GetFunctionType(
347 Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
348 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
351 llvm::Constant *getLookUpClassFn() {
352 CodeGen::CodeGenTypes &Types = CGM.getTypes();
353 ASTContext &Ctx = CGM.getContext();
354 // Class objc_lookUpClass (const char *)
355 SmallVector<CanQualType,1> Params;
357 Ctx.getCanonicalType(Ctx.getPointerType(Ctx.CharTy.withConst())));
358 llvm::FunctionType *FTy =
359 Types.GetFunctionType(Types.arrangeBuiltinFunctionDeclaration(
360 Ctx.getCanonicalType(Ctx.getObjCClassType()),
362 return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass");
365 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
366 llvm::Constant *getGcReadWeakFn() {
367 // id objc_read_weak (id *)
368 llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
369 llvm::FunctionType *FTy =
370 llvm::FunctionType::get(ObjectPtrTy, args, false);
371 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
374 /// GcAssignWeakFn -- LLVM objc_assign_weak function.
375 llvm::Constant *getGcAssignWeakFn() {
376 // id objc_assign_weak (id, id *)
377 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
378 llvm::FunctionType *FTy =
379 llvm::FunctionType::get(ObjectPtrTy, args, false);
380 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
383 /// GcAssignGlobalFn -- LLVM objc_assign_global function.
384 llvm::Constant *getGcAssignGlobalFn() {
385 // id objc_assign_global(id, id *)
386 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
387 llvm::FunctionType *FTy =
388 llvm::FunctionType::get(ObjectPtrTy, args, false);
389 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
392 /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
393 llvm::Constant *getGcAssignThreadLocalFn() {
394 // id objc_assign_threadlocal(id src, id * dest)
395 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
396 llvm::FunctionType *FTy =
397 llvm::FunctionType::get(ObjectPtrTy, args, false);
398 return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
401 /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
402 llvm::Constant *getGcAssignIvarFn() {
403 // id objc_assign_ivar(id, id *, ptrdiff_t)
404 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
406 llvm::FunctionType *FTy =
407 llvm::FunctionType::get(ObjectPtrTy, args, false);
408 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
411 /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
412 llvm::Constant *GcMemmoveCollectableFn() {
413 // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
414 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
415 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
416 return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
419 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
420 llvm::Constant *getGcAssignStrongCastFn() {
421 // id objc_assign_strongCast(id, id *)
422 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
423 llvm::FunctionType *FTy =
424 llvm::FunctionType::get(ObjectPtrTy, args, false);
425 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
428 /// ExceptionThrowFn - LLVM objc_exception_throw function.
429 llvm::Constant *getExceptionThrowFn() {
430 // void objc_exception_throw(id)
431 llvm::Type *args[] = { ObjectPtrTy };
432 llvm::FunctionType *FTy =
433 llvm::FunctionType::get(CGM.VoidTy, args, false);
434 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
437 /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
438 llvm::Constant *getExceptionRethrowFn() {
439 // void objc_exception_rethrow(void)
440 llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
441 return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
444 /// SyncEnterFn - LLVM object_sync_enter function.
445 llvm::Constant *getSyncEnterFn() {
446 // int objc_sync_enter (id)
447 llvm::Type *args[] = { ObjectPtrTy };
448 llvm::FunctionType *FTy =
449 llvm::FunctionType::get(CGM.IntTy, args, false);
450 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
453 /// SyncExitFn - LLVM object_sync_exit function.
454 llvm::Constant *getSyncExitFn() {
455 // int objc_sync_exit (id)
456 llvm::Type *args[] = { ObjectPtrTy };
457 llvm::FunctionType *FTy =
458 llvm::FunctionType::get(CGM.IntTy, args, false);
459 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
462 llvm::Constant *getSendFn(bool IsSuper) const {
463 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
466 llvm::Constant *getSendFn2(bool IsSuper) const {
467 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
470 llvm::Constant *getSendStretFn(bool IsSuper) const {
471 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
474 llvm::Constant *getSendStretFn2(bool IsSuper) const {
475 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
478 llvm::Constant *getSendFpretFn(bool IsSuper) const {
479 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
482 llvm::Constant *getSendFpretFn2(bool IsSuper) const {
483 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
486 llvm::Constant *getSendFp2retFn(bool IsSuper) const {
487 return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
490 llvm::Constant *getSendFp2RetFn2(bool IsSuper) const {
491 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn();
494 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
497 /// ObjCTypesHelper - Helper class that encapsulates lazy
498 /// construction of varies types used during ObjC generation.
499 class ObjCTypesHelper : public ObjCCommonTypesHelper {
501 /// SymtabTy - LLVM type for struct objc_symtab.
502 llvm::StructType *SymtabTy;
503 /// SymtabPtrTy - LLVM type for struct objc_symtab *.
504 llvm::PointerType *SymtabPtrTy;
505 /// ModuleTy - LLVM type for struct objc_module.
506 llvm::StructType *ModuleTy;
508 /// ProtocolTy - LLVM type for struct objc_protocol.
509 llvm::StructType *ProtocolTy;
510 /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
511 llvm::PointerType *ProtocolPtrTy;
512 /// ProtocolExtensionTy - LLVM type for struct
513 /// objc_protocol_extension.
514 llvm::StructType *ProtocolExtensionTy;
515 /// ProtocolExtensionTy - LLVM type for struct
516 /// objc_protocol_extension *.
517 llvm::PointerType *ProtocolExtensionPtrTy;
518 /// MethodDescriptionTy - LLVM type for struct
519 /// objc_method_description.
520 llvm::StructType *MethodDescriptionTy;
521 /// MethodDescriptionListTy - LLVM type for struct
522 /// objc_method_description_list.
523 llvm::StructType *MethodDescriptionListTy;
524 /// MethodDescriptionListPtrTy - LLVM type for struct
525 /// objc_method_description_list *.
526 llvm::PointerType *MethodDescriptionListPtrTy;
527 /// ProtocolListTy - LLVM type for struct objc_property_list.
528 llvm::StructType *ProtocolListTy;
529 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
530 llvm::PointerType *ProtocolListPtrTy;
531 /// CategoryTy - LLVM type for struct objc_category.
532 llvm::StructType *CategoryTy;
533 /// ClassTy - LLVM type for struct objc_class.
534 llvm::StructType *ClassTy;
535 /// ClassPtrTy - LLVM type for struct objc_class *.
536 llvm::PointerType *ClassPtrTy;
537 /// ClassExtensionTy - LLVM type for struct objc_class_ext.
538 llvm::StructType *ClassExtensionTy;
539 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
540 llvm::PointerType *ClassExtensionPtrTy;
541 // IvarTy - LLVM type for struct objc_ivar.
542 llvm::StructType *IvarTy;
543 /// IvarListTy - LLVM type for struct objc_ivar_list.
544 llvm::StructType *IvarListTy;
545 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
546 llvm::PointerType *IvarListPtrTy;
547 /// MethodListTy - LLVM type for struct objc_method_list.
548 llvm::StructType *MethodListTy;
549 /// MethodListPtrTy - LLVM type for struct objc_method_list *.
550 llvm::PointerType *MethodListPtrTy;
552 /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
553 llvm::StructType *ExceptionDataTy;
555 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
556 llvm::Constant *getExceptionTryEnterFn() {
557 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
558 return CGM.CreateRuntimeFunction(
559 llvm::FunctionType::get(CGM.VoidTy, params, false),
560 "objc_exception_try_enter");
563 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
564 llvm::Constant *getExceptionTryExitFn() {
565 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
566 return CGM.CreateRuntimeFunction(
567 llvm::FunctionType::get(CGM.VoidTy, params, false),
568 "objc_exception_try_exit");
571 /// ExceptionExtractFn - LLVM objc_exception_extract function.
572 llvm::Constant *getExceptionExtractFn() {
573 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
574 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
576 "objc_exception_extract");
579 /// ExceptionMatchFn - LLVM objc_exception_match function.
580 llvm::Constant *getExceptionMatchFn() {
581 llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
582 return CGM.CreateRuntimeFunction(
583 llvm::FunctionType::get(CGM.Int32Ty, params, false),
584 "objc_exception_match");
587 /// SetJmpFn - LLVM _setjmp function.
588 llvm::Constant *getSetJmpFn() {
589 // This is specifically the prototype for x86.
590 llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
591 return CGM.CreateRuntimeFunction(
592 llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp",
593 llvm::AttributeList::get(CGM.getLLVMContext(),
594 llvm::AttributeList::FunctionIndex,
595 llvm::Attribute::NonLazyBind));
599 ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
602 /// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
604 class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
606 // MethodListnfABITy - LLVM for struct _method_list_t
607 llvm::StructType *MethodListnfABITy;
609 // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
610 llvm::PointerType *MethodListnfABIPtrTy;
612 // ProtocolnfABITy = LLVM for struct _protocol_t
613 llvm::StructType *ProtocolnfABITy;
615 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
616 llvm::PointerType *ProtocolnfABIPtrTy;
618 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
619 llvm::StructType *ProtocolListnfABITy;
621 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
622 llvm::PointerType *ProtocolListnfABIPtrTy;
624 // ClassnfABITy - LLVM for struct _class_t
625 llvm::StructType *ClassnfABITy;
627 // ClassnfABIPtrTy - LLVM for struct _class_t*
628 llvm::PointerType *ClassnfABIPtrTy;
630 // IvarnfABITy - LLVM for struct _ivar_t
631 llvm::StructType *IvarnfABITy;
633 // IvarListnfABITy - LLVM for struct _ivar_list_t
634 llvm::StructType *IvarListnfABITy;
636 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
637 llvm::PointerType *IvarListnfABIPtrTy;
639 // ClassRonfABITy - LLVM for struct _class_ro_t
640 llvm::StructType *ClassRonfABITy;
642 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
643 llvm::PointerType *ImpnfABITy;
645 // CategorynfABITy - LLVM for struct _category_t
646 llvm::StructType *CategorynfABITy;
648 // New types for nonfragile abi messaging.
650 // MessageRefTy - LLVM for:
651 // struct _message_ref_t {
655 llvm::StructType *MessageRefTy;
656 // MessageRefCTy - clang type for struct _message_ref_t
657 QualType MessageRefCTy;
659 // MessageRefPtrTy - LLVM for struct _message_ref_t*
660 llvm::Type *MessageRefPtrTy;
661 // MessageRefCPtrTy - clang type for struct _message_ref_t*
662 QualType MessageRefCPtrTy;
664 // SuperMessageRefTy - LLVM for:
665 // struct _super_message_ref_t {
666 // SUPER_IMP messenger;
669 llvm::StructType *SuperMessageRefTy;
671 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
672 llvm::PointerType *SuperMessageRefPtrTy;
674 llvm::Constant *getMessageSendFixupFn() {
675 // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
676 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
677 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
679 "objc_msgSend_fixup");
682 llvm::Constant *getMessageSendFpretFixupFn() {
683 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
684 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
685 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
687 "objc_msgSend_fpret_fixup");
690 llvm::Constant *getMessageSendStretFixupFn() {
691 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
692 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
693 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
695 "objc_msgSend_stret_fixup");
698 llvm::Constant *getMessageSendSuper2FixupFn() {
699 // id objc_msgSendSuper2_fixup (struct objc_super *,
700 // struct _super_message_ref_t*, ...)
701 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
702 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
704 "objc_msgSendSuper2_fixup");
707 llvm::Constant *getMessageSendSuper2StretFixupFn() {
708 // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
709 // struct _super_message_ref_t*, ...)
710 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
711 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
713 "objc_msgSendSuper2_stret_fixup");
716 llvm::Constant *getObjCEndCatchFn() {
717 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
722 llvm::Constant *getObjCBeginCatchFn() {
723 llvm::Type *params[] = { Int8PtrTy };
724 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
729 llvm::StructType *EHTypeTy;
730 llvm::Type *EHTypePtrTy;
732 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
735 enum class ObjCLabelType {
742 class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
748 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
749 : skip(_skip), scan(_scan) {}
752 /// opcode for captured block variables layout 'instructions'.
753 /// In the following descriptions, 'I' is the value of the immediate field.
754 /// (field following the opcode).
756 enum BLOCK_LAYOUT_OPCODE {
757 /// An operator which affects how the following layout should be
759 /// I == 0: Halt interpretation and treat everything else as
760 /// a non-pointer. Note that this instruction is equal
762 /// I != 0: Currently unused.
763 BLOCK_LAYOUT_OPERATOR = 0,
765 /// The next I+1 bytes do not contain a value of object pointer type.
766 /// Note that this can leave the stream unaligned, meaning that
767 /// subsequent word-size instructions do not begin at a multiple of
768 /// the pointer size.
769 BLOCK_LAYOUT_NON_OBJECT_BYTES = 1,
771 /// The next I+1 words do not contain a value of object pointer type.
772 /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
773 /// when the required skip quantity is a multiple of the pointer size.
774 BLOCK_LAYOUT_NON_OBJECT_WORDS = 2,
776 /// The next I+1 words are __strong pointers to Objective-C
777 /// objects or blocks.
778 BLOCK_LAYOUT_STRONG = 3,
780 /// The next I+1 words are pointers to __block variables.
781 BLOCK_LAYOUT_BYREF = 4,
783 /// The next I+1 words are __weak pointers to Objective-C
784 /// objects or blocks.
785 BLOCK_LAYOUT_WEAK = 5,
787 /// The next I+1 words are __unsafe_unretained pointers to
788 /// Objective-C objects or blocks.
789 BLOCK_LAYOUT_UNRETAINED = 6
791 /// The next I+1 words are block or object pointers with some
792 /// as-yet-unspecified ownership semantics. If we add more
793 /// flavors of ownership semantics, values will be taken from
796 /// This is included so that older tools can at least continue
797 /// processing the layout past such things.
798 //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
800 /// All other opcodes are reserved. Halt interpretation and
801 /// treat everything else as opaque.
806 enum BLOCK_LAYOUT_OPCODE opcode;
807 CharUnits block_var_bytepos;
808 CharUnits block_var_size;
809 RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
810 CharUnits BytePos = CharUnits::Zero(),
811 CharUnits Size = CharUnits::Zero())
812 : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {}
814 // Allow sorting based on byte pos.
815 bool operator<(const RUN_SKIP &b) const {
816 return block_var_bytepos < b.block_var_bytepos;
821 llvm::LLVMContext &VMContext;
822 // FIXME! May not be needing this after all.
825 // arc/mrr layout of captured block literal variables.
826 SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
828 /// LazySymbols - Symbols to generate a lazy reference for. See
829 /// DefinedSymbols and FinishModule().
830 llvm::SetVector<IdentifierInfo*> LazySymbols;
832 /// DefinedSymbols - External symbols which are defined by this
833 /// module. The symbols in this list and LazySymbols are used to add
834 /// special linker symbols which ensure that Objective-C modules are
836 llvm::SetVector<IdentifierInfo*> DefinedSymbols;
838 /// ClassNames - uniqued class names.
839 llvm::StringMap<llvm::GlobalVariable*> ClassNames;
841 /// MethodVarNames - uniqued method variable names.
842 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
844 /// DefinedCategoryNames - list of category names in form Class_Category.
845 llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames;
847 /// MethodVarTypes - uniqued method type signatures. We have to use
848 /// a StringMap here because have no other unique reference.
849 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
851 /// MethodDefinitions - map of methods which have been defined in
852 /// this translation unit.
853 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
855 /// PropertyNames - uniqued method variable names.
856 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
858 /// ClassReferences - uniqued class references.
859 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
861 /// SelectorReferences - uniqued selector references.
862 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
864 /// Protocols - Protocols for which an objc_protocol structure has
865 /// been emitted. Forward declarations are handled by creating an
866 /// empty structure whose initializer is filled in when/if defined.
867 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
869 /// DefinedProtocols - Protocols which have actually been
870 /// defined. We should not need this, see FIXME in GenerateProtocol.
871 llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
873 /// DefinedClasses - List of defined classes.
874 SmallVector<llvm::GlobalValue*, 16> DefinedClasses;
876 /// ImplementedClasses - List of @implemented classes.
877 SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses;
879 /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
880 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
882 /// DefinedCategories - List of defined categories.
883 SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
885 /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
886 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
888 /// Cached reference to the class for constant strings. This value has type
889 /// int * but is actually an Obj-C class pointer.
890 llvm::WeakTrackingVH ConstantStringClassRef;
892 /// The LLVM type corresponding to NSConstantString.
893 llvm::StructType *NSConstantStringType = nullptr;
895 llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap;
897 /// GetNameForMethod - Return a name for the given method.
898 /// \param[out] NameOut - The return value.
899 void GetNameForMethod(const ObjCMethodDecl *OMD,
900 const ObjCContainerDecl *CD,
901 SmallVectorImpl<char> &NameOut);
903 /// GetMethodVarName - Return a unique constant for the given
904 /// selector's name. The return value has type char *.
905 llvm::Constant *GetMethodVarName(Selector Sel);
906 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
908 /// GetMethodVarType - Return a unique constant for the given
909 /// method's type encoding string. The return value has type char *.
911 // FIXME: This is a horrible name.
912 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
913 bool Extended = false);
914 llvm::Constant *GetMethodVarType(const FieldDecl *D);
916 /// GetPropertyName - Return a unique constant for the given
917 /// name. The return value has type char *.
918 llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
920 // FIXME: This can be dropped once string functions are unified.
921 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
922 const Decl *Container);
924 /// GetClassName - Return a unique constant for the given selector's
925 /// runtime name (which may change via use of objc_runtime_name attribute on
926 /// class or protocol definition. The return value has type char *.
927 llvm::Constant *GetClassName(StringRef RuntimeName);
929 llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
931 /// BuildIvarLayout - Builds ivar layout bitmap for the class
932 /// implementation for the __strong or __weak case.
934 /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there
935 /// are any weak ivars defined directly in the class. Meaningless unless
936 /// building a weak layout. Does not guarantee that the layout will
937 /// actually have any entries, because the ivar might be under-aligned.
938 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
939 CharUnits beginOffset,
941 bool forStrongLayout,
942 bool hasMRCWeakIvars);
944 llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,
945 CharUnits beginOffset,
946 CharUnits endOffset) {
947 return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
950 llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
951 CharUnits beginOffset,
953 bool hasMRCWeakIvars) {
954 return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
957 Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
959 void UpdateRunSkipBlockVars(bool IsByref,
960 Qualifiers::ObjCLifetime LifeTime,
961 CharUnits FieldOffset,
962 CharUnits FieldSize);
964 void BuildRCBlockVarRecordLayout(const RecordType *RT,
965 CharUnits BytePos, bool &HasUnion,
966 bool ByrefLayout=false);
968 void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
969 const RecordDecl *RD,
970 ArrayRef<const FieldDecl*> RecFields,
971 CharUnits BytePos, bool &HasUnion,
974 uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
976 llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
978 /// GetIvarLayoutName - Returns a unique constant for the given
979 /// ivar layout bitmap.
980 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
981 const ObjCCommonTypesHelper &ObjCTypes);
983 /// EmitPropertyList - Emit the given property list. The return
984 /// value has type PropertyListPtrTy.
985 llvm::Constant *EmitPropertyList(Twine Name,
986 const Decl *Container,
987 const ObjCContainerDecl *OCD,
988 const ObjCCommonTypesHelper &ObjCTypes,
989 bool IsClassProperty);
991 /// EmitProtocolMethodTypes - Generate the array of extended method type
992 /// strings. The return value has type Int8PtrPtrTy.
993 llvm::Constant *EmitProtocolMethodTypes(Twine Name,
994 ArrayRef<llvm::Constant*> MethodTypes,
995 const ObjCCommonTypesHelper &ObjCTypes);
997 /// GetProtocolRef - Return a reference to the internal protocol
998 /// description, creating an empty one if it has not been
999 /// defined. The return value has type ProtocolPtrTy.
1000 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
1002 /// Return a reference to the given Class using runtime calls rather than
1003 /// by a symbol reference.
1004 llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,
1005 const ObjCInterfaceDecl *ID,
1006 ObjCCommonTypesHelper &ObjCTypes);
1008 std::string GetSectionName(StringRef Section, StringRef MachOAttributes);
1011 /// CreateMetadataVar - Create a global variable with internal
1012 /// linkage for use by the Objective-C runtime.
1014 /// This is a convenience wrapper which not only creates the
1015 /// variable, but also sets the section and alignment and adds the
1016 /// global to the "llvm.used" list.
1018 /// \param Name - The variable name.
1019 /// \param Init - The variable initializer; this is also used to
1020 /// define the type of the variable.
1021 /// \param Section - The section the variable should go into, or empty.
1022 /// \param Align - The alignment for the variable, or 0.
1023 /// \param AddToUsed - Whether the variable should be added to
1025 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1026 ConstantStructBuilder &Init,
1027 StringRef Section, CharUnits Align,
1029 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1030 llvm::Constant *Init,
1031 StringRef Section, CharUnits Align,
1034 llvm::GlobalVariable *CreateCStringLiteral(StringRef Name,
1035 ObjCLabelType LabelType,
1036 bool ForceNonFragileABI = false,
1037 bool NullTerminate = true);
1040 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1041 ReturnValueSlot Return,
1042 QualType ResultType,
1047 const CallArgList &CallArgs,
1048 const ObjCMethodDecl *OMD,
1049 const ObjCInterfaceDecl *ClassReceiver,
1050 const ObjCCommonTypesHelper &ObjCTypes);
1052 /// EmitImageInfo - Emit the image info marker used to encode some module
1053 /// level information.
1054 void EmitImageInfo();
1057 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) :
1058 CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) { }
1060 bool isNonFragileABI() const {
1061 return ObjCABI == 2;
1064 ConstantAddress GenerateConstantString(const StringLiteral *SL) override;
1065 ConstantAddress GenerateConstantNSString(const StringLiteral *SL);
1067 llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1068 const ObjCContainerDecl *CD=nullptr) override;
1070 void GenerateProtocol(const ObjCProtocolDecl *PD) override;
1072 /// GetOrEmitProtocol - Get the protocol object for the given
1073 /// declaration, emitting it if necessary. The return value has type
1075 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
1077 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1078 /// object for the given declaration, emitting it if needed. These
1079 /// forward references will be filled in with empty bodies if no
1080 /// definition is seen. The return value has type ProtocolPtrTy.
1081 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1083 virtual llvm::Constant *getNSConstantStringClassRef() = 0;
1085 llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1086 const CGBlockInfo &blockInfo) override;
1087 llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1088 const CGBlockInfo &blockInfo) override;
1089 std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM,
1090 const CGBlockInfo &blockInfo) override;
1092 llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1093 QualType T) override;
1096 void fillRunSkipBlockVars(CodeGenModule &CGM, const CGBlockInfo &blockInfo);
1101 enum class MethodListType {
1102 CategoryInstanceMethods,
1103 CategoryClassMethods,
1106 ProtocolInstanceMethods,
1107 ProtocolClassMethods,
1108 OptionalProtocolInstanceMethods,
1109 OptionalProtocolClassMethods,
1112 /// A convenience class for splitting the methods of a protocol into
1113 /// the four interesting groups.
1114 class ProtocolMethodLists {
1117 RequiredInstanceMethods,
1118 RequiredClassMethods,
1119 OptionalInstanceMethods,
1120 OptionalClassMethods
1123 NumProtocolMethodLists = 4
1126 static MethodListType getMethodListKind(Kind kind) {
1128 case RequiredInstanceMethods:
1129 return MethodListType::ProtocolInstanceMethods;
1130 case RequiredClassMethods:
1131 return MethodListType::ProtocolClassMethods;
1132 case OptionalInstanceMethods:
1133 return MethodListType::OptionalProtocolInstanceMethods;
1134 case OptionalClassMethods:
1135 return MethodListType::OptionalProtocolClassMethods;
1137 llvm_unreachable("bad kind");
1140 SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists];
1142 static ProtocolMethodLists get(const ObjCProtocolDecl *PD) {
1143 ProtocolMethodLists result;
1145 for (auto MD : PD->methods()) {
1146 size_t index = (2 * size_t(MD->isOptional()))
1147 + (size_t(MD->isClassMethod()));
1148 result.Methods[index].push_back(MD);
1154 template <class Self>
1155 SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const {
1156 // In both ABIs, the method types list is parallel with the
1157 // concatenation of the methods arrays in the following order:
1160 // optional instance methods
1161 // optional class methods
1162 SmallVector<llvm::Constant*, 8> result;
1164 // Methods is already in the correct order for both ABIs.
1165 for (auto &list : Methods) {
1166 for (auto MD : list) {
1167 result.push_back(self->GetMethodVarType(MD, true));
1174 template <class Self>
1175 llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD,
1177 return self->emitMethodList(PD->getObjCRuntimeNameAsString(),
1178 getMethodListKind(kind), Methods[kind]);
1182 } // end anonymous namespace
1184 class CGObjCMac : public CGObjCCommonMac {
1186 friend ProtocolMethodLists;
1188 ObjCTypesHelper ObjCTypes;
1190 /// EmitModuleInfo - Another marker encoding module level
1192 void EmitModuleInfo();
1194 /// EmitModuleSymols - Emit module symbols, the list of defined
1195 /// classes and categories. The result has type SymtabPtrTy.
1196 llvm::Constant *EmitModuleSymbols();
1198 /// FinishModule - Write out global data structures at the end of
1199 /// processing a translation unit.
1200 void FinishModule();
1202 /// EmitClassExtension - Generate the class extension structure used
1203 /// to store the weak ivar layout and properties. The return value
1204 /// has type ClassExtensionPtrTy.
1205 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID,
1206 CharUnits instanceSize,
1207 bool hasMRCWeakIvars,
1210 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1211 /// for the given class.
1212 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1213 const ObjCInterfaceDecl *ID);
1215 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1216 IdentifierInfo *II);
1218 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1220 /// EmitSuperClassRef - Emits reference to class's main metadata class.
1221 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1223 /// EmitIvarList - Emit the ivar list for the given
1224 /// implementation. If ForClass is true the list of class ivars
1225 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1226 /// interface ivars will be emitted. The return value has type
1228 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1231 /// EmitMetaClass - Emit a forward reference to the class structure
1232 /// for the metaclass of the given interface. The return value has
1233 /// type ClassPtrTy.
1234 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1236 /// EmitMetaClass - Emit a class structure for the metaclass of the
1237 /// given implementation. The return value has type ClassPtrTy.
1238 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1239 llvm::Constant *Protocols,
1240 ArrayRef<const ObjCMethodDecl *> Methods);
1242 void emitMethodConstant(ConstantArrayBuilder &builder,
1243 const ObjCMethodDecl *MD);
1245 void emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
1246 const ObjCMethodDecl *MD);
1248 /// EmitMethodList - Emit the method list for the given
1249 /// implementation. The return value has type MethodListPtrTy.
1250 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1251 ArrayRef<const ObjCMethodDecl *> Methods);
1253 /// GetOrEmitProtocol - Get the protocol object for the given
1254 /// declaration, emitting it if necessary. The return value has type
1256 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1258 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1259 /// object for the given declaration, emitting it if needed. These
1260 /// forward references will be filled in with empty bodies if no
1261 /// definition is seen. The return value has type ProtocolPtrTy.
1262 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1264 /// EmitProtocolExtension - Generate the protocol extension
1265 /// structure used to store optional instance and class methods, and
1266 /// protocol properties. The return value has type
1267 /// ProtocolExtensionPtrTy.
1269 EmitProtocolExtension(const ObjCProtocolDecl *PD,
1270 const ProtocolMethodLists &methodLists);
1272 /// EmitProtocolList - Generate the list of referenced
1273 /// protocols. The return value has type ProtocolListPtrTy.
1274 llvm::Constant *EmitProtocolList(Twine Name,
1275 ObjCProtocolDecl::protocol_iterator begin,
1276 ObjCProtocolDecl::protocol_iterator end);
1278 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1279 /// for the given selector.
1280 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1281 Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1284 CGObjCMac(CodeGen::CodeGenModule &cgm);
1286 llvm::Constant *getNSConstantStringClassRef() override;
1288 llvm::Function *ModuleInitFunction() override;
1290 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1291 ReturnValueSlot Return,
1292 QualType ResultType,
1293 Selector Sel, llvm::Value *Receiver,
1294 const CallArgList &CallArgs,
1295 const ObjCInterfaceDecl *Class,
1296 const ObjCMethodDecl *Method) override;
1299 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1300 ReturnValueSlot Return, QualType ResultType,
1301 Selector Sel, const ObjCInterfaceDecl *Class,
1302 bool isCategoryImpl, llvm::Value *Receiver,
1303 bool IsClassMessage, const CallArgList &CallArgs,
1304 const ObjCMethodDecl *Method) override;
1306 llvm::Value *GetClass(CodeGenFunction &CGF,
1307 const ObjCInterfaceDecl *ID) override;
1309 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
1310 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
1312 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1314 llvm::Value *GetSelector(CodeGenFunction &CGF,
1315 const ObjCMethodDecl *Method) override;
1317 llvm::Constant *GetEHType(QualType T) override;
1319 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1321 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1323 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1325 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1326 const ObjCProtocolDecl *PD) override;
1328 llvm::Constant *GetPropertyGetFunction() override;
1329 llvm::Constant *GetPropertySetFunction() override;
1330 llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1331 bool copy) override;
1332 llvm::Constant *GetGetStructFunction() override;
1333 llvm::Constant *GetSetStructFunction() override;
1334 llvm::Constant *GetCppAtomicObjectGetFunction() override;
1335 llvm::Constant *GetCppAtomicObjectSetFunction() override;
1336 llvm::Constant *EnumerationMutationFunction() override;
1338 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1339 const ObjCAtTryStmt &S) override;
1340 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1341 const ObjCAtSynchronizedStmt &S) override;
1342 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1343 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1344 bool ClearInsertionPoint=true) override;
1345 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1346 Address AddrWeakObj) override;
1347 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1348 llvm::Value *src, Address dst) override;
1349 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1350 llvm::Value *src, Address dest,
1351 bool threadlocal = false) override;
1352 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1353 llvm::Value *src, Address dest,
1354 llvm::Value *ivarOffset) override;
1355 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1356 llvm::Value *src, Address dest) override;
1357 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1358 Address dest, Address src,
1359 llvm::Value *size) override;
1361 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1362 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1363 unsigned CVRQualifiers) override;
1364 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1365 const ObjCInterfaceDecl *Interface,
1366 const ObjCIvarDecl *Ivar) override;
1369 class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1371 friend ProtocolMethodLists;
1372 ObjCNonFragileABITypesHelper ObjCTypes;
1373 llvm::GlobalVariable* ObjCEmptyCacheVar;
1374 llvm::Constant* ObjCEmptyVtableVar;
1376 /// SuperClassReferences - uniqued super class references.
1377 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1379 /// MetaClassReferences - uniqued meta class references.
1380 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1382 /// EHTypeReferences - uniqued class ehtype references.
1383 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1385 /// VTableDispatchMethods - List of methods for which we generate
1386 /// vtable-based message dispatch.
1387 llvm::DenseSet<Selector> VTableDispatchMethods;
1389 /// DefinedMetaClasses - List of defined meta-classes.
1390 std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1392 /// isVTableDispatchedSelector - Returns true if SEL is a
1393 /// vtable-based selector.
1394 bool isVTableDispatchedSelector(Selector Sel);
1396 /// FinishNonFragileABIModule - Write out global data structures at the end of
1397 /// processing a translation unit.
1398 void FinishNonFragileABIModule();
1400 /// AddModuleClassList - Add the given list of class pointers to the
1401 /// module with the provided symbol and section names.
1402 void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container,
1403 StringRef SymbolName, StringRef SectionName);
1405 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1406 unsigned InstanceStart,
1407 unsigned InstanceSize,
1408 const ObjCImplementationDecl *ID);
1409 llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI,
1411 llvm::Constant *IsAGV,
1412 llvm::Constant *SuperClassGV,
1413 llvm::Constant *ClassRoGV,
1414 bool HiddenVisibility);
1416 void emitMethodConstant(ConstantArrayBuilder &builder,
1417 const ObjCMethodDecl *MD,
1420 /// Emit the method list for the given implementation. The return value
1421 /// has type MethodListnfABITy.
1422 llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1423 ArrayRef<const ObjCMethodDecl *> Methods);
1425 /// EmitIvarList - Emit the ivar list for the given
1426 /// implementation. If ForClass is true the list of class ivars
1427 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1428 /// interface ivars will be emitted. The return value has type
1429 /// IvarListnfABIPtrTy.
1430 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
1432 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1433 const ObjCIvarDecl *Ivar,
1434 unsigned long int offset);
1436 /// GetOrEmitProtocol - Get the protocol object for the given
1437 /// declaration, emitting it if necessary. The return value has type
1439 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1441 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1442 /// object for the given declaration, emitting it if needed. These
1443 /// forward references will be filled in with empty bodies if no
1444 /// definition is seen. The return value has type ProtocolPtrTy.
1445 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1447 /// EmitProtocolList - Generate the list of referenced
1448 /// protocols. The return value has type ProtocolListPtrTy.
1449 llvm::Constant *EmitProtocolList(Twine Name,
1450 ObjCProtocolDecl::protocol_iterator begin,
1451 ObjCProtocolDecl::protocol_iterator end);
1453 CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1454 ReturnValueSlot Return,
1455 QualType ResultType,
1457 llvm::Value *Receiver,
1460 const CallArgList &CallArgs,
1461 const ObjCMethodDecl *Method);
1463 /// GetClassGlobal - Return the global variable for the Objective-C
1464 /// class of the given name.
1465 llvm::Constant *GetClassGlobal(StringRef Name,
1466 ForDefinition_t IsForDefinition,
1467 bool Weak = false, bool DLLImport = false);
1468 llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID,
1470 ForDefinition_t isForDefinition);
1472 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1473 /// for the given class reference.
1474 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1475 const ObjCInterfaceDecl *ID);
1477 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1479 const ObjCInterfaceDecl *ID);
1481 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1483 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1484 /// for the given super class reference.
1485 llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1486 const ObjCInterfaceDecl *ID);
1488 /// EmitMetaClassRef - Return a Value * of the address of _class_t
1490 llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1491 const ObjCInterfaceDecl *ID, bool Weak);
1493 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1496 llvm::GlobalVariable * ObjCIvarOffsetVariable(
1497 const ObjCInterfaceDecl *ID,
1498 const ObjCIvarDecl *Ivar);
1500 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1501 /// for the given selector.
1502 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1503 Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1505 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1506 /// interface. The return value has type EHTypePtrTy.
1507 llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1508 ForDefinition_t IsForDefinition);
1510 StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }
1512 StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; }
1514 void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1515 uint32_t &InstanceStart,
1516 uint32_t &InstanceSize);
1518 // Shamelessly stolen from Analysis/CFRefCount.cpp
1519 Selector GetNullarySelector(const char* name) const {
1520 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1521 return CGM.getContext().Selectors.getSelector(0, &II);
1524 Selector GetUnarySelector(const char* name) const {
1525 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1526 return CGM.getContext().Selectors.getSelector(1, &II);
1529 /// ImplementationIsNonLazy - Check whether the given category or
1530 /// class implementation is "non-lazy".
1531 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1533 bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1534 const ObjCIvarDecl *IV) {
1535 // Annotate the load as an invariant load iff inside an instance method
1536 // and ivar belongs to instance method's class and one of its super class.
1537 // This check is needed because the ivar offset is a lazily
1538 // initialised value that may depend on objc_msgSend to perform a fixup on
1539 // the first message dispatch.
1541 // An additional opportunity to mark the load as invariant arises when the
1542 // base of the ivar access is a parameter to an Objective C method.
1543 // However, because the parameters are not available in the current
1544 // interface, we cannot perform this check.
1545 if (const ObjCMethodDecl *MD =
1546 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1547 if (MD->isInstanceMethod())
1548 if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1549 return IV->getContainingInterface()->isSuperClassOf(ID);
1554 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1556 llvm::Constant *getNSConstantStringClassRef() override;
1558 llvm::Function *ModuleInitFunction() override;
1560 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1561 ReturnValueSlot Return,
1562 QualType ResultType, Selector Sel,
1563 llvm::Value *Receiver,
1564 const CallArgList &CallArgs,
1565 const ObjCInterfaceDecl *Class,
1566 const ObjCMethodDecl *Method) override;
1569 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1570 ReturnValueSlot Return, QualType ResultType,
1571 Selector Sel, const ObjCInterfaceDecl *Class,
1572 bool isCategoryImpl, llvm::Value *Receiver,
1573 bool IsClassMessage, const CallArgList &CallArgs,
1574 const ObjCMethodDecl *Method) override;
1576 llvm::Value *GetClass(CodeGenFunction &CGF,
1577 const ObjCInterfaceDecl *ID) override;
1579 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override
1580 { return EmitSelector(CGF, Sel); }
1581 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
1582 { return EmitSelectorAddr(CGF, Sel); }
1584 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1586 llvm::Value *GetSelector(CodeGenFunction &CGF,
1587 const ObjCMethodDecl *Method) override
1588 { return EmitSelector(CGF, Method->getSelector()); }
1590 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1592 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1594 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1596 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1597 const ObjCProtocolDecl *PD) override;
1599 llvm::Constant *GetEHType(QualType T) override;
1601 llvm::Constant *GetPropertyGetFunction() override {
1602 return ObjCTypes.getGetPropertyFn();
1604 llvm::Constant *GetPropertySetFunction() override {
1605 return ObjCTypes.getSetPropertyFn();
1608 llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1609 bool copy) override {
1610 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1613 llvm::Constant *GetSetStructFunction() override {
1614 return ObjCTypes.getCopyStructFn();
1617 llvm::Constant *GetGetStructFunction() override {
1618 return ObjCTypes.getCopyStructFn();
1621 llvm::Constant *GetCppAtomicObjectSetFunction() override {
1622 return ObjCTypes.getCppAtomicObjectFunction();
1625 llvm::Constant *GetCppAtomicObjectGetFunction() override {
1626 return ObjCTypes.getCppAtomicObjectFunction();
1629 llvm::Constant *EnumerationMutationFunction() override {
1630 return ObjCTypes.getEnumerationMutationFn();
1633 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1634 const ObjCAtTryStmt &S) override;
1635 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1636 const ObjCAtSynchronizedStmt &S) override;
1637 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1638 bool ClearInsertionPoint=true) override;
1639 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1640 Address AddrWeakObj) override;
1641 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1642 llvm::Value *src, Address edst) override;
1643 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1644 llvm::Value *src, Address dest,
1645 bool threadlocal = false) override;
1646 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1647 llvm::Value *src, Address dest,
1648 llvm::Value *ivarOffset) override;
1649 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1650 llvm::Value *src, Address dest) override;
1651 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1652 Address dest, Address src,
1653 llvm::Value *size) override;
1654 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1655 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1656 unsigned CVRQualifiers) override;
1657 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1658 const ObjCInterfaceDecl *Interface,
1659 const ObjCIvarDecl *Ivar) override;
1662 /// A helper class for performing the null-initialization of a return
1664 struct NullReturnState {
1665 llvm::BasicBlock *NullBB;
1666 NullReturnState() : NullBB(nullptr) {}
1668 /// Perform a null-check of the given receiver.
1669 void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1670 // Make blocks for the null-receiver and call edges.
1671 NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1672 llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1674 // Check for a null receiver and, if there is one, jump to the
1675 // null-receiver block. There's no point in trying to avoid it:
1676 // we're always going to put *something* there, because otherwise
1677 // we shouldn't have done this null-check in the first place.
1678 llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1679 CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1681 // Otherwise, start performing the call.
1682 CGF.EmitBlock(callBB);
1685 /// Complete the null-return operation. It is valid to call this
1686 /// regardless of whether 'init' has been called.
1687 RValue complete(CodeGenFunction &CGF,
1688 ReturnValueSlot returnSlot,
1690 QualType resultType,
1691 const CallArgList &CallArgs,
1692 const ObjCMethodDecl *Method) {
1693 // If we never had to do a null-check, just use the raw result.
1694 if (!NullBB) return result;
1696 // The continuation block. This will be left null if we don't have an
1697 // IP, which can happen if the method we're calling is marked noreturn.
1698 llvm::BasicBlock *contBB = nullptr;
1700 // Finish the call path.
1701 llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1703 contBB = CGF.createBasicBlock("msgSend.cont");
1704 CGF.Builder.CreateBr(contBB);
1707 // Okay, start emitting the null-receiver block.
1708 CGF.EmitBlock(NullBB);
1710 // Release any consumed arguments we've got.
1712 CallArgList::const_iterator I = CallArgs.begin();
1713 for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
1714 e = Method->param_end(); i != e; ++i, ++I) {
1715 const ParmVarDecl *ParamDecl = (*i);
1716 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1717 RValue RV = I->getRValue(CGF);
1718 assert(RV.isScalar() &&
1719 "NullReturnState::complete - arg not on object");
1720 CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime);
1725 // The phi code below assumes that we haven't needed any control flow yet.
1726 assert(CGF.Builder.GetInsertBlock() == NullBB);
1728 // If we've got a void return, just jump to the continuation block.
1729 if (result.isScalar() && resultType->isVoidType()) {
1730 // No jumps required if the message-send was noreturn.
1731 if (contBB) CGF.EmitBlock(contBB);
1735 // If we've got a scalar return, build a phi.
1736 if (result.isScalar()) {
1737 // Derive the null-initialization value.
1738 llvm::Constant *null = CGF.CGM.EmitNullConstant(resultType);
1740 // If no join is necessary, just flow out.
1741 if (!contBB) return RValue::get(null);
1743 // Otherwise, build a phi.
1744 CGF.EmitBlock(contBB);
1745 llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1746 phi->addIncoming(result.getScalarVal(), callBB);
1747 phi->addIncoming(null, NullBB);
1748 return RValue::get(phi);
1751 // If we've got an aggregate return, null the buffer out.
1752 // FIXME: maybe we should be doing things differently for all the
1753 // cases where the ABI has us returning (1) non-agg values in
1754 // memory or (2) agg values in registers.
1755 if (result.isAggregate()) {
1756 assert(result.isAggregate() && "null init of non-aggregate result?");
1757 if (!returnSlot.isUnused())
1758 CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
1759 if (contBB) CGF.EmitBlock(contBB);
1764 CGF.EmitBlock(contBB);
1765 CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1767 // Find the scalar type and its zero value.
1768 llvm::Type *scalarTy = callResult.first->getType();
1769 llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1771 // Build phis for both coordinates.
1772 llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1773 real->addIncoming(callResult.first, callBB);
1774 real->addIncoming(scalarZero, NullBB);
1775 llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1776 imag->addIncoming(callResult.second, callBB);
1777 imag->addIncoming(scalarZero, NullBB);
1778 return RValue::getComplex(real, imag);
1782 } // end anonymous namespace
1784 /* *** Helper Functions *** */
1786 /// getConstantGEP() - Help routine to construct simple GEPs.
1787 static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1788 llvm::GlobalVariable *C, unsigned idx0,
1790 llvm::Value *Idxs[] = {
1791 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1792 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1794 return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1797 /// hasObjCExceptionAttribute - Return true if this class or any super
1798 /// class has the __objc_exception__ attribute.
1799 static bool hasObjCExceptionAttribute(ASTContext &Context,
1800 const ObjCInterfaceDecl *OID) {
1801 if (OID->hasAttr<ObjCExceptionAttr>())
1803 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1804 return hasObjCExceptionAttribute(Context, Super);
1808 /* *** CGObjCMac Public Interface *** */
1810 CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1816 /// GetClass - Return a reference to the class for the given interface
1818 llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1819 const ObjCInterfaceDecl *ID) {
1820 return EmitClassRef(CGF, ID);
1823 /// GetSelector - Return the pointer to the unique'd string for this selector.
1824 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1825 return EmitSelector(CGF, Sel);
1827 Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1828 return EmitSelectorAddr(CGF, Sel);
1830 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1832 return EmitSelector(CGF, Method->getSelector());
1835 llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1836 if (T->isObjCIdType() ||
1837 T->isObjCQualifiedIdType()) {
1838 return CGM.GetAddrOfRTTIDescriptor(
1839 CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1841 if (T->isObjCClassType() ||
1842 T->isObjCQualifiedClassType()) {
1843 return CGM.GetAddrOfRTTIDescriptor(
1844 CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1846 if (T->isObjCObjectPointerType())
1847 return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true);
1849 llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1852 /// Generate a constant CFString object.
1854 struct __builtin_CFString {
1855 const int *isa; // point to __CFConstantStringClassReference
1862 /// or Generate a constant NSString object.
1864 struct __builtin_NSString {
1865 const int *isa; // point to __NSConstantStringClassReference
1867 unsigned int length;
1872 CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) {
1873 return (!CGM.getLangOpts().NoConstantCFStrings
1874 ? CGM.GetAddrOfConstantCFString(SL)
1875 : GenerateConstantNSString(SL));
1878 static llvm::StringMapEntry<llvm::GlobalVariable *> &
1879 GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
1880 const StringLiteral *Literal, unsigned &StringLength) {
1881 StringRef String = Literal->getString();
1882 StringLength = String.size();
1883 return *Map.insert(std::make_pair(String, nullptr)).first;
1886 llvm::Constant *CGObjCMac::getNSConstantStringClassRef() {
1887 if (llvm::Value *V = ConstantStringClassRef)
1888 return cast<llvm::Constant>(V);
1890 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1892 StringClass.empty() ? "_NSConstantStringClassReference"
1893 : "_" + StringClass + "ClassReference";
1895 llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
1896 auto GV = CGM.CreateRuntimeVariable(PTy, str);
1897 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1898 ConstantStringClassRef = V;
1902 llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() {
1903 if (llvm::Value *V = ConstantStringClassRef)
1904 return cast<llvm::Constant>(V);
1906 auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1908 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
1909 : "OBJC_CLASS_$_" + StringClass;
1910 auto GV = GetClassGlobal(str, NotForDefinition);
1912 // Make sure the result is of the correct type.
1913 auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1915 ConstantStringClassRef = V;
1920 CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) {
1921 unsigned StringLength = 0;
1922 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
1923 GetConstantStringEntry(NSConstantStringMap, Literal, StringLength);
1925 if (auto *C = Entry.second)
1926 return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
1928 // If we don't already have it, get _NSConstantStringClassReference.
1929 llvm::Constant *Class = getNSConstantStringClassRef();
1931 // If we don't already have it, construct the type for a constant NSString.
1932 if (!NSConstantStringType) {
1933 NSConstantStringType =
1934 llvm::StructType::create({
1935 CGM.Int32Ty->getPointerTo(),
1938 }, "struct.__builtin_NSString");
1941 ConstantInitBuilder Builder(CGM);
1942 auto Fields = Builder.beginStruct(NSConstantStringType);
1949 llvm::ConstantDataArray::getString(VMContext, Entry.first());
1951 llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage;
1952 bool isConstant = !CGM.getLangOpts().WritableStrings;
1954 auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant,
1955 Linkage, C, ".str");
1956 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1957 // Don't enforce the target's minimum global alignment, since the only use
1958 // of the string is via this class initializer.
1959 GV->setAlignment(1);
1960 Fields.addBitCast(GV, CGM.Int8PtrTy);
1963 Fields.addInt(CGM.IntTy, StringLength);
1966 CharUnits Alignment = CGM.getPointerAlign();
1967 GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
1969 llvm::GlobalVariable::PrivateLinkage);
1970 const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
1971 const char *NSStringNonFragileABISection =
1972 "__DATA,__objc_stringobj,regular,no_dead_strip";
1973 // FIXME. Fix section.
1974 GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
1975 ? NSStringNonFragileABISection
1979 return ConstantAddress(GV, Alignment);
1983 kCFTaggedObjectID_Integer = (1 << 1) + 1
1986 /// Generates a message send where the super is the receiver. This is
1987 /// a message send to self with special delivery semantics indicating
1988 /// which class's method should be called.
1990 CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1991 ReturnValueSlot Return,
1992 QualType ResultType,
1994 const ObjCInterfaceDecl *Class,
1995 bool isCategoryImpl,
1996 llvm::Value *Receiver,
1997 bool IsClassMessage,
1998 const CodeGen::CallArgList &CallArgs,
1999 const ObjCMethodDecl *Method) {
2000 // Create and init a super structure; this is a (receiver, class)
2001 // pair we will pass to objc_msgSendSuper.
2003 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
2005 llvm::Value *ReceiverAsObject =
2006 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
2007 CGF.Builder.CreateStore(
2009 CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
2011 // If this is a class message the metaclass is passed as the target.
2012 llvm::Value *Target;
2013 if (IsClassMessage) {
2014 if (isCategoryImpl) {
2015 // Message sent to 'super' in a class method defined in a category
2016 // implementation requires an odd treatment.
2017 // If we are in a class method, we must retrieve the
2018 // _metaclass_ for the current class, pointed at by
2019 // the class's "isa" pointer. The following assumes that
2020 // isa" is the first ivar in a class (which it must be).
2021 Target = EmitClassRef(CGF, Class->getSuperClass());
2022 Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
2023 Target = CGF.Builder.CreateAlignedLoad(Target, CGF.getPointerAlign());
2025 llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
2026 llvm::Value *SuperPtr =
2027 CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
2028 llvm::Value *Super =
2029 CGF.Builder.CreateAlignedLoad(SuperPtr, CGF.getPointerAlign());
2032 } else if (isCategoryImpl)
2033 Target = EmitClassRef(CGF, Class->getSuperClass());
2035 llvm::Value *ClassPtr = EmitSuperClassRef(Class);
2036 ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
2037 Target = CGF.Builder.CreateAlignedLoad(ClassPtr, CGF.getPointerAlign());
2039 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
2041 llvm::Type *ClassTy =
2042 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
2043 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
2044 CGF.Builder.CreateStore(Target,
2045 CGF.Builder.CreateStructGEP(ObjCSuper, 1, CGF.getPointerSize()));
2046 return EmitMessageSend(CGF, Return, ResultType,
2047 EmitSelector(CGF, Sel),
2048 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
2049 true, CallArgs, Method, Class, ObjCTypes);
2052 /// Generate code for a message send expression.
2053 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
2054 ReturnValueSlot Return,
2055 QualType ResultType,
2057 llvm::Value *Receiver,
2058 const CallArgList &CallArgs,
2059 const ObjCInterfaceDecl *Class,
2060 const ObjCMethodDecl *Method) {
2061 return EmitMessageSend(CGF, Return, ResultType,
2062 EmitSelector(CGF, Sel),
2063 Receiver, CGF.getContext().getObjCIdType(),
2064 false, CallArgs, Method, Class, ObjCTypes);
2067 static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
2069 if (ID->isWeakImported())
2071 } while ((ID = ID->getSuperClass()));
2077 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
2078 ReturnValueSlot Return,
2079 QualType ResultType,
2084 const CallArgList &CallArgs,
2085 const ObjCMethodDecl *Method,
2086 const ObjCInterfaceDecl *ClassReceiver,
2087 const ObjCCommonTypesHelper &ObjCTypes) {
2088 CallArgList ActualArgs;
2090 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
2091 ActualArgs.add(RValue::get(Arg0), Arg0Ty);
2092 ActualArgs.add(RValue::get(Sel), CGF.getContext().getObjCSelType());
2093 ActualArgs.addFrom(CallArgs);
2095 // If we're calling a method, use the formal signature.
2096 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2099 assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==
2100 CGM.getContext().getCanonicalType(ResultType) &&
2101 "Result type mismatch!");
2103 bool ReceiverCanBeNull = true;
2105 // Super dispatch assumes that self is non-null; even the messenger
2106 // doesn't have a null check internally.
2108 ReceiverCanBeNull = false;
2110 // If this is a direct dispatch of a class method, check whether the class,
2111 // or anything in its hierarchy, was weak-linked.
2112 } else if (ClassReceiver && Method && Method->isClassMethod()) {
2113 ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);
2115 // If we're emitting a method, and self is const (meaning just ARC, for now),
2116 // and the receiver is a load of self, then self is a valid object.
2117 } else if (auto CurMethod =
2118 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
2119 auto Self = CurMethod->getSelfDecl();
2120 if (Self->getType().isConstQualified()) {
2121 if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {
2122 llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer();
2123 if (SelfAddr == LI->getPointerOperand()) {
2124 ReceiverCanBeNull = false;
2130 bool RequiresNullCheck = false;
2132 llvm::Constant *Fn = nullptr;
2133 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
2134 if (ReceiverCanBeNull) RequiresNullCheck = true;
2135 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
2136 : ObjCTypes.getSendStretFn(IsSuper);
2137 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
2138 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
2139 : ObjCTypes.getSendFpretFn(IsSuper);
2140 } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
2141 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
2142 : ObjCTypes.getSendFp2retFn(IsSuper);
2144 // arm64 uses objc_msgSend for stret methods and yet null receiver check
2145 // must be made for it.
2146 if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
2147 RequiresNullCheck = true;
2148 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
2149 : ObjCTypes.getSendFn(IsSuper);
2152 // We don't need to emit a null check to zero out an indirect result if the
2153 // result is ignored.
2154 if (Return.isUnused())
2155 RequiresNullCheck = false;
2157 // Emit a null-check if there's a consumed argument other than the receiver.
2158 if (!RequiresNullCheck && CGM.getLangOpts().ObjCAutoRefCount && Method) {
2159 for (const auto *ParamDecl : Method->parameters()) {
2160 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
2161 RequiresNullCheck = true;
2167 NullReturnState nullReturn;
2168 if (RequiresNullCheck) {
2169 nullReturn.init(CGF, Arg0);
2172 llvm::Instruction *CallSite;
2173 Fn = llvm::ConstantExpr::getBitCast(Fn, MSI.MessengerType);
2174 CGCallee Callee = CGCallee::forDirect(Fn);
2175 RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
2178 // Mark the call as noreturn if the method is marked noreturn and the
2179 // receiver cannot be null.
2180 if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) {
2181 llvm::CallSite(CallSite).setDoesNotReturn();
2184 return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs,
2185 RequiresNullCheck ? Method : nullptr);
2188 static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT,
2189 bool pointee = false) {
2190 // Note that GC qualification applies recursively to C pointer types
2191 // that aren't otherwise decorated. This is weird, but it's probably
2192 // an intentional workaround to the unreliable placement of GC qualifiers.
2193 if (FQT.isObjCGCStrong())
2194 return Qualifiers::Strong;
2196 if (FQT.isObjCGCWeak())
2197 return Qualifiers::Weak;
2199 if (auto ownership = FQT.getObjCLifetime()) {
2200 // Ownership does not apply recursively to C pointer types.
2201 if (pointee) return Qualifiers::GCNone;
2202 switch (ownership) {
2203 case Qualifiers::OCL_Weak: return Qualifiers::Weak;
2204 case Qualifiers::OCL_Strong: return Qualifiers::Strong;
2205 case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone;
2206 case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?");
2207 case Qualifiers::OCL_None: llvm_unreachable("known nonzero");
2209 llvm_unreachable("bad objc ownership");
2212 // Treat unqualified retainable pointers as strong.
2213 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2214 return Qualifiers::Strong;
2216 // Walk into C pointer types, but only in GC.
2217 if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
2218 if (const PointerType *PT = FQT->getAs<PointerType>())
2219 return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
2222 return Qualifiers::GCNone;
2228 uint64_t SizeInWords;
2229 IvarInfo(CharUnits offset, uint64_t sizeInWords)
2230 : Offset(offset), SizeInWords(sizeInWords) {}
2232 // Allow sorting based on byte pos.
2233 bool operator<(const IvarInfo &other) const {
2234 return Offset < other.Offset;
2238 /// A helper class for building GC layout strings.
2239 class IvarLayoutBuilder {
2242 /// The start of the layout. Offsets will be relative to this value,
2243 /// and entries less than this value will be silently discarded.
2244 CharUnits InstanceBegin;
2246 /// The end of the layout. Offsets will never exceed this value.
2247 CharUnits InstanceEnd;
2249 /// Whether we're generating the strong layout or the weak layout.
2250 bool ForStrongLayout;
2252 /// Whether the offsets in IvarsInfo might be out-of-order.
2253 bool IsDisordered = false;
2255 llvm::SmallVector<IvarInfo, 8> IvarsInfo;
2258 IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2259 CharUnits instanceEnd, bool forStrongLayout)
2260 : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
2261 ForStrongLayout(forStrongLayout) {
2264 void visitRecord(const RecordType *RT, CharUnits offset);
2266 template <class Iterator, class GetOffsetFn>
2267 void visitAggregate(Iterator begin, Iterator end,
2268 CharUnits aggrOffset,
2269 const GetOffsetFn &getOffset);
2271 void visitField(const FieldDecl *field, CharUnits offset);
2273 /// Add the layout of a block implementation.
2274 void visitBlock(const CGBlockInfo &blockInfo);
2276 /// Is there any information for an interesting bitmap?
2277 bool hasBitmapData() const { return !IvarsInfo.empty(); }
2279 llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
2280 llvm::SmallVectorImpl<unsigned char> &buffer);
2282 static void dump(ArrayRef<unsigned char> buffer) {
2283 const unsigned char *s = buffer.data();
2284 for (unsigned i = 0, e = buffer.size(); i < e; i++)
2286 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2288 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
2292 } // end anonymous namespace
2294 llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
2295 const CGBlockInfo &blockInfo) {
2297 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2298 if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
2301 IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2302 /*for strong layout*/ true);
2304 builder.visitBlock(blockInfo);
2306 if (!builder.hasBitmapData())
2309 llvm::SmallVector<unsigned char, 32> buffer;
2310 llvm::Constant *C = builder.buildBitmap(*this, buffer);
2311 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
2312 printf("\n block variable layout for block: ");
2313 builder.dump(buffer);
2319 void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
2320 // __isa is the first field in block descriptor and must assume by runtime's
2321 // convention that it is GC'able.
2322 IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2324 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2326 // Ignore the optional 'this' capture: C++ objects are not assumed
2329 CharUnits lastFieldOffset;
2331 // Walk the captured variables.
2332 for (const auto &CI : blockDecl->captures()) {
2333 const VarDecl *variable = CI.getVariable();
2334 QualType type = variable->getType();
2336 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2338 // Ignore constant captures.
2339 if (capture.isConstant()) continue;
2341 CharUnits fieldOffset = capture.getOffset();
2343 // Block fields are not necessarily ordered; if we detect that we're
2344 // adding them out-of-order, make sure we sort later.
2345 if (fieldOffset < lastFieldOffset)
2346 IsDisordered = true;
2347 lastFieldOffset = fieldOffset;
2349 // __block variables are passed by their descriptor address.
2351 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2355 assert(!type->isArrayType() && "array variable should not be caught");
2356 if (const RecordType *record = type->getAs<RecordType>()) {
2357 visitRecord(record, fieldOffset);
2361 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);
2363 if (GCAttr == Qualifiers::Strong) {
2364 assert(CGM.getContext().getTypeSize(type)
2365 == CGM.getTarget().getPointerWidth(0));
2366 IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2371 /// getBlockCaptureLifetime - This routine returns life time of the captured
2372 /// block variable for the purpose of block layout meta-data generation. FQT is
2373 /// the type of the variable captured in the block.
2374 Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2376 // If it has an ownership qualifier, we're done.
2377 if (auto lifetime = FQT.getObjCLifetime())
2380 // If it doesn't, and this is ARC, it has no ownership.
2381 if (CGM.getLangOpts().ObjCAutoRefCount)
2382 return Qualifiers::OCL_None;
2384 // In MRC, retainable pointers are owned by non-__block variables.
2385 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2386 return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong;
2388 return Qualifiers::OCL_None;
2391 void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2392 Qualifiers::ObjCLifetime LifeTime,
2393 CharUnits FieldOffset,
2394 CharUnits FieldSize) {
2395 // __block variables are passed by their descriptor address.
2397 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2399 else if (LifeTime == Qualifiers::OCL_Strong)
2400 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2402 else if (LifeTime == Qualifiers::OCL_Weak)
2403 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2405 else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2406 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2409 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2414 void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2415 const RecordDecl *RD,
2416 ArrayRef<const FieldDecl*> RecFields,
2417 CharUnits BytePos, bool &HasUnion,
2419 bool IsUnion = (RD && RD->isUnion());
2420 CharUnits MaxUnionSize = CharUnits::Zero();
2421 const FieldDecl *MaxField = nullptr;
2422 const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2423 CharUnits MaxFieldOffset = CharUnits::Zero();
2424 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2426 if (RecFields.empty())
2428 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2430 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
2431 const FieldDecl *Field = RecFields[i];
2432 // Note that 'i' here is actually the field index inside RD of Field,
2433 // although this dependency is hidden.
2434 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2435 CharUnits FieldOffset =
2436 CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i));
2438 // Skip over unnamed or bitfields
2439 if (!Field->getIdentifier() || Field->isBitField()) {
2440 LastFieldBitfieldOrUnnamed = Field;
2441 LastBitfieldOrUnnamedOffset = FieldOffset;
2445 LastFieldBitfieldOrUnnamed = nullptr;
2446 QualType FQT = Field->getType();
2447 if (FQT->isRecordType() || FQT->isUnionType()) {
2448 if (FQT->isUnionType())
2451 BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
2452 BytePos + FieldOffset, HasUnion);
2456 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2457 const ConstantArrayType *CArray =
2458 dyn_cast_or_null<ConstantArrayType>(Array);
2459 uint64_t ElCount = CArray->getSize().getZExtValue();
2460 assert(CArray && "only array with known element size is supported");
2461 FQT = CArray->getElementType();
2462 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2463 const ConstantArrayType *CArray =
2464 dyn_cast_or_null<ConstantArrayType>(Array);
2465 ElCount *= CArray->getSize().getZExtValue();
2466 FQT = CArray->getElementType();
2468 if (FQT->isRecordType() && ElCount) {
2469 int OldIndex = RunSkipBlockVars.size() - 1;
2470 const RecordType *RT = FQT->getAs<RecordType>();
2471 BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset,
2474 // Replicate layout information for each array element. Note that
2475 // one element is already done.
2477 for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2478 CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2479 for (int i = OldIndex+1; i <= FirstIndex; ++i)
2480 RunSkipBlockVars.push_back(
2481 RUN_SKIP(RunSkipBlockVars[i].opcode,
2482 RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2483 RunSkipBlockVars[i].block_var_size));
2488 CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2490 CharUnits UnionIvarSize = FieldSize;
2491 if (UnionIvarSize > MaxUnionSize) {
2492 MaxUnionSize = UnionIvarSize;
2494 MaxFieldOffset = FieldOffset;
2497 UpdateRunSkipBlockVars(false,
2498 getBlockCaptureLifetime(FQT, ByrefLayout),
2499 BytePos + FieldOffset,
2504 if (LastFieldBitfieldOrUnnamed) {
2505 if (LastFieldBitfieldOrUnnamed->isBitField()) {
2506 // Last field was a bitfield. Must update the info.
2507 uint64_t BitFieldSize
2508 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2509 unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2510 ((BitFieldSize % ByteSizeInBits) != 0);
2511 CharUnits Size = CharUnits::fromQuantity(UnsSize);
2512 Size += LastBitfieldOrUnnamedOffset;
2513 UpdateRunSkipBlockVars(false,
2514 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2516 BytePos + LastBitfieldOrUnnamedOffset,
2519 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2520 // Last field was unnamed. Must update skip info.
2522 = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2523 UpdateRunSkipBlockVars(false,
2524 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2526 BytePos + LastBitfieldOrUnnamedOffset,
2532 UpdateRunSkipBlockVars(false,
2533 getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2534 BytePos + MaxFieldOffset,
2538 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2542 const RecordDecl *RD = RT->getDecl();
2543 SmallVector<const FieldDecl*, 16> Fields(RD->fields());
2544 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2545 const llvm::StructLayout *RecLayout =
2546 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2548 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2551 /// InlineLayoutInstruction - This routine produce an inline instruction for the
2552 /// block variable layout if it can. If not, it returns 0. Rules are as follow:
2553 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2554 /// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2555 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2556 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2557 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2558 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2559 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2560 uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2561 SmallVectorImpl<unsigned char> &Layout) {
2562 uint64_t Result = 0;
2563 if (Layout.size() <= 3) {
2564 unsigned size = Layout.size();
2565 unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2567 enum BLOCK_LAYOUT_OPCODE opcode ;
2571 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2572 if (opcode == BLOCK_LAYOUT_STRONG)
2573 strong_word_count = (inst & 0xF)+1;
2577 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2578 if (opcode == BLOCK_LAYOUT_BYREF)
2579 byref_word_count = (inst & 0xF)+1;
2583 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2584 if (opcode == BLOCK_LAYOUT_WEAK)
2585 weak_word_count = (inst & 0xF)+1;
2592 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2593 if (opcode == BLOCK_LAYOUT_STRONG) {
2594 strong_word_count = (inst & 0xF)+1;
2596 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2597 if (opcode == BLOCK_LAYOUT_BYREF)
2598 byref_word_count = (inst & 0xF)+1;
2599 else if (opcode == BLOCK_LAYOUT_WEAK)
2600 weak_word_count = (inst & 0xF)+1;
2604 else if (opcode == BLOCK_LAYOUT_BYREF) {
2605 byref_word_count = (inst & 0xF)+1;
2607 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2608 if (opcode == BLOCK_LAYOUT_WEAK)
2609 weak_word_count = (inst & 0xF)+1;
2619 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2620 if (opcode == BLOCK_LAYOUT_STRONG)
2621 strong_word_count = (inst & 0xF)+1;
2622 else if (opcode == BLOCK_LAYOUT_BYREF)
2623 byref_word_count = (inst & 0xF)+1;
2624 else if (opcode == BLOCK_LAYOUT_WEAK)
2625 weak_word_count = (inst & 0xF)+1;
2634 // Cannot inline when any of the word counts is 15. Because this is one less
2635 // than the actual work count (so 15 means 16 actual word counts),
2636 // and we can only display 0 thru 15 word counts.
2637 if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2641 (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2643 if (size == count) {
2644 if (strong_word_count)
2645 Result = strong_word_count;
2647 if (byref_word_count)
2648 Result += byref_word_count;
2650 if (weak_word_count)
2651 Result += weak_word_count;
2657 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2658 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2659 if (RunSkipBlockVars.empty())
2661 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2662 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2663 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2665 // Sort on byte position; captures might not be allocated in order,
2666 // and unions can do funny things.
2667 llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2668 SmallVector<unsigned char, 16> Layout;
2670 unsigned size = RunSkipBlockVars.size();
2671 for (unsigned i = 0; i < size; i++) {
2672 enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2673 CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2674 CharUnits end_byte_pos = start_byte_pos;
2677 if (opcode == RunSkipBlockVars[j].opcode) {
2678 end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2684 CharUnits size_in_bytes =
2685 end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2688 RunSkipBlockVars[j].block_var_bytepos -
2689 RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2690 size_in_bytes += gap;
2692 CharUnits residue_in_bytes = CharUnits::Zero();
2693 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2694 residue_in_bytes = size_in_bytes % WordSizeInBytes;
2695 size_in_bytes -= residue_in_bytes;
2696 opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2699 unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2700 while (size_in_words >= 16) {
2701 // Note that value in imm. is one less that the actual
2702 // value. So, 0xf means 16 words follow!
2703 unsigned char inst = (opcode << 4) | 0xf;
2704 Layout.push_back(inst);
2705 size_in_words -= 16;
2707 if (size_in_words > 0) {
2708 // Note that value in imm. is one less that the actual
2709 // value. So, we subtract 1 away!
2710 unsigned char inst = (opcode << 4) | (size_in_words-1);
2711 Layout.push_back(inst);
2713 if (residue_in_bytes > CharUnits::Zero()) {
2714 unsigned char inst =
2715 (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2716 Layout.push_back(inst);
2720 while (!Layout.empty()) {
2721 unsigned char inst = Layout.back();
2722 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2723 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2729 uint64_t Result = InlineLayoutInstruction(Layout);
2731 // Block variable layout instruction has been inlined.
2732 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2733 if (ComputeByrefLayout)
2734 printf("\n Inline BYREF variable layout: ");
2736 printf("\n Inline block variable layout: ");
2737 printf("0x0%" PRIx64 "", Result);
2738 if (auto numStrong = (Result & 0xF00) >> 8)
2739 printf(", BL_STRONG:%d", (int) numStrong);
2740 if (auto numByref = (Result & 0x0F0) >> 4)
2741 printf(", BL_BYREF:%d", (int) numByref);
2742 if (auto numWeak = (Result & 0x00F) >> 0)
2743 printf(", BL_WEAK:%d", (int) numWeak);
2744 printf(", BL_OPERATOR:0\n");
2746 return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2749 unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2750 Layout.push_back(inst);
2752 for (unsigned i = 0, e = Layout.size(); i != e; i++)
2753 BitMap += Layout[i];
2755 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2756 if (ComputeByrefLayout)
2757 printf("\n Byref variable layout: ");
2759 printf("\n Block variable layout: ");
2760 for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2761 unsigned char inst = BitMap[i];
2762 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2765 case BLOCK_LAYOUT_OPERATOR:
2766 printf("BL_OPERATOR:");
2769 case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2770 printf("BL_NON_OBJECT_BYTES:");
2772 case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2773 printf("BL_NON_OBJECT_WORD:");
2775 case BLOCK_LAYOUT_STRONG:
2776 printf("BL_STRONG:");
2778 case BLOCK_LAYOUT_BYREF:
2779 printf("BL_BYREF:");
2781 case BLOCK_LAYOUT_WEAK:
2784 case BLOCK_LAYOUT_UNRETAINED:
2785 printf("BL_UNRETAINED:");
2788 // Actual value of word count is one more that what is in the imm.
2789 // field of the instruction
2790 printf("%d", (inst & 0xf) + delta);
2798 auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
2799 /*ForceNonFragileABI=*/true,
2800 /*NullTerminate=*/false);
2801 return getConstantGEP(VMContext, Entry, 0, 0);
2804 static std::string getBlockLayoutInfoString(
2805 const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars,
2806 bool HasCopyDisposeHelpers) {
2808 for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) {
2809 if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) {
2810 // Copy/dispose helpers don't have any information about
2811 // __unsafe_unretained captures, so unconditionally concatenate a string.
2813 } else if (HasCopyDisposeHelpers) {
2814 // Information about __strong, __weak, or byref captures has already been
2815 // encoded into the names of the copy/dispose helpers. We have to add a
2816 // string here only when the copy/dispose helpers aren't generated (which
2817 // happens when the block is non-escaping).
2821 case CGObjCCommonMac::BLOCK_LAYOUT_STRONG:
2824 case CGObjCCommonMac::BLOCK_LAYOUT_BYREF:
2827 case CGObjCCommonMac::BLOCK_LAYOUT_WEAK:
2834 Str += llvm::to_string(R.block_var_bytepos.getQuantity());
2835 Str += "l" + llvm::to_string(R.block_var_size.getQuantity());
2840 void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM,
2841 const CGBlockInfo &blockInfo) {
2842 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2844 RunSkipBlockVars.clear();
2845 bool hasUnion = false;
2847 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2848 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2849 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2851 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2853 // Calculate the basic layout of the block structure.
2854 const llvm::StructLayout *layout =
2855 CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2857 // Ignore the optional 'this' capture: C++ objects are not assumed
2859 if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2860 UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2861 blockInfo.BlockHeaderForcedGapOffset,
2862 blockInfo.BlockHeaderForcedGapSize);
2863 // Walk the captured variables.
2864 for (const auto &CI : blockDecl->captures()) {
2865 const VarDecl *variable = CI.getVariable();
2866 QualType type = variable->getType();
2868 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2870 // Ignore constant captures.
2871 if (capture.isConstant()) continue;
2873 CharUnits fieldOffset =
2874 CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2876 assert(!type->isArrayType() && "array variable should not be caught");
2878 if (const RecordType *record = type->getAs<RecordType>()) {
2879 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2882 CharUnits fieldSize;
2884 fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2886 fieldSize = CGM.getContext().getTypeSizeInChars(type);
2887 UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2888 fieldOffset, fieldSize);
2893 CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2894 const CGBlockInfo &blockInfo) {
2895 fillRunSkipBlockVars(CGM, blockInfo);
2896 return getBitmapBlockLayout(false);
2899 std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM,
2900 const CGBlockInfo &blockInfo) {
2901 fillRunSkipBlockVars(CGM, blockInfo);
2902 return getBlockLayoutInfoString(RunSkipBlockVars,
2903 blockInfo.needsCopyDisposeHelpers());
2906 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
2908 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2909 assert(!T->isArrayType() && "__block array variable should not be caught");
2910 CharUnits fieldOffset;
2911 RunSkipBlockVars.clear();
2912 bool hasUnion = false;
2913 if (const RecordType *record = T->getAs<RecordType>()) {
2914 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
2915 llvm::Constant *Result = getBitmapBlockLayout(true);
2916 if (isa<llvm::ConstantInt>(Result))
2917 Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
2920 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2924 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
2925 const ObjCProtocolDecl *PD) {
2926 // FIXME: I don't understand why gcc generates this, or where it is
2927 // resolved. Investigate. Its also wasteful to look this up over and over.
2928 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2930 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
2931 ObjCTypes.getExternalProtocolPtrTy());
2934 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
2935 // FIXME: We shouldn't need this, the protocol decl should contain enough
2936 // information to tell us whether this was a declaration or a definition.
2937 DefinedProtocols.insert(PD->getIdentifier());
2939 // If we have generated a forward reference to this protocol, emit
2940 // it now. Otherwise do nothing, the protocol objects are lazily
2942 if (Protocols.count(PD->getIdentifier()))
2943 GetOrEmitProtocol(PD);
2946 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
2947 if (DefinedProtocols.count(PD->getIdentifier()))
2948 return GetOrEmitProtocol(PD);
2950 return GetOrEmitProtocolRef(PD);
2953 llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
2954 CodeGenFunction &CGF,
2955 const ObjCInterfaceDecl *ID,
2956 ObjCCommonTypesHelper &ObjCTypes) {
2957 llvm::Constant *lookUpClassFn = ObjCTypes.getLookUpClassFn();
2959 llvm::Value *className =
2960 CGF.CGM.GetAddrOfConstantCString(ID->getObjCRuntimeNameAsString())
2962 ASTContext &ctx = CGF.CGM.getContext();
2964 CGF.Builder.CreateBitCast(className,
2966 ctx.getPointerType(ctx.CharTy.withConst())));
2967 llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
2968 call->setDoesNotThrow();
2973 // Objective-C 1.0 extensions
2974 struct _objc_protocol {
2975 struct _objc_protocol_extension *isa;
2976 char *protocol_name;
2977 struct _objc_protocol_list *protocol_list;
2978 struct _objc__method_prototype_list *instance_methods;
2979 struct _objc__method_prototype_list *class_methods
2982 See EmitProtocolExtension().
2984 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
2985 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
2987 // Early exit if a defining object has already been generated.
2988 if (Entry && Entry->hasInitializer())
2991 // Use the protocol definition, if there is one.
2992 if (const ObjCProtocolDecl *Def = PD->getDefinition())
2995 // FIXME: I don't understand why gcc generates this, or where it is
2996 // resolved. Investigate. Its also wasteful to look this up over and over.
2997 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2999 // Construct method lists.
3000 auto methodLists = ProtocolMethodLists::get(PD);
3002 ConstantInitBuilder builder(CGM);
3003 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
3004 values.add(EmitProtocolExtension(PD, methodLists));
3005 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
3006 values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
3007 PD->protocol_begin(), PD->protocol_end()));
3008 values.add(methodLists.emitMethodList(this, PD,
3009 ProtocolMethodLists::RequiredInstanceMethods));
3010 values.add(methodLists.emitMethodList(this, PD,
3011 ProtocolMethodLists::RequiredClassMethods));
3014 // Already created, update the initializer.
3015 assert(Entry->hasPrivateLinkage());
3016 values.finishAndSetAsInitializer(Entry);
3018 Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
3019 CGM.getPointerAlign(),
3021 llvm::GlobalValue::PrivateLinkage);
3022 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3024 Protocols[PD->getIdentifier()] = Entry;
3026 CGM.addCompilerUsedGlobal(Entry);
3031 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
3032 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
3035 // We use the initializer as a marker of whether this is a forward
3036 // reference or not. At module finalization we add the empty
3037 // contents for protocols which were referenced but never defined.
3038 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
3039 false, llvm::GlobalValue::PrivateLinkage,
3040 nullptr, "OBJC_PROTOCOL_" + PD->getName());
3041 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3042 // FIXME: Is this necessary? Why only for protocol?
3043 Entry->setAlignment(4);
3050 struct _objc_protocol_extension {
3052 struct objc_method_description_list *optional_instance_methods;
3053 struct objc_method_description_list *optional_class_methods;
3054 struct objc_property_list *instance_properties;
3055 const char ** extendedMethodTypes;
3056 struct objc_property_list *class_properties;
3060 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
3061 const ProtocolMethodLists &methodLists) {
3062 auto optInstanceMethods =
3063 methodLists.emitMethodList(this, PD,
3064 ProtocolMethodLists::OptionalInstanceMethods);
3065 auto optClassMethods =
3066 methodLists.emitMethodList(this, PD,
3067 ProtocolMethodLists::OptionalClassMethods);
3069 auto extendedMethodTypes =
3070 EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3071 methodLists.emitExtendedTypesArray(this),
3074 auto instanceProperties =
3075 EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3077 auto classProperties =
3078 EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3079 PD, ObjCTypes, true);
3081 // Return null if no extension bits are used.
3082 if (optInstanceMethods->isNullValue() &&
3083 optClassMethods->isNullValue() &&
3084 extendedMethodTypes->isNullValue() &&
3085 instanceProperties->isNullValue() &&
3086 classProperties->isNullValue()) {
3087 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3091 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3093 ConstantInitBuilder builder(CGM);
3094 auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3095 values.addInt(ObjCTypes.IntTy, size);
3096 values.add(optInstanceMethods);
3097 values.add(optClassMethods);
3098 values.add(instanceProperties);
3099 values.add(extendedMethodTypes);
3100 values.add(classProperties);
3102 // No special section, but goes in llvm.used
3103 return CreateMetadataVar("\01l_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3104 StringRef(), CGM.getPointerAlign(), true);
3108 struct objc_protocol_list {
3109 struct objc_protocol_list *next;
3115 CGObjCMac::EmitProtocolList(Twine name,
3116 ObjCProtocolDecl::protocol_iterator begin,
3117 ObjCProtocolDecl::protocol_iterator end) {
3118 // Just return null for empty protocol lists
3120 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3122 ConstantInitBuilder builder(CGM);
3123 auto values = builder.beginStruct();
3125 // This field is only used by the runtime.
3126 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3128 // Reserve a slot for the count.
3129 auto countSlot = values.addPlaceholder();
3131 auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3132 for (; begin != end; ++begin) {
3133 refsArray.add(GetProtocolRef(*begin));
3135 auto count = refsArray.size();
3137 // This list is null terminated.
3138 refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3140 refsArray.finishAndAddTo(values);
3141 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3144 if (CGM.getTriple().isOSBinFormatMachO())
3145 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3147 llvm::GlobalVariable *GV =
3148 CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3149 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3153 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
3154 SmallVectorImpl<const ObjCPropertyDecl *> &Properties,
3155 const ObjCProtocolDecl *Proto,
3156 bool IsClassProperty) {
3157 for (const auto *P : Proto->protocols())
3158 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3160 for (const auto *PD : Proto->properties()) {
3161 if (IsClassProperty != PD->isClassProperty())
3163 if (!PropertySet.insert(PD->getIdentifier()).second)
3165 Properties.push_back(PD);
3170 struct _objc_property {
3171 const char * const name;
3172 const char * const attributes;
3175 struct _objc_property_list {
3176 uint32_t entsize; // sizeof (struct _objc_property)
3177 uint32_t prop_count;
3178 struct _objc_property[prop_count];
3181 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3182 const Decl *Container,
3183 const ObjCContainerDecl *OCD,
3184 const ObjCCommonTypesHelper &ObjCTypes,
3185 bool IsClassProperty) {
3186 if (IsClassProperty) {
3187 // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3188 // with deployment target < 9.0.
3189 const llvm::Triple &Triple = CGM.getTarget().getTriple();
3190 if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
3191 (Triple.isiOS() && Triple.isOSVersionLT(9)))
3192 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3195 SmallVector<const ObjCPropertyDecl *, 16> Properties;
3196 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3198 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3199 for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3200 for (auto *PD : ClassExt->properties()) {
3201 if (IsClassProperty != PD->isClassProperty())
3203 PropertySet.insert(PD->getIdentifier());
3204 Properties.push_back(PD);
3207 for (const auto *PD : OCD->properties()) {
3208 if (IsClassProperty != PD->isClassProperty())
3210 // Don't emit duplicate metadata for properties that were already in a
3212 if (!PropertySet.insert(PD->getIdentifier()).second)
3214 Properties.push_back(PD);
3217 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3218 for (const auto *P : OID->all_referenced_protocols())
3219 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3221 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3222 for (const auto *P : CD->protocols())
3223 PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3226 // Return null for empty list.
3227 if (Properties.empty())
3228 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3230 unsigned propertySize =
3231 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3233 ConstantInitBuilder builder(CGM);
3234 auto values = builder.beginStruct();
3235 values.addInt(ObjCTypes.IntTy, propertySize);
3236 values.addInt(ObjCTypes.IntTy, Properties.size());
3237 auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3238 for (auto PD : Properties) {
3239 auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3240 property.add(GetPropertyName(PD->getIdentifier()));
3241 property.add(GetPropertyTypeString(PD, Container));
3242 property.finishAndAddTo(propertiesArray);
3244 propertiesArray.finishAndAddTo(values);
3247 if (CGM.getTriple().isOSBinFormatMachO())
3248 Section = (ObjCABI == 2) ? "__DATA, __objc_const"
3249 : "__OBJC,__property,regular,no_dead_strip";
3251 llvm::GlobalVariable *GV =
3252 CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3253 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3257 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3258 ArrayRef<llvm::Constant*> MethodTypes,
3259 const ObjCCommonTypesHelper &ObjCTypes) {
3260 // Return null for empty list.
3261 if (MethodTypes.empty())
3262 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3264 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3265 MethodTypes.size());
3266 llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3269 if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
3270 Section = "__DATA, __objc_const";
3272 llvm::GlobalVariable *GV =
3273 CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3274 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3278 struct _objc_category {
3279 char *category_name;
3281 struct _objc_method_list *instance_methods;
3282 struct _objc_method_list *class_methods;
3283 struct _objc_protocol_list *protocols;
3284 uint32_t size; // <rdar://4585769>
3285 struct _objc_property_list *instance_properties;
3286 struct _objc_property_list *class_properties;
3289 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3290 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3292 // FIXME: This is poor design, the OCD should have a pointer to the category
3293 // decl. Additionally, note that Category can be null for the @implementation
3294 // w/o an @interface case. Sema should just create one for us as it does for
3295 // @implementation so everyone else can live life under a clear blue sky.
3296 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3297 const ObjCCategoryDecl *Category =
3298 Interface->FindCategoryDeclaration(OCD->getIdentifier());
3300 SmallString<256> ExtName;
3301 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3304 ConstantInitBuilder Builder(CGM);
3305 auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3312 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3313 for (const auto *MD : OCD->methods()) {
3314 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3317 Values.add(GetClassName(OCD->getName()));
3318 Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3319 LazySymbols.insert(Interface->getIdentifier());
3321 Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3322 Methods[InstanceMethods]));
3323 Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3324 Methods[ClassMethods]));
3327 EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3328 Category->protocol_begin(), Category->protocol_end()));
3330 Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3332 Values.addInt(ObjCTypes.IntTy, Size);
3334 // If there is no category @interface then there can be no properties.
3336 Values.add(EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
3337 OCD, Category, ObjCTypes, false));
3338 Values.add(EmitPropertyList("\01l_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3339 OCD, Category, ObjCTypes, true));
3341 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3342 Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3345 llvm::GlobalVariable *GV =
3346 CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3347 "__OBJC,__category,regular,no_dead_strip",
3348 CGM.getPointerAlign(), true);
3349 DefinedCategories.push_back(GV);
3350 DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3351 // method definition entries must be clear for next implementation.
3352 MethodDefinitions.clear();
3355 enum FragileClassFlags {
3356 /// Apparently: is not a meta-class.
3357 FragileABI_Class_Factory = 0x00001,
3359 /// Is a meta-class.
3360 FragileABI_Class_Meta = 0x00002,
3362 /// Has a non-trivial constructor or destructor.
3363 FragileABI_Class_HasCXXStructors = 0x02000,
3365 /// Has hidden visibility.
3366 FragileABI_Class_Hidden = 0x20000,
3368 /// Class implementation was compiled under ARC.
3369 FragileABI_Class_CompiledByARC = 0x04000000,
3371 /// Class implementation was compiled under MRC and has MRC weak ivars.
3372 /// Exclusive with CompiledByARC.
3373 FragileABI_Class_HasMRCWeakIvars = 0x08000000,
3376 enum NonFragileClassFlags {
3377 /// Is a meta-class.
3378 NonFragileABI_Class_Meta = 0x00001,
3380 /// Is a root class.
3381 NonFragileABI_Class_Root = 0x00002,
3383 /// Has a non-trivial constructor or destructor.
3384 NonFragileABI_Class_HasCXXStructors = 0x00004,
3386 /// Has hidden visibility.
3387 NonFragileABI_Class_Hidden = 0x00010,
3389 /// Has the exception attribute.
3390 NonFragileABI_Class_Exception = 0x00020,
3392 /// (Obsolete) ARC-specific: this class has a .release_ivars method
3393 NonFragileABI_Class_HasIvarReleaser = 0x00040,
3395 /// Class implementation was compiled under ARC.
3396 NonFragileABI_Class_CompiledByARC = 0x00080,
3398 /// Class has non-trivial destructors, but zero-initialization is okay.
3399 NonFragileABI_Class_HasCXXDestructorOnly = 0x00100,
3401 /// Class implementation was compiled under MRC and has MRC weak ivars.
3402 /// Exclusive with CompiledByARC.
3403 NonFragileABI_Class_HasMRCWeakIvars = 0x00200,
3406 static bool hasWeakMember(QualType type) {
3407 if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3411 if (auto recType = type->getAs<RecordType>()) {
3412 for (auto field : recType->getDecl()->fields()) {
3413 if (hasWeakMember(field->getType()))
3421 /// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3422 /// (and actually fill in a layout string) if we really do have any
3424 static bool hasMRCWeakIvars(CodeGenModule &CGM,
3425 const ObjCImplementationDecl *ID) {
3426 if (!CGM.getLangOpts().ObjCWeak) return false;
3427 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3429 for (const ObjCIvarDecl *ivar =
3430 ID->getClassInterface()->all_declared_ivar_begin();
3431 ivar; ivar = ivar->getNextIvar()) {
3432 if (hasWeakMember(ivar->getType()))
3440 struct _objc_class {
3447 struct _objc_ivar_list *ivars;
3448 struct _objc_method_list *methods;
3449 struct _objc_cache *cache;
3450 struct _objc_protocol_list *protocols;
3451 // Objective-C 1.0 extensions (<rdr://4585769>)
3452 const char *ivar_layout;
3453 struct _objc_class_ext *ext;
3456 See EmitClassExtension();
3458 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3459 IdentifierInfo *RuntimeName =
3460 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
3461 DefinedSymbols.insert(RuntimeName);
3463 std::string ClassName = ID->getNameAsString();
3465 ObjCInterfaceDecl *Interface =
3466 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3467 llvm::Constant *Protocols =
3468 EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3469 Interface->all_referenced_protocol_begin(),
3470 Interface->all_referenced_protocol_end());
3471 unsigned Flags = FragileABI_Class_Factory;
3472 if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3473 Flags |= FragileABI_Class_HasCXXStructors;
3475 bool hasMRCWeak = false;
3477 if (CGM.getLangOpts().ObjCAutoRefCount)
3478 Flags |= FragileABI_Class_CompiledByARC;
3479 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3480 Flags |= FragileABI_Class_HasMRCWeakIvars;
3483 CGM.getContext().getASTObjCImplementationLayout(ID).getSize();
3485 // FIXME: Set CXX-structors flag.
3486 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3487 Flags |= FragileABI_Class_Hidden;
3494 SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3495 for (const auto *MD : ID->methods()) {
3496 Methods[unsigned(MD->isClassMethod())].push_back(MD);
3499 for (const auto *PID : ID->property_impls()) {
3500 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3501 ObjCPropertyDecl *PD = PID->getPropertyDecl();
3503 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
3504 if (GetMethodDefinition(MD))
3505 Methods[InstanceMethods].push_back(MD);
3506 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
3507 if (GetMethodDefinition(MD))
3508 Methods[InstanceMethods].push_back(MD);
3512 ConstantInitBuilder builder(CGM);
3513 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3514 values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3515 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3516 // Record a reference to the super class.
3517 LazySymbols.insert(Super->getIdentifier());
3519 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3520 ObjCTypes.ClassPtrTy);
3522 values.addNullPointer(ObjCTypes.ClassPtrTy);
3524 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3525 // Version is always 0.
3526 values.addInt(ObjCTypes.LongTy, 0);
3527 values.addInt(ObjCTypes.LongTy, Flags);
3528 values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3529 values.add(EmitIvarList(ID, false));
3530 values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3531 Methods[InstanceMethods]));
3532 // cache is always NULL.
3533 values.addNullPointer(ObjCTypes.CachePtrTy);
3534 values.add(Protocols);
3535 values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3536 values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3537 /*isMetaclass*/ false));
3539 std::string Name("OBJC_CLASS_");
3541 const char *Section = "__OBJC,__class,regular,no_dead_strip";
3542 // Check for a forward reference.
3543 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3545 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3546 "Forward metaclass reference has incorrect type.");
3547 values.finishAndSetAsInitializer(GV);
3548 GV->setSection(Section);
3549 GV->setAlignment(CGM.getPointerAlign().getQuantity());
3550 CGM.addCompilerUsedGlobal(GV);
3552 GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3553 DefinedClasses.push_back(GV);
3554 ImplementedClasses.push_back(Interface);
3555 // method definition entries must be clear for next implementation.
3556 MethodDefinitions.clear();
3559 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3560 llvm::Constant *Protocols,
3561 ArrayRef<const ObjCMethodDecl*> Methods) {
3562 unsigned Flags = FragileABI_Class_Meta;
3563 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3565 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3566 Flags |= FragileABI_Class_Hidden;
3568 ConstantInitBuilder builder(CGM);
3569 auto values = builder.beginStruct(ObjCTypes.ClassTy);
3570 // The isa for the metaclass is the root of the hierarchy.
3571 const ObjCInterfaceDecl *Root = ID->getClassInterface();
3572 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3574 values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3575 ObjCTypes.ClassPtrTy);
3576 // The super class for the metaclass is emitted as the name of the
3577 // super class. The runtime fixes this up to point to the
3578 // *metaclass* for the super class.
3579 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3580 values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3581 ObjCTypes.ClassPtrTy);
3583 values.addNullPointer(ObjCTypes.ClassPtrTy);
3585 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3586 // Version is always 0.
3587 values.addInt(ObjCTypes.LongTy, 0);
3588 values.addInt(ObjCTypes.LongTy, Flags);
3589 values.addInt(ObjCTypes.LongTy, Size);
3590 values.add(EmitIvarList(ID, true));
3591 values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3593 // cache is always NULL.
3594 values.addNullPointer(ObjCTypes.CachePtrTy);
3595 values.add(Protocols);
3596 // ivar_layout for metaclass is always NULL.
3597 values.addNullPointer(ObjCTypes.Int8PtrTy);
3598 // The class extension is used to store class properties for metaclasses.
3599 values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3600 /*isMetaclass*/true));
3602 std::string Name("OBJC_METACLASS_");
3603 Name += ID->getName();
3605 // Check for a forward reference.
3606 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3608 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3609 "Forward metaclass reference has incorrect type.");
3610 values.finishAndSetAsInitializer(GV);
3612 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3614 llvm::GlobalValue::PrivateLinkage);
3616 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3617 CGM.addCompilerUsedGlobal(GV);
3622 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3623 std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3625 // FIXME: Should we look these up somewhere other than the module. Its a bit
3626 // silly since we only generate these while processing an implementation, so
3627 // exactly one pointer would work if know when we entered/exitted an
3628 // implementation block.
3630 // Check for an existing forward reference.
3631 // Previously, metaclass with internal linkage may have been defined.
3632 // pass 'true' as 2nd argument so it is returned.
3633 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3635 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3636 llvm::GlobalValue::PrivateLinkage, nullptr,
3639 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3640 "Forward metaclass reference has incorrect type.");
3644 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3645 std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3646 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3649 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3650 llvm::GlobalValue::PrivateLinkage, nullptr,
3653 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3654 "Forward class metadata reference has incorrect type.");
3659 Emit a "class extension", which in this specific context means extra
3660 data that doesn't fit in the normal fragile-ABI class structure, and
3661 has nothing to do with the language concept of a class extension.
3663 struct objc_class_ext {
3665 const char *weak_ivar_layout;
3666 struct _objc_property_list *properties;
3670 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3671 CharUnits InstanceSize, bool hasMRCWeakIvars,
3673 // Weak ivar layout.
3674 llvm::Constant *layout;
3676 layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3678 layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3683 llvm::Constant *propertyList =
3684 EmitPropertyList((isMetaclass ? Twine("\01l_OBJC_$_CLASS_PROP_LIST_")
3685 : Twine("\01l_OBJC_$_PROP_LIST_"))
3687 ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3689 // Return null if no extension bits are used.
3690 if (layout->isNullValue() && propertyList->isNullValue()) {
3691 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3695 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3697 ConstantInitBuilder builder(CGM);
3698 auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3699 values.addInt(ObjCTypes.IntTy, size);
3701 values.add(propertyList);
3703 return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3704 "__OBJC,__class_ext,regular,no_dead_strip",
3705 CGM.getPointerAlign(), true);
3715 struct objc_ivar_list {
3717 struct objc_ivar list[count];
3720 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3722 // When emitting the root class GCC emits ivar entries for the
3723 // actual class structure. It is not clear if we need to follow this
3724 // behavior; for now lets try and get away with not doing it. If so,
3725 // the cleanest solution would be to make up an ObjCInterfaceDecl
3728 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3730 const ObjCInterfaceDecl *OID = ID->getClassInterface();
3732 ConstantInitBuilder builder(CGM);
3733 auto ivarList = builder.beginStruct();
3734 auto countSlot = ivarList.addPlaceholder();
3735 auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3737 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3738 IVD; IVD = IVD->getNextIvar()) {
3739 // Ignore unnamed bit-fields.
3740 if (!IVD->getDeclName())
3743 auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3744 ivar.add(GetMethodVarName(IVD->getIdentifier()));
3745 ivar.add(GetMethodVarType(IVD));
3746 ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3747 ivar.finishAndAddTo(ivars);
3750 // Return null for empty list.
3751 auto count = ivars.size();
3755 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3758 ivars.finishAndAddTo(ivarList);
3759 ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3761 llvm::GlobalVariable *GV;
3764 CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3765 "__OBJC,__class_vars,regular,no_dead_strip",
3766 CGM.getPointerAlign(), true);
3768 GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3769 "__OBJC,__instance_vars,regular,no_dead_strip",
3770 CGM.getPointerAlign(), true);
3771 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3774 /// Build a struct objc_method_description constant for the given method.
3776 /// struct objc_method_description {
3777 /// SEL method_name;
3778 /// char *method_types;
3780 void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3781 const ObjCMethodDecl *MD) {
3782 auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3783 description.addBitCast(GetMethodVarName(MD->getSelector()),
3784 ObjCTypes.SelectorPtrTy);
3785 description.add(GetMethodVarType(MD));
3786 description.finishAndAddTo(builder);
3789 /// Build a struct objc_method constant for the given method.
3791 /// struct objc_method {
3792 /// SEL method_name;
3793 /// char *method_types;
3796 void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3797 const ObjCMethodDecl *MD) {
3798 llvm::Function *fn = GetMethodDefinition(MD);
3799 assert(fn && "no definition registered for method");
3801 auto method = builder.beginStruct(ObjCTypes.MethodTy);
3802 method.addBitCast(GetMethodVarName(MD->getSelector()),
3803 ObjCTypes.SelectorPtrTy);
3804 method.add(GetMethodVarType(MD));
3805 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3806 method.finishAndAddTo(builder);
3809 /// Build a struct objc_method_list or struct objc_method_description_list,
3812 /// struct objc_method_list {
3813 /// struct objc_method_list *obsolete;
3815 /// struct objc_method methods_list[count];
3818 /// struct objc_method_description_list {
3820 /// struct objc_method_description list[count];
3822 llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3823 ArrayRef<const ObjCMethodDecl *> methods) {
3826 bool forProtocol = false;
3828 case MethodListType::CategoryInstanceMethods:
3829 prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3830 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3831 forProtocol = false;
3833 case MethodListType::CategoryClassMethods:
3834 prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3835 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3836 forProtocol = false;
3838 case MethodListType::InstanceMethods:
3839 prefix = "OBJC_INSTANCE_METHODS_";
3840 section = "__OBJC,__inst_meth,regular,no_dead_strip";
3841 forProtocol = false;
3843 case MethodListType::ClassMethods:
3844 prefix = "OBJC_CLASS_METHODS_";
3845 section = "__OBJC,__cls_meth,regular,no_dead_strip";
3846 forProtocol = false;
3848 case MethodListType::ProtocolInstanceMethods:
3849 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3850 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3853 case MethodListType::ProtocolClassMethods:
3854 prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3855 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3858 case MethodListType::OptionalProtocolInstanceMethods:
3859 prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3860 section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3863 case MethodListType::OptionalProtocolClassMethods:
3864 prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3865 section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3870 // Return null for empty list.
3871 if (methods.empty())
3872 return llvm::Constant::getNullValue(forProtocol
3873 ? ObjCTypes.MethodDescriptionListPtrTy
3874 : ObjCTypes.MethodListPtrTy);
3876 // For protocols, this is an objc_method_description_list, which has
3877 // a slightly different structure.
3879 ConstantInitBuilder builder(CGM);
3880 auto values = builder.beginStruct();
3881 values.addInt(ObjCTypes.IntTy, methods.size());
3882 auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3883 for (auto MD : methods) {
3884 emitMethodDescriptionConstant(methodArray, MD);
3886 methodArray.finishAndAddTo(values);
3888 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3889 CGM.getPointerAlign(), true);
3890 return llvm::ConstantExpr::getBitCast(GV,
3891 ObjCTypes.MethodDescriptionListPtrTy);
3894 // Otherwise, it's an objc_method_list.
3895 ConstantInitBuilder builder(CGM);
3896 auto values = builder.beginStruct();
3897 values.addNullPointer(ObjCTypes.Int8PtrTy);
3898 values.addInt(ObjCTypes.IntTy, methods.size());
3899 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
3900 for (auto MD : methods) {
3901 emitMethodConstant(methodArray, MD);
3903 methodArray.finishAndAddTo(values);
3905 llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3906 CGM.getPointerAlign(), true);
3907 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
3910 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
3911 const ObjCContainerDecl *CD) {
3912 SmallString<256> Name;
3913 GetNameForMethod(OMD, CD, Name);
3915 CodeGenTypes &Types = CGM.getTypes();
3916 llvm::FunctionType *MethodTy =
3917 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
3918 llvm::Function *Method =
3919 llvm::Function::Create(MethodTy,
3920 llvm::GlobalValue::InternalLinkage,
3923 MethodDefinitions.insert(std::make_pair(OMD, Method));
3928 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3929 ConstantStructBuilder &Init,
3933 llvm::GlobalVariable *GV =
3934 Init.finishAndCreateGlobal(Name, Align, /*constant*/ false,
3935 llvm::GlobalValue::PrivateLinkage);
3936 if (!Section.empty())
3937 GV->setSection(Section);
3939 CGM.addCompilerUsedGlobal(GV);
3943 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3944 llvm::Constant *Init,
3948 llvm::Type *Ty = Init->getType();
3949 llvm::GlobalVariable *GV =
3950 new llvm::GlobalVariable(CGM.getModule(), Ty, false,
3951 llvm::GlobalValue::PrivateLinkage, Init, Name);
3952 if (!Section.empty())
3953 GV->setSection(Section);
3954 GV->setAlignment(Align.getQuantity());
3956 CGM.addCompilerUsedGlobal(GV);
3960 llvm::GlobalVariable *
3961 CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
3962 bool ForceNonFragileABI,
3963 bool NullTerminate) {
3966 case ObjCLabelType::ClassName: Label = "OBJC_CLASS_NAME_"; break;
3967 case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
3968 case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
3969 case ObjCLabelType::PropertyName: Label = "OBJC_PROP_NAME_ATTR_"; break;
3972 bool NonFragile = ForceNonFragileABI || isNonFragileABI();
3976 case ObjCLabelType::ClassName:
3977 Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
3978 : "__TEXT,__cstring,cstring_literals";
3980 case ObjCLabelType::MethodVarName:
3981 Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
3982 : "__TEXT,__cstring,cstring_literals";
3984 case ObjCLabelType::MethodVarType:
3985 Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
3986 : "__TEXT,__cstring,cstring_literals";
3988 case ObjCLabelType::PropertyName:
3989 Section = "__TEXT,__cstring,cstring_literals";
3993 llvm::Constant *Value =
3994 llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
3995 llvm::GlobalVariable *GV =
3996 new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
3997 /*isConstant=*/true,
3998 llvm::GlobalValue::PrivateLinkage, Value, Label);
3999 if (CGM.getTriple().isOSBinFormatMachO())
4000 GV->setSection(Section);
4001 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4002 GV->setAlignment(CharUnits::One().getQuantity());
4003 CGM.addCompilerUsedGlobal(GV);
4008 llvm::Function *CGObjCMac::ModuleInitFunction() {
4009 // Abuse this interface function as a place to finalize.
4014 llvm::Constant *CGObjCMac::GetPropertyGetFunction() {
4015 return ObjCTypes.getGetPropertyFn();
4018 llvm::Constant *CGObjCMac::GetPropertySetFunction() {
4019 return ObjCTypes.getSetPropertyFn();
4022 llvm::Constant *CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
4024 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
4027 llvm::Constant *CGObjCMac::GetGetStructFunction() {
4028 return ObjCTypes.getCopyStructFn();
4031 llvm::Constant *CGObjCMac::GetSetStructFunction() {
4032 return ObjCTypes.getCopyStructFn();
4035 llvm::Constant *CGObjCMac::GetCppAtomicObjectGetFunction() {
4036 return ObjCTypes.getCppAtomicObjectFunction();
4039 llvm::Constant *CGObjCMac::GetCppAtomicObjectSetFunction() {
4040 return ObjCTypes.getCppAtomicObjectFunction();
4043 llvm::Constant *CGObjCMac::EnumerationMutationFunction() {
4044 return ObjCTypes.getEnumerationMutationFn();
4047 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
4048 return EmitTryOrSynchronizedStmt(CGF, S);
4051 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
4052 const ObjCAtSynchronizedStmt &S) {
4053 return EmitTryOrSynchronizedStmt(CGF, S);
4057 struct PerformFragileFinally final : EHScopeStack::Cleanup {
4059 Address SyncArgSlot;
4060 Address CallTryExitVar;
4061 Address ExceptionData;
4062 ObjCTypesHelper &ObjCTypes;
4063 PerformFragileFinally(const Stmt *S,
4064 Address SyncArgSlot,
4065 Address CallTryExitVar,
4066 Address ExceptionData,
4067 ObjCTypesHelper *ObjCTypes)
4068 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4069 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4071 void Emit(CodeGenFunction &CGF, Flags flags) override {
4072 // Check whether we need to call objc_exception_try_exit.
4073 // In optimized code, this branch will always be folded.
4074 llvm::BasicBlock *FinallyCallExit =
4075 CGF.createBasicBlock("finally.call_exit");
4076 llvm::BasicBlock *FinallyNoCallExit =
4077 CGF.createBasicBlock("finally.no_call_exit");
4078 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4079 FinallyCallExit, FinallyNoCallExit);
4081 CGF.EmitBlock(FinallyCallExit);
4082 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4083 ExceptionData.getPointer());
4085 CGF.EmitBlock(FinallyNoCallExit);
4087 if (isa<ObjCAtTryStmt>(S)) {
4088 if (const ObjCAtFinallyStmt* FinallyStmt =
4089 cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4090 // Don't try to do the @finally if this is an EH cleanup.
4091 if (flags.isForEHCleanup()) return;
4093 // Save the current cleanup destination in case there's
4094 // control flow inside the finally statement.
4095 llvm::Value *CurCleanupDest =
4096 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
4098 CGF.EmitStmt(FinallyStmt->getFinallyBody());
4100 if (CGF.HaveInsertPoint()) {
4101 CGF.Builder.CreateStore(CurCleanupDest,
4102 CGF.getNormalCleanupDestSlot());
4104 // Currently, the end of the cleanup must always exist.
4105 CGF.EnsureInsertPoint();
4109 // Emit objc_sync_exit(expr); as finally's sole statement for
4111 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4112 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4117 class FragileHazards {
4118 CodeGenFunction &CGF;
4119 SmallVector<llvm::Value*, 20> Locals;
4120 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4122 llvm::InlineAsm *ReadHazard;
4123 llvm::InlineAsm *WriteHazard;
4125 llvm::FunctionType *GetAsmFnType();
4127 void collectLocals();
4128 void emitReadHazard(CGBuilderTy &Builder);
4131 FragileHazards(CodeGenFunction &CGF);
4133 void emitWriteHazard();
4134 void emitHazardsInNewBlocks();
4136 } // end anonymous namespace
4138 /// Create the fragile-ABI read and write hazards based on the current
4139 /// state of the function, which is presumed to be immediately prior
4140 /// to a @try block. These hazards are used to maintain correct
4141 /// semantics in the face of optimization and the fragile ABI's
4142 /// cavalier use of setjmp/longjmp.
4143 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4146 if (Locals.empty()) return;
4148 // Collect all the blocks in the function.
4149 for (llvm::Function::iterator
4150 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
4151 BlocksBeforeTry.insert(&*I);
4153 llvm::FunctionType *AsmFnTy = GetAsmFnType();
4155 // Create a read hazard for the allocas. This inhibits dead-store
4156 // optimizations and forces the values to memory. This hazard is
4157 // inserted before any 'throwing' calls in the protected scope to
4158 // reflect the possibility that the variables might be read from the
4159 // catch block if the call throws.
4161 std::string Constraint;
4162 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4163 if (I) Constraint += ',';
4167 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4170 // Create a write hazard for the allocas. This inhibits folding
4171 // loads across the hazard. This hazard is inserted at the
4172 // beginning of the catch path to reflect the possibility that the
4173 // variables might have been written within the protected scope.
4175 std::string Constraint;
4176 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4177 if (I) Constraint += ',';
4178 Constraint += "=*m";
4181 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4185 /// Emit a write hazard at the current location.
4186 void FragileHazards::emitWriteHazard() {
4187 if (Locals.empty()) return;
4189 CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4192 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4193 assert(!Locals.empty());
4194 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4195 call->setDoesNotThrow();
4196 call->setCallingConv(CGF.getRuntimeCC());
4199 /// Emit read hazards in all the protected blocks, i.e. all the blocks
4200 /// which have been inserted since the beginning of the try.
4201 void FragileHazards::emitHazardsInNewBlocks() {
4202 if (Locals.empty()) return;
4204 CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4206 // Iterate through all blocks, skipping those prior to the try.
4207 for (llvm::Function::iterator
4208 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
4209 llvm::BasicBlock &BB = *FI;
4210 if (BlocksBeforeTry.count(&BB)) continue;
4212 // Walk through all the calls in the block.
4213 for (llvm::BasicBlock::iterator
4214 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
4215 llvm::Instruction &I = *BI;
4217 // Ignore instructions that aren't non-intrinsic calls.
4218 // These are the only calls that can possibly call longjmp.
4219 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) continue;
4220 if (isa<llvm::IntrinsicInst>(I))
4223 // Ignore call sites marked nounwind. This may be questionable,
4224 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4225 llvm::CallSite CS(&I);
4226 if (CS.doesNotThrow()) continue;
4228 // Insert a read hazard before the call. This will ensure that
4229 // any writes to the locals are performed before making the
4230 // call. If the call throws, then this is sufficient to
4231 // guarantee correctness as long as it doesn't also write to any
4233 Builder.SetInsertPoint(&BB, BI);
4234 emitReadHazard(Builder);
4239 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
4240 if (V.isValid()) S.insert(V.getPointer());
4243 void FragileHazards::collectLocals() {
4244 // Compute a set of allocas to ignore.
4245 llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4246 addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4247 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4249 // Collect all the allocas currently in the function. This is
4250 // probably way too aggressive.
4251 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4252 for (llvm::BasicBlock::iterator
4253 I = Entry.begin(), E = Entry.end(); I != E; ++I)
4254 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
4255 Locals.push_back(&*I);
4258 llvm::FunctionType *FragileHazards::GetAsmFnType() {
4259 SmallVector<llvm::Type *, 16> tys(Locals.size());
4260 for (unsigned i = 0, e = Locals.size(); i != e; ++i)
4261 tys[i] = Locals[i]->getType();
4262 return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4267 Objective-C setjmp-longjmp (sjlj) Exception Handling
4270 A catch buffer is a setjmp buffer plus:
4271 - a pointer to the exception that was caught
4272 - a pointer to the previous exception data buffer
4273 - two pointers of reserved storage
4274 Therefore catch buffers form a stack, with a pointer to the top
4275 of the stack kept in thread-local storage.
4277 objc_exception_try_enter pushes a catch buffer onto the EH stack.
4278 objc_exception_try_exit pops the given catch buffer, which is
4279 required to be the top of the EH stack.
4280 objc_exception_throw pops the top of the EH stack, writes the
4281 thrown exception into the appropriate field, and longjmps
4282 to the setjmp buffer. It crashes the process (with a printf
4283 and an abort()) if there are no catch buffers on the stack.
4284 objc_exception_extract just reads the exception pointer out of the
4287 There's no reason an implementation couldn't use a light-weight
4288 setjmp here --- something like __builtin_setjmp, but API-compatible
4289 with the heavyweight setjmp. This will be more important if we ever
4290 want to implement correct ObjC/C++ exception interactions for the
4293 Note that for this use of setjmp/longjmp to be correct, we may need
4294 to mark some local variables volatile: if a non-volatile local
4295 variable is modified between the setjmp and the longjmp, it has
4296 indeterminate value. For the purposes of LLVM IR, it may be
4297 sufficient to make loads and stores within the @try (to variables
4298 declared outside the @try) volatile. This is necessary for
4299 optimized correctness, but is not currently being done; this is
4300 being tracked as rdar://problem/8160285
4302 The basic framework for a @try-catch-finally is as follows:
4304 objc_exception_data d;
4306 bool _call_try_exit = true;
4308 objc_exception_try_enter(&d);
4309 if (!setjmp(d.jmp_buf)) {
4313 id _caught = objc_exception_extract(&d);
4315 // enter new try scope for handlers
4316 if (!setjmp(d.jmp_buf)) {
4317 ... match exception and execute catch blocks ...
4319 // fell off end, rethrow.
4321 ... jump-through-finally to finally_rethrow ...
4323 // exception in catch block
4324 _rethrow = objc_exception_extract(&d);
4325 _call_try_exit = false;
4326 ... jump-through-finally to finally_rethrow ...
4329 ... jump-through-finally to finally_end ...
4333 objc_exception_try_exit(&d);
4335 ... finally block ....
4336 ... dispatch to finally destination ...
4339 objc_exception_throw(_rethrow);
4344 This framework differs slightly from the one gcc uses, in that gcc
4345 uses _rethrow to determine if objc_exception_try_exit should be called
4346 and if the object should be rethrown. This breaks in the face of
4347 throwing nil and introduces unnecessary branches.
4349 We specialize this framework for a few particular circumstances:
4351 - If there are no catch blocks, then we avoid emitting the second
4352 exception handling context.
4354 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4355 e)) we avoid emitting the code to rethrow an uncaught exception.
4357 - FIXME: If there is no @finally block we can do a few more
4360 Rethrows and Jumps-Through-Finally
4363 '@throw;' is supported by pushing the currently-caught exception
4364 onto ObjCEHStack while the @catch blocks are emitted.
4366 Branches through the @finally block are handled with an ordinary
4367 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
4368 exceptions are not compatible with C++ exceptions, and this is
4369 hardly the only place where this will go wrong.
4371 @synchronized(expr) { stmt; } is emitted as if it were:
4372 id synch_value = expr;
4373 objc_sync_enter(synch_value);
4374 @try { stmt; } @finally { objc_sync_exit(synch_value); }
4377 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4379 bool isTry = isa<ObjCAtTryStmt>(S);
4381 // A destination for the fall-through edges of the catch handlers to
4383 CodeGenFunction::JumpDest FinallyEnd =
4384 CGF.getJumpDestInCurrentScope("finally.end");
4386 // A destination for the rethrow edge of the catch handlers to jump
4388 CodeGenFunction::JumpDest FinallyRethrow =
4389 CGF.getJumpDestInCurrentScope("finally.rethrow");
4391 // For @synchronized, call objc_sync_enter(sync.expr). The
4392 // evaluation of the expression must occur before we enter the
4393 // @synchronized. We can't avoid a temp here because we need the
4394 // value to be preserved. If the backend ever does liveness
4395 // correctly after setjmp, this will be unnecessary.
4396 Address SyncArgSlot = Address::invalid();
4398 llvm::Value *SyncArg =
4399 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4400 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4401 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4403 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4404 CGF.getPointerAlign(), "sync.arg");
4405 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4408 // Allocate memory for the setjmp buffer. This needs to be kept
4409 // live throughout the try and catch blocks.
4410 Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4411 CGF.getPointerAlign(),
4412 "exceptiondata.ptr");
4414 // Create the fragile hazards. Note that this will not capture any
4415 // of the allocas required for exception processing, but will
4416 // capture the current basic block (which extends all the way to the
4417 // setjmp call) as "before the @try".
4418 FragileHazards Hazards(CGF);
4420 // Create a flag indicating whether the cleanup needs to call
4421 // objc_exception_try_exit. This is true except when
4422 // - no catches match and we're branching through the cleanup
4423 // just to rethrow the exception, or
4424 // - a catch matched and we're falling out of the catch handler.
4425 // The setjmp-safety rule here is that we should always store to this
4426 // variable in a place that dominates the branch through the cleanup
4427 // without passing through any setjmps.
4428 Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4432 // A slot containing the exception to rethrow. Only needed when we
4433 // have both a @catch and a @finally.
4434 Address PropagatingExnVar = Address::invalid();
4436 // Push a normal cleanup to leave the try scope.
4437 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4443 // Enter a try block:
4444 // - Call objc_exception_try_enter to push ExceptionData on top of
4446 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4447 ExceptionData.getPointer());
4449 // - Call setjmp on the exception data buffer.
4450 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4451 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4452 llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4453 ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4455 llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4456 ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4457 SetJmpResult->setCanReturnTwice();
4459 // If setjmp returned 0, enter the protected block; otherwise,
4460 // branch to the handler.
4461 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4462 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4463 llvm::Value *DidCatch =
4464 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4465 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4467 // Emit the protected block.
4468 CGF.EmitBlock(TryBlock);
4469 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4470 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4471 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4473 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4475 // Emit the exception handler block.
4476 CGF.EmitBlock(TryHandler);
4478 // Don't optimize loads of the in-scope locals across this point.
4479 Hazards.emitWriteHazard();
4481 // For a @synchronized (or a @try with no catches), just branch
4482 // through the cleanup to the rethrow block.
4483 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4484 // Tell the cleanup not to re-pop the exit.
4485 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4486 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4488 // Otherwise, we have to match against the caught exceptions.
4490 // Retrieve the exception object. We may emit multiple blocks but
4491 // nothing can cross this so the value is already in SSA form.
4492 llvm::CallInst *Caught =
4493 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4494 ExceptionData.getPointer(), "caught");
4496 // Push the exception to rethrow onto the EH value stack for the
4497 // benefit of any @throws in the handlers.
4498 CGF.ObjCEHValueStack.push_back(Caught);
4500 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4502 bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4504 llvm::BasicBlock *CatchBlock = nullptr;
4505 llvm::BasicBlock *CatchHandler = nullptr;
4507 // Save the currently-propagating exception before
4508 // objc_exception_try_enter clears the exception slot.
4509 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4510 CGF.getPointerAlign(),
4511 "propagating_exception");
4512 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4514 // Enter a new exception try block (in case a @catch block
4515 // throws an exception).
4516 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4517 ExceptionData.getPointer());
4519 llvm::CallInst *SetJmpResult =
4520 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4521 SetJmpBuffer, "setjmp.result");
4522 SetJmpResult->setCanReturnTwice();
4524 llvm::Value *Threw =
4525 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4527 CatchBlock = CGF.createBasicBlock("catch");
4528 CatchHandler = CGF.createBasicBlock("catch_for_catch");
4529 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4531 CGF.EmitBlock(CatchBlock);
4534 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4536 // Handle catch list. As a special case we check if everything is
4537 // matched and avoid generating code for falling off the end if
4539 bool AllMatched = false;
4540 for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
4541 const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4543 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4544 const ObjCObjectPointerType *OPT = nullptr;
4546 // catch(...) always matches.
4550 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4552 // catch(id e) always matches under this ABI, since only
4553 // ObjC exceptions end up here in the first place.
4554 // FIXME: For the time being we also match id<X>; this should
4555 // be rejected by Sema instead.
4556 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4560 // If this is a catch-all, we don't need to test anything.
4562 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4565 CGF.EmitAutoVarDecl(*CatchParam);
4566 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4568 // These types work out because ConvertType(id) == i8*.
4569 EmitInitOfCatchParam(CGF, Caught, CatchParam);
4572 CGF.EmitStmt(CatchStmt->getCatchBody());
4574 // The scope of the catch variable ends right here.
4575 CatchVarCleanups.ForceCleanup();
4577 CGF.EmitBranchThroughCleanup(FinallyEnd);
4581 assert(OPT && "Unexpected non-object pointer type in @catch");
4582 const ObjCObjectType *ObjTy = OPT->getObjectType();
4584 // FIXME: @catch (Class c) ?
4585 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4586 assert(IDecl && "Catch parameter must have Objective-C type!");
4588 // Check if the @catch block matches the exception object.
4589 llvm::Value *Class = EmitClassRef(CGF, IDecl);
4591 llvm::Value *matchArgs[] = { Class, Caught };
4592 llvm::CallInst *Match =
4593 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4594 matchArgs, "match");
4596 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4597 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4599 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4600 MatchedBlock, NextCatchBlock);
4602 // Emit the @catch block.
4603 CGF.EmitBlock(MatchedBlock);
4605 // Collect any cleanups for the catch variable. The scope lasts until
4606 // the end of the catch body.
4607 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4609 CGF.EmitAutoVarDecl(*CatchParam);
4610 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4612 // Initialize the catch variable.
4614 CGF.Builder.CreateBitCast(Caught,
4615 CGF.ConvertType(CatchParam->getType()));
4616 EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4618 CGF.EmitStmt(CatchStmt->getCatchBody());
4620 // We're done with the catch variable.
4621 CatchVarCleanups.ForceCleanup();
4623 CGF.EmitBranchThroughCleanup(FinallyEnd);
4625 CGF.EmitBlock(NextCatchBlock);
4628 CGF.ObjCEHValueStack.pop_back();
4630 // If nothing wanted anything to do with the caught exception,
4631 // kill the extract call.
4632 if (Caught->use_empty())
4633 Caught->eraseFromParent();
4636 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4639 // Emit the exception handler for the @catch blocks.
4640 CGF.EmitBlock(CatchHandler);
4642 // In theory we might now need a write hazard, but actually it's
4643 // unnecessary because there's no local-accessing code between
4644 // the try's write hazard and here.
4645 //Hazards.emitWriteHazard();
4647 // Extract the new exception and save it to the
4648 // propagating-exception slot.
4649 assert(PropagatingExnVar.isValid());
4650 llvm::CallInst *NewCaught =
4651 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4652 ExceptionData.getPointer(), "caught");
4653 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4655 // Don't pop the catch handler; the throw already did.
4656 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4657 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4661 // Insert read hazards as required in the new blocks.
4662 Hazards.emitHazardsInNewBlocks();
4665 CGF.Builder.restoreIP(TryFallthroughIP);
4666 if (CGF.HaveInsertPoint())
4667 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4668 CGF.PopCleanupBlock();
4669 CGF.EmitBlock(FinallyEnd.getBlock(), true);
4671 // Emit the rethrow block.
4672 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4673 CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4674 if (CGF.HaveInsertPoint()) {
4675 // If we have a propagating-exception variable, check it.
4676 llvm::Value *PropagatingExn;
4677 if (PropagatingExnVar.isValid()) {
4678 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4680 // Otherwise, just look in the buffer for the exception to throw.
4682 llvm::CallInst *Caught =
4683 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4684 ExceptionData.getPointer());
4685 PropagatingExn = Caught;
4688 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4690 CGF.Builder.CreateUnreachable();
4693 CGF.Builder.restoreIP(SavedIP);
4696 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4697 const ObjCAtThrowStmt &S,
4698 bool ClearInsertionPoint) {
4699 llvm::Value *ExceptionAsObject;
4701 if (const Expr *ThrowExpr = S.getThrowExpr()) {
4702 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4704 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4706 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4707 "Unexpected rethrow outside @catch block.");
4708 ExceptionAsObject = CGF.ObjCEHValueStack.back();
4711 CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4712 ->setDoesNotReturn();
4713 CGF.Builder.CreateUnreachable();
4715 // Clear the insertion point to indicate we are in unreachable code.
4716 if (ClearInsertionPoint)
4717 CGF.Builder.ClearInsertionPoint();
4720 /// EmitObjCWeakRead - Code gen for loading value of a __weak
4721 /// object: objc_read_weak (id *src)
4723 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4724 Address AddrWeakObj) {
4725 llvm::Type* DestTy = AddrWeakObj.getElementType();
4726 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4727 ObjCTypes.PtrObjectPtrTy);
4728 llvm::Value *read_weak =
4729 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4730 AddrWeakObj.getPointer(), "weakread");
4731 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4735 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4736 /// objc_assign_weak (id src, id *dst)
4738 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4739 llvm::Value *src, Address dst) {
4740 llvm::Type * SrcTy = src->getType();
4741 if (!isa<llvm::PointerType>(SrcTy)) {
4742 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4743 assert(Size <= 8 && "does not support size > 8");
4744 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4745 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4746 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4748 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4749 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4750 llvm::Value *args[] = { src, dst.getPointer() };
4751 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4752 args, "weakassign");
4755 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4756 /// objc_assign_global (id src, id *dst)
4758 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4759 llvm::Value *src, Address dst,
4761 llvm::Type * SrcTy = src->getType();
4762 if (!isa<llvm::PointerType>(SrcTy)) {
4763 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4764 assert(Size <= 8 && "does not support size > 8");
4765 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4766 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4767 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4769 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4770 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4771 llvm::Value *args[] = { src, dst.getPointer() };
4773 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4774 args, "globalassign");
4776 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4777 args, "threadlocalassign");
4780 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4781 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4783 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4784 llvm::Value *src, Address dst,
4785 llvm::Value *ivarOffset) {
4786 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
4787 llvm::Type * SrcTy = src->getType();
4788 if (!isa<llvm::PointerType>(SrcTy)) {
4789 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4790 assert(Size <= 8 && "does not support size > 8");
4791 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4792 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4793 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4795 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4796 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4797 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
4798 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
4801 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
4802 /// objc_assign_strongCast (id src, id *dst)
4804 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
4805 llvm::Value *src, Address dst) {
4806 llvm::Type * SrcTy = src->getType();
4807 if (!isa<llvm::PointerType>(SrcTy)) {
4808 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4809 assert(Size <= 8 && "does not support size > 8");
4810 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4811 : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4812 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4814 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4815 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4816 llvm::Value *args[] = { src, dst.getPointer() };
4817 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
4818 args, "strongassign");
4821 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
4824 llvm::Value *size) {
4825 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
4826 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
4827 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
4828 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
4831 /// EmitObjCValueForIvar - Code Gen for ivar reference.
4833 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
4835 llvm::Value *BaseValue,
4836 const ObjCIvarDecl *Ivar,
4837 unsigned CVRQualifiers) {
4838 const ObjCInterfaceDecl *ID =
4839 ObjectTy->getAs<ObjCObjectType>()->getInterface();
4840 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
4841 EmitIvarOffset(CGF, ID, Ivar));
4844 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
4845 const ObjCInterfaceDecl *Interface,
4846 const ObjCIvarDecl *Ivar) {
4847 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
4848 return llvm::ConstantInt::get(
4849 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
4853 /* *** Private Interface *** */
4855 std::string CGObjCCommonMac::GetSectionName(StringRef Section,
4856 StringRef MachOAttributes) {
4857 switch (CGM.getTriple().getObjectFormat()) {
4859 llvm_unreachable("unexpected object file format");
4860 case llvm::Triple::MachO: {
4861 if (MachOAttributes.empty())
4862 return ("__DATA," + Section).str();
4863 return ("__DATA," + Section + "," + MachOAttributes).str();
4865 case llvm::Triple::ELF:
4866 assert(Section.substr(0, 2) == "__" &&
4867 "expected the name to begin with __");
4868 return Section.substr(2).str();
4869 case llvm::Triple::COFF:
4870 assert(Section.substr(0, 2) == "__" &&
4871 "expected the name to begin with __");
4872 return ("." + Section.substr(2) + "$B").str();
4876 /// EmitImageInfo - Emit the image info marker used to encode some module
4877 /// level information.
4879 /// See: <rdr://4810609&4810587&4810587>
4880 /// struct IMAGE_INFO {
4881 /// unsigned version;
4884 enum ImageInfoFlags {
4885 eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang.
4886 eImageInfo_GarbageCollected = (1 << 1),
4887 eImageInfo_GCOnly = (1 << 2),
4888 eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache.
4890 // A flag indicating that the module has no instances of a @synthesize of a
4891 // superclass variable. <rdar://problem/6803242>
4892 eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
4893 eImageInfo_ImageIsSimulated = (1 << 5),
4894 eImageInfo_ClassProperties = (1 << 6)
4897 void CGObjCCommonMac::EmitImageInfo() {
4898 unsigned version = 0; // Version is unused?
4899 std::string Section =
4901 ? "__OBJC,__image_info,regular"
4902 : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");
4904 // Generate module-level named metadata to convey this information to the
4905 // linker and code-gen.
4906 llvm::Module &Mod = CGM.getModule();
4908 // Add the ObjC ABI version to the module flags.
4909 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
4910 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
4912 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
4913 llvm::MDString::get(VMContext, Section));
4915 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
4916 // Non-GC overrides those files which specify GC.
4917 Mod.addModuleFlag(llvm::Module::Override,
4918 "Objective-C Garbage Collection", (uint32_t)0);
4920 // Add the ObjC garbage collection value.
4921 Mod.addModuleFlag(llvm::Module::Error,
4922 "Objective-C Garbage Collection",
4923 eImageInfo_GarbageCollected);
4925 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
4926 // Add the ObjC GC Only value.
4927 Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
4930 // Require that GC be specified and set to eImageInfo_GarbageCollected.
4931 llvm::Metadata *Ops[2] = {
4932 llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
4933 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
4934 llvm::Type::getInt32Ty(VMContext), eImageInfo_GarbageCollected))};
4935 Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
4936 llvm::MDNode::get(VMContext, Ops));
4940 // Indicate whether we're compiling this to run on a simulator.
4941 if (CGM.getTarget().getTriple().isSimulatorEnvironment())
4942 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
4943 eImageInfo_ImageIsSimulated);
4945 // Indicate whether we are generating class properties.
4946 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
4947 eImageInfo_ClassProperties);
4950 // struct objc_module {
4951 // unsigned long version;
4952 // unsigned long size;
4953 // const char *name;
4957 // FIXME: Get from somewhere
4958 static const int ModuleVersion = 7;
4960 void CGObjCMac::EmitModuleInfo() {
4961 uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
4963 ConstantInitBuilder builder(CGM);
4964 auto values = builder.beginStruct(ObjCTypes.ModuleTy);
4965 values.addInt(ObjCTypes.LongTy, ModuleVersion);
4966 values.addInt(ObjCTypes.LongTy, Size);
4967 // This used to be the filename, now it is unused. <rdr://4327263>
4968 values.add(GetClassName(StringRef("")));
4969 values.add(EmitModuleSymbols());
4970 CreateMetadataVar("OBJC_MODULES", values,
4971 "__OBJC,__module_info,regular,no_dead_strip",
4972 CGM.getPointerAlign(), true);
4975 llvm::Constant *CGObjCMac::EmitModuleSymbols() {
4976 unsigned NumClasses = DefinedClasses.size();
4977 unsigned NumCategories = DefinedCategories.size();
4979 // Return null if no symbols were defined.
4980 if (!NumClasses && !NumCategories)
4981 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
4983 ConstantInitBuilder builder(CGM);
4984 auto values = builder.beginStruct();
4985 values.addInt(ObjCTypes.LongTy, 0);
4986 values.addNullPointer(ObjCTypes.SelectorPtrTy);
4987 values.addInt(ObjCTypes.ShortTy, NumClasses);
4988 values.addInt(ObjCTypes.ShortTy, NumCategories);
4990 // The runtime expects exactly the list of defined classes followed
4991 // by the list of defined categories, in a single array.
4992 auto array = values.beginArray(ObjCTypes.Int8PtrTy);
4993 for (unsigned i=0; i<NumClasses; i++) {
4994 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
4996 if (ObjCImplementationDecl *IMP = ID->getImplementation())
4997 // We are implementing a weak imported interface. Give it external linkage
4998 if (ID->isWeakImported() && !IMP->isWeakImported())
4999 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5001 array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy);
5003 for (unsigned i=0; i<NumCategories; i++)
5004 array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy);
5006 array.finishAndAddTo(values);
5008 llvm::GlobalVariable *GV = CreateMetadataVar(
5009 "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip",
5010 CGM.getPointerAlign(), true);
5011 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
5014 llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
5015 IdentifierInfo *II) {
5016 LazySymbols.insert(II);
5018 llvm::GlobalVariable *&Entry = ClassReferences[II];
5021 llvm::Constant *Casted =
5022 llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
5023 ObjCTypes.ClassPtrTy);
5024 Entry = CreateMetadataVar(
5025 "OBJC_CLASS_REFERENCES_", Casted,
5026 "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
5027 CGM.getPointerAlign(), true);
5030 return CGF.Builder.CreateAlignedLoad(Entry, CGF.getPointerAlign());
5033 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
5034 const ObjCInterfaceDecl *ID) {
5035 // If the class has the objc_runtime_visible attribute, we need to
5036 // use the Objective-C runtime to get the class.
5037 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
5038 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
5040 IdentifierInfo *RuntimeName =
5041 &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
5042 return EmitClassRefFromId(CGF, RuntimeName);
5045 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
5046 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
5047 return EmitClassRefFromId(CGF, II);
5050 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
5051 return CGF.Builder.CreateLoad(EmitSelectorAddr(CGF, Sel));
5054 Address CGObjCMac::EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel) {
5055 CharUnits Align = CGF.getPointerAlign();
5057 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
5059 llvm::Constant *Casted =
5060 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5061 ObjCTypes.SelectorPtrTy);
5062 Entry = CreateMetadataVar(
5063 "OBJC_SELECTOR_REFERENCES_", Casted,
5064 "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
5065 Entry->setExternallyInitialized(true);
5068 return Address(Entry, Align);
5071 llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
5072 llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
5074 Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
5075 return getConstantGEP(VMContext, Entry, 0, 0);
5078 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
5079 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
5080 I = MethodDefinitions.find(MD);
5081 if (I != MethodDefinitions.end())
5087 /// GetIvarLayoutName - Returns a unique constant for the given
5088 /// ivar layout bitmap.
5089 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
5090 const ObjCCommonTypesHelper &ObjCTypes) {
5091 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5094 void IvarLayoutBuilder::visitRecord(const RecordType *RT,
5096 const RecordDecl *RD = RT->getDecl();
5098 // If this is a union, remember that we had one, because it might mess
5099 // up the ordering of layout entries.
5101 IsDisordered = true;
5103 const ASTRecordLayout *recLayout = nullptr;
5104 visitAggregate(RD->field_begin(), RD->field_end(), offset,
5105 [&](const FieldDecl *field) -> CharUnits {
5107 recLayout = &CGM.getContext().getASTRecordLayout(RD);
5108 auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
5109 return CGM.getContext().toCharUnitsFromBits(offsetInBits);
5113 template <class Iterator, class GetOffsetFn>
5114 void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
5115 CharUnits aggregateOffset,
5116 const GetOffsetFn &getOffset) {
5117 for (; begin != end; ++begin) {
5118 auto field = *begin;
5120 // Skip over bitfields.
5121 if (field->isBitField()) {
5125 // Compute the offset of the field within the aggregate.
5126 CharUnits fieldOffset = aggregateOffset + getOffset(field);
5128 visitField(field, fieldOffset);
5132 /// Collect layout information for the given fields into IvarsInfo.
5133 void IvarLayoutBuilder::visitField(const FieldDecl *field,
5134 CharUnits fieldOffset) {
5135 QualType fieldType = field->getType();
5137 // Drill down into arrays.
5138 uint64_t numElts = 1;
5139 if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) {
5141 fieldType = arrayType->getElementType();
5143 // Unlike incomplete arrays, constant arrays can be nested.
5144 while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
5145 numElts *= arrayType->getSize().getZExtValue();
5146 fieldType = arrayType->getElementType();
5149 assert(!fieldType->isArrayType() && "ivar of non-constant array type?");
5151 // If we ended up with a zero-sized array, we've done what we can do within
5152 // the limits of this layout encoding.
5153 if (numElts == 0) return;
5155 // Recurse if the base element type is a record type.
5156 if (auto recType = fieldType->getAs<RecordType>()) {
5157 size_t oldEnd = IvarsInfo.size();
5159 visitRecord(recType, fieldOffset);
5161 // If we have an array, replicate the first entry's layout information.
5162 auto numEltEntries = IvarsInfo.size() - oldEnd;
5163 if (numElts != 1 && numEltEntries != 0) {
5164 CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5165 for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
5166 // Copy the last numEltEntries onto the end of the array, adjusting
5167 // each for the element size.
5168 for (size_t i = 0; i != numEltEntries; ++i) {
5169 auto firstEntry = IvarsInfo[oldEnd + i];
5170 IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
5171 firstEntry.SizeInWords));
5179 // Classify the element type.
5180 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
5182 // If it matches what we're looking for, add an entry.
5183 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
5184 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
5185 assert(CGM.getContext().getTypeSizeInChars(fieldType)
5186 == CGM.getPointerSize());
5187 IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
5191 /// buildBitmap - This routine does the horsework of taking the offsets of
5192 /// strong/weak references and creating a bitmap. The bitmap is also
5193 /// returned in the given buffer, suitable for being passed to \c dump().
5194 llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
5195 llvm::SmallVectorImpl<unsigned char> &buffer) {
5196 // The bitmap is a series of skip/scan instructions, aligned to word
5197 // boundaries. The skip is performed first.
5198 const unsigned char MaxNibble = 0xF;
5199 const unsigned char SkipMask = 0xF0, SkipShift = 4;
5200 const unsigned char ScanMask = 0x0F, ScanShift = 0;
5202 assert(!IvarsInfo.empty() && "generating bitmap for no data");
5204 // Sort the ivar info on byte position in case we encounterred a
5205 // union nested in the ivar list.
5207 // This isn't a stable sort, but our algorithm should handle it fine.
5208 llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
5210 assert(std::is_sorted(IvarsInfo.begin(), IvarsInfo.end()));
5212 assert(IvarsInfo.back().Offset < InstanceEnd);
5214 assert(buffer.empty());
5216 // Skip the next N words.
5217 auto skip = [&](unsigned numWords) {
5218 assert(numWords > 0);
5220 // Try to merge into the previous byte. Since scans happen second, we
5221 // can't do this if it includes a scan.
5222 if (!buffer.empty() && !(buffer.back() & ScanMask)) {
5223 unsigned lastSkip = buffer.back() >> SkipShift;
5224 if (lastSkip < MaxNibble) {
5225 unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
5226 numWords -= claimed;
5227 lastSkip += claimed;
5228 buffer.back() = (lastSkip << SkipShift);
5232 while (numWords >= MaxNibble) {
5233 buffer.push_back(MaxNibble << SkipShift);
5234 numWords -= MaxNibble;
5237 buffer.push_back(numWords << SkipShift);
5241 // Scan the next N words.
5242 auto scan = [&](unsigned numWords) {
5243 assert(numWords > 0);
5245 // Try to merge into the previous byte. Since scans happen second, we can
5246 // do this even if it includes a skip.
5247 if (!buffer.empty()) {
5248 unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
5249 if (lastScan < MaxNibble) {
5250 unsigned claimed = std::min(MaxNibble - lastScan, numWords);
5251 numWords -= claimed;
5252 lastScan += claimed;
5253 buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
5257 while (numWords >= MaxNibble) {
5258 buffer.push_back(MaxNibble << ScanShift);
5259 numWords -= MaxNibble;
5262 buffer.push_back(numWords << ScanShift);
5266 // One past the end of the last scan.
5267 unsigned endOfLastScanInWords = 0;
5268 const CharUnits WordSize = CGM.getPointerSize();
5270 // Consider all the scan requests.
5271 for (auto &request : IvarsInfo) {
5272 CharUnits beginOfScan = request.Offset - InstanceBegin;
5274 // Ignore scan requests that don't start at an even multiple of the
5275 // word size. We can't encode them.
5276 if ((beginOfScan % WordSize) != 0) continue;
5278 // Ignore scan requests that start before the instance start.
5279 // This assumes that scans never span that boundary. The boundary
5280 // isn't the true start of the ivars, because in the fragile-ARC case
5281 // it's rounded up to word alignment, but the test above should leave
5282 // us ignoring that possibility.
5283 if (beginOfScan.isNegative()) {
5284 assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin);
5288 unsigned beginOfScanInWords = beginOfScan / WordSize;
5289 unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
5291 // If the scan starts some number of words after the last one ended,
5293 if (beginOfScanInWords > endOfLastScanInWords) {
5294 skip(beginOfScanInWords - endOfLastScanInWords);
5296 // Otherwise, start scanning where the last left off.
5298 beginOfScanInWords = endOfLastScanInWords;
5300 // If that leaves us with nothing to scan, ignore this request.
5301 if (beginOfScanInWords >= endOfScanInWords) continue;
5304 // Scan to the end of the request.
5305 assert(beginOfScanInWords < endOfScanInWords);
5306 scan(endOfScanInWords - beginOfScanInWords);
5307 endOfLastScanInWords = endOfScanInWords;
5311 return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
5313 // For GC layouts, emit a skip to the end of the allocation so that we
5314 // have precise information about the entire thing. This isn't useful
5315 // or necessary for the ARC-style layout strings.
5316 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5317 unsigned lastOffsetInWords =
5318 (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5319 if (lastOffsetInWords > endOfLastScanInWords) {
5320 skip(lastOffsetInWords - endOfLastScanInWords);
5324 // Null terminate the string.
5325 buffer.push_back(0);
5327 auto *Entry = CGObjC.CreateCStringLiteral(
5328 reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
5329 return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5332 /// BuildIvarLayout - Builds ivar layout bitmap for the class
5333 /// implementation for the __strong or __weak case.
5334 /// The layout map displays which words in ivar list must be skipped
5335 /// and which must be scanned by GC (see below). String is built of bytes.
5336 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5337 /// of words to skip and right nibble is count of words to scan. So, each
5338 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5339 /// represented by a 0x00 byte which also ends the string.
5340 /// 1. when ForStrongLayout is true, following ivars are scanned:
5343 /// - __strong anything
5345 /// 2. When ForStrongLayout is false, following ivars are scanned:
5346 /// - __weak anything
5349 CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
5350 CharUnits beginOffset, CharUnits endOffset,
5351 bool ForStrongLayout, bool HasMRCWeakIvars) {
5352 // If this is MRC, and we're either building a strong layout or there
5353 // are no weak ivars, bail out early.
5354 llvm::Type *PtrTy = CGM.Int8PtrTy;
5355 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5356 !CGM.getLangOpts().ObjCAutoRefCount &&
5357 (ForStrongLayout || !HasMRCWeakIvars))
5358 return llvm::Constant::getNullValue(PtrTy);
5360 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5361 SmallVector<const ObjCIvarDecl*, 32> ivars;
5363 // GC layout strings include the complete object layout, possibly
5364 // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5367 // ARC layout strings only include the class's ivars. In non-fragile
5368 // runtimes, that means starting at InstanceStart, rounded up to word
5369 // alignment. In fragile runtimes, there's no InstanceStart, so it means
5370 // starting at the offset of the first ivar, rounded up to word alignment.
5372 // MRC weak layout strings follow the ARC style.
5373 CharUnits baseOffset;
5374 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5375 for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5376 IVD; IVD = IVD->getNextIvar())
5377 ivars.push_back(IVD);
5379 if (isNonFragileABI()) {
5380 baseOffset = beginOffset; // InstanceStart
5381 } else if (!ivars.empty()) {
5383 CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5385 baseOffset = CharUnits::Zero();
5388 baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5391 CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5393 baseOffset = CharUnits::Zero();
5397 return llvm::Constant::getNullValue(PtrTy);
5399 IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5401 builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5402 [&](const ObjCIvarDecl *ivar) -> CharUnits {
5403 return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5406 if (!builder.hasBitmapData())
5407 return llvm::Constant::getNullValue(PtrTy);
5409 llvm::SmallVector<unsigned char, 4> buffer;
5410 llvm::Constant *C = builder.buildBitmap(*this, buffer);
5412 if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5413 printf("\n%s ivar layout for class '%s': ",
5414 ForStrongLayout ? "strong" : "weak",
5415 OMD->getClassInterface()->getName().str().c_str());
5416 builder.dump(buffer);
5421 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5422 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5423 // FIXME: Avoid std::string in "Sel.getAsString()"
5425 Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
5426 return getConstantGEP(VMContext, Entry, 0, 0);
5429 // FIXME: Merge into a single cstring creation function.
5430 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5431 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5434 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5435 std::string TypeStr;
5436 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5438 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5440 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5441 return getConstantGEP(VMContext, Entry, 0, 0);
5444 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5446 std::string TypeStr =
5447 CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);
5449 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5451 Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5452 return getConstantGEP(VMContext, Entry, 0, 0);
5455 // FIXME: Merge into a single cstring creation function.
5456 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5457 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5459 Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
5460 return getConstantGEP(VMContext, Entry, 0, 0);
5463 // FIXME: Merge into a single cstring creation function.
5464 // FIXME: This Decl should be more precise.
5466 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5467 const Decl *Container) {
5468 std::string TypeStr =
5469 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
5470 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5473 void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
5474 const ObjCContainerDecl *CD,
5475 SmallVectorImpl<char> &Name) {
5476 llvm::raw_svector_ostream OS(Name);
5477 assert (CD && "Missing container decl in GetNameForMethod");
5478 OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
5479 << '[' << CD->getName();
5480 if (const ObjCCategoryImplDecl *CID =
5481 dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
5482 OS << '(' << *CID << ')';
5483 OS << ' ' << D->getSelector().getAsString() << ']';
5486 void CGObjCMac::FinishModule() {
5489 // Emit the dummy bodies for any protocols which were referenced but
5491 for (auto &entry : Protocols) {
5492 llvm::GlobalVariable *global = entry.second;
5493 if (global->hasInitializer())
5496 ConstantInitBuilder builder(CGM);
5497 auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
5498 values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
5499 values.add(GetClassName(entry.first->getName()));
5500 values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
5501 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5502 values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5503 values.finishAndSetAsInitializer(global);
5504 CGM.addCompilerUsedGlobal(global);
5507 // Add assembler directives to add lazy undefined symbol references
5508 // for classes which are referenced but not defined. This is
5509 // important for correct linker interaction.
5511 // FIXME: It would be nice if we had an LLVM construct for this.
5512 if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
5513 CGM.getTriple().isOSBinFormatMachO()) {
5514 SmallString<256> Asm;
5515 Asm += CGM.getModule().getModuleInlineAsm();
5516 if (!Asm.empty() && Asm.back() != '\n')
5519 llvm::raw_svector_ostream OS(Asm);
5520 for (const auto *Sym : DefinedSymbols)
5521 OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
5522 << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
5523 for (const auto *Sym : LazySymbols)
5524 OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
5525 for (const auto &Category : DefinedCategoryNames)
5526 OS << "\t.objc_category_name_" << Category << "=0\n"
5527 << "\t.globl .objc_category_name_" << Category << "\n";
5529 CGM.getModule().setModuleInlineAsm(OS.str());
5533 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5534 : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
5535 ObjCEmptyVtableVar(nullptr) {
5541 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5542 : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5544 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5545 ASTContext &Ctx = CGM.getContext();
5547 ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
5549 LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
5550 Int8PtrTy = CGM.Int8PtrTy;
5551 Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5553 // arm64 targets use "int" ivar offset variables. All others,
5554 // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5555 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5556 IvarOffsetVarTy = IntTy;
5558 IvarOffsetVarTy = LongTy;
5561 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
5563 llvm::PointerType::getUnqual(ObjectPtrTy);
5565 cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
5567 // I'm not sure I like this. The implicit coordination is a bit
5568 // gross. We should solve this in a reasonable fashion because this
5569 // is a pretty common task (match some runtime data structure with
5570 // an LLVM data structure).
5572 // FIXME: This is leaked.
5573 // FIXME: Merge with rewriter code?
5575 // struct _objc_super {
5579 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5580 Ctx.getTranslationUnitDecl(),
5581 SourceLocation(), SourceLocation(),
5582 &Ctx.Idents.get("_objc_super"));
5583 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5584 nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5585 false, ICIS_NoInit));
5586 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5587 nullptr, Ctx.getObjCClassType(), nullptr,
5588 nullptr, false, ICIS_NoInit));
5589 RD->completeDefinition();
5591 SuperCTy = Ctx.getTagDeclType(RD);
5592 SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5594 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5595 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5599 // char *attributes;
5601 PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy);
5603 // struct _prop_list_t {
5604 // uint32_t entsize; // sizeof(struct _prop_t)
5605 // uint32_t count_of_properties;
5606 // struct _prop_t prop_list[count_of_properties];
5608 PropertyListTy = llvm::StructType::create(
5609 "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0));
5610 // struct _prop_list_t *
5611 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5613 // struct _objc_method {
5615 // char *method_type;
5618 MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy,
5619 Int8PtrTy, Int8PtrTy);
5621 // struct _objc_cache *
5622 CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5623 CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5626 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5627 : ObjCCommonTypesHelper(cgm) {
5628 // struct _objc_method_description {
5632 MethodDescriptionTy = llvm::StructType::create(
5633 "struct._objc_method_description", SelectorPtrTy, Int8PtrTy);
5635 // struct _objc_method_description_list {
5637 // struct _objc_method_description[1];
5639 MethodDescriptionListTy =
5640 llvm::StructType::create("struct._objc_method_description_list", IntTy,
5641 llvm::ArrayType::get(MethodDescriptionTy, 0));
5643 // struct _objc_method_description_list *
5644 MethodDescriptionListPtrTy =
5645 llvm::PointerType::getUnqual(MethodDescriptionListTy);
5647 // Protocol description structures
5649 // struct _objc_protocol_extension {
5650 // uint32_t size; // sizeof(struct _objc_protocol_extension)
5651 // struct _objc_method_description_list *optional_instance_methods;
5652 // struct _objc_method_description_list *optional_class_methods;
5653 // struct _objc_property_list *instance_properties;
5654 // const char ** extendedMethodTypes;
5655 // struct _objc_property_list *class_properties;
5657 ProtocolExtensionTy = llvm::StructType::create(
5658 "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy,
5659 MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy,
5662 // struct _objc_protocol_extension *
5663 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5665 // Handle recursive construction of Protocol and ProtocolList types
5668 llvm::StructType::create(VMContext, "struct._objc_protocol");
5671 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5672 ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy,
5673 llvm::ArrayType::get(ProtocolTy, 0));
5675 // struct _objc_protocol {
5676 // struct _objc_protocol_extension *isa;
5677 // char *protocol_name;
5678 // struct _objc_protocol **_objc_protocol_list;
5679 // struct _objc_method_description_list *instance_methods;
5680 // struct _objc_method_description_list *class_methods;
5682 ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5683 llvm::PointerType::getUnqual(ProtocolListTy),
5684 MethodDescriptionListPtrTy, MethodDescriptionListPtrTy);
5686 // struct _objc_protocol_list *
5687 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5689 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5691 // Class description structures
5693 // struct _objc_ivar {
5698 IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy,
5701 // struct _objc_ivar_list *
5703 llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5704 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5706 // struct _objc_method_list *
5708 llvm::StructType::create(VMContext, "struct._objc_method_list");
5709 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5711 // struct _objc_class_extension *
5712 ClassExtensionTy = llvm::StructType::create(
5713 "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy);
5714 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5716 ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5718 // struct _objc_class {
5720 // Class super_class;
5724 // long instance_size;
5725 // struct _objc_ivar_list *ivars;
5726 // struct _objc_method_list *methods;
5727 // struct _objc_cache *cache;
5728 // struct _objc_protocol_list *protocols;
5729 // char *ivar_layout;
5730 // struct _objc_class_ext *ext;
5732 ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5733 llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy,
5734 LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy,
5735 ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy);
5737 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5739 // struct _objc_category {
5740 // char *category_name;
5741 // char *class_name;
5742 // struct _objc_method_list *instance_method;
5743 // struct _objc_method_list *class_method;
5744 // struct _objc_protocol_list *protocols;
5745 // uint32_t size; // sizeof(struct _objc_category)
5746 // struct _objc_property_list *instance_properties;// category's @property
5747 // struct _objc_property_list *class_properties;
5749 CategoryTy = llvm::StructType::create(
5750 "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5751 MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy,
5754 // Global metadata structures
5756 // struct _objc_symtab {
5757 // long sel_ref_cnt;
5759 // short cls_def_cnt;
5760 // short cat_def_cnt;
5761 // char *defs[cls_def_cnt + cat_def_cnt];
5763 SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy,
5764 SelectorPtrTy, ShortTy, ShortTy,
5765 llvm::ArrayType::get(Int8PtrTy, 0));
5766 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
5768 // struct _objc_module {
5770 // long size; // sizeof(struct _objc_module)
5772 // struct _objc_symtab* symtab;
5774 ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy,
5775 Int8PtrTy, SymtabPtrTy);
5777 // FIXME: This is the size of the setjmp buffer and should be target
5778 // specific. 18 is what's used on 32-bit X86.
5779 uint64_t SetJmpBufferSize = 18;
5782 llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
5784 ExceptionDataTy = llvm::StructType::create(
5785 "struct._objc_exception_data",
5786 llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy);
5789 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
5790 : ObjCCommonTypesHelper(cgm) {
5791 // struct _method_list_t {
5792 // uint32_t entsize; // sizeof(struct _objc_method)
5793 // uint32_t method_count;
5794 // struct _objc_method method_list[method_count];
5797 llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
5798 llvm::ArrayType::get(MethodTy, 0));
5799 // struct method_list_t *
5800 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
5802 // struct _protocol_t {
5804 // const char * const protocol_name;
5805 // const struct _protocol_list_t * protocol_list; // super protocols
5806 // const struct method_list_t * const instance_methods;
5807 // const struct method_list_t * const class_methods;
5808 // const struct method_list_t *optionalInstanceMethods;
5809 // const struct method_list_t *optionalClassMethods;
5810 // const struct _prop_list_t * properties;
5811 // const uint32_t size; // sizeof(struct _protocol_t)
5812 // const uint32_t flags; // = 0
5813 // const char ** extendedMethodTypes;
5814 // const char *demangledName;
5815 // const struct _prop_list_t * class_properties;
5818 // Holder for struct _protocol_list_t *
5819 ProtocolListnfABITy =
5820 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5822 ProtocolnfABITy = llvm::StructType::create(
5823 "struct._protocol_t", ObjectPtrTy, Int8PtrTy,
5824 llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy,
5825 MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5826 PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy,
5829 // struct _protocol_t*
5830 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
5832 // struct _protocol_list_t {
5833 // long protocol_count; // Note, this is 32/64 bit
5834 // struct _protocol_t *[protocol_count];
5836 ProtocolListnfABITy->setBody(LongTy,
5837 llvm::ArrayType::get(ProtocolnfABIPtrTy, 0));
5839 // struct _objc_protocol_list*
5840 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
5843 // unsigned [long] int *offset; // pointer to ivar offset location
5846 // uint32_t alignment;
5849 IvarnfABITy = llvm::StructType::create(
5850 "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
5851 Int8PtrTy, Int8PtrTy, IntTy, IntTy);
5853 // struct _ivar_list_t {
5854 // uint32 entsize; // sizeof(struct _ivar_t)
5856 // struct _iver_t list[count];
5859 llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
5860 llvm::ArrayType::get(IvarnfABITy, 0));
5862 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
5864 // struct _class_ro_t {
5865 // uint32_t const flags;
5866 // uint32_t const instanceStart;
5867 // uint32_t const instanceSize;
5868 // uint32_t const reserved; // only when building for 64bit targets
5869 // const uint8_t * const ivarLayout;
5870 // const char *const name;
5871 // const struct _method_list_t * const baseMethods;
5872 // const struct _objc_protocol_list *const baseProtocols;
5873 // const struct _ivar_list_t *const ivars;
5874 // const uint8_t * const weakIvarLayout;
5875 // const struct _prop_list_t * const properties;
5878 // FIXME. Add 'reserved' field in 64bit abi mode!
5879 ClassRonfABITy = llvm::StructType::create(
5880 "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy,
5881 MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy,
5882 Int8PtrTy, PropertyListPtrTy);
5884 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
5885 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
5886 ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
5889 // struct _class_t {
5890 // struct _class_t *isa;
5891 // struct _class_t * const superclass;
5894 // struct class_ro_t *ro;
5897 ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
5898 ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
5899 llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy,
5900 llvm::PointerType::getUnqual(ImpnfABITy),
5901 llvm::PointerType::getUnqual(ClassRonfABITy));
5903 // LLVM for struct _class_t *
5904 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
5906 // struct _category_t {
5907 // const char * const name;
5908 // struct _class_t *const cls;
5909 // const struct _method_list_t * const instance_methods;
5910 // const struct _method_list_t * const class_methods;
5911 // const struct _protocol_list_t * const protocols;
5912 // const struct _prop_list_t * const properties;
5913 // const struct _prop_list_t * const class_properties;
5914 // const uint32_t size;
5916 CategorynfABITy = llvm::StructType::create(
5917 "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy,
5918 MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy,
5919 PropertyListPtrTy, IntTy);
5921 // New types for nonfragile abi messaging.
5922 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5923 ASTContext &Ctx = CGM.getContext();
5925 // MessageRefTy - LLVM for:
5926 // struct _message_ref_t {
5931 // First the clang type for struct _message_ref_t
5932 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5933 Ctx.getTranslationUnitDecl(),
5934 SourceLocation(), SourceLocation(),
5935 &Ctx.Idents.get("_message_ref_t"));
5936 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5937 nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
5939 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5940 nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
5941 false, ICIS_NoInit));
5942 RD->completeDefinition();
5944 MessageRefCTy = Ctx.getTagDeclType(RD);
5945 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
5946 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
5948 // MessageRefPtrTy - LLVM for struct _message_ref_t*
5949 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
5951 // SuperMessageRefTy - LLVM for:
5952 // struct _super_message_ref_t {
5953 // SUPER_IMP messenger;
5956 SuperMessageRefTy = llvm::StructType::create("struct._super_message_ref_t",
5957 ImpnfABITy, SelectorPtrTy);
5959 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
5960 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
5963 // struct objc_typeinfo {
5964 // const void** vtable; // objc_ehtype_vtable + 2
5965 // const char* name; // c++ typeinfo string
5968 EHTypeTy = llvm::StructType::create("struct._objc_typeinfo",
5969 llvm::PointerType::getUnqual(Int8PtrTy),
5970 Int8PtrTy, ClassnfABIPtrTy);
5971 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
5974 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
5975 FinishNonFragileABIModule();
5980 void CGObjCNonFragileABIMac::AddModuleClassList(
5981 ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName,
5982 StringRef SectionName) {
5983 unsigned NumClasses = Container.size();
5988 SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
5989 for (unsigned i=0; i<NumClasses; i++)
5990 Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
5991 ObjCTypes.Int8PtrTy);
5992 llvm::Constant *Init =
5993 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
5997 llvm::GlobalVariable *GV =
5998 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
5999 llvm::GlobalValue::PrivateLinkage,
6002 GV->setAlignment(CGM.getDataLayout().getABITypeAlignment(Init->getType()));
6003 GV->setSection(SectionName);
6004 CGM.addCompilerUsedGlobal(GV);
6007 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
6008 // nonfragile abi has no module definition.
6010 // Build list of all implemented class addresses in array
6011 // L_OBJC_LABEL_CLASS_$.
6013 for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
6014 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
6016 if (ObjCImplementationDecl *IMP = ID->getImplementation())
6017 // We are implementing a weak imported interface. Give it external linkage
6018 if (ID->isWeakImported() && !IMP->isWeakImported()) {
6019 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6020 DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6024 AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
6025 GetSectionName("__objc_classlist",
6026 "regular,no_dead_strip"));
6028 AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$",
6029 GetSectionName("__objc_nlclslist",
6030 "regular,no_dead_strip"));
6032 // Build list of all implemented category addresses in array
6033 // L_OBJC_LABEL_CATEGORY_$.
6034 AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$",
6035 GetSectionName("__objc_catlist",
6036 "regular,no_dead_strip"));
6037 AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$",
6038 GetSectionName("__objc_nlcatlist",
6039 "regular,no_dead_strip"));
6044 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of
6045 /// VTableDispatchMethods; false otherwise. What this means is that
6046 /// except for the 19 selectors in the list, we generate 32bit-style
6047 /// message dispatch call for all the rest.
6048 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
6049 // At various points we've experimented with using vtable-based
6050 // dispatch for all methods.
6051 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
6052 case CodeGenOptions::Legacy:
6054 case CodeGenOptions::NonLegacy:
6056 case CodeGenOptions::Mixed:
6060 // If so, see whether this selector is in the white-list of things which must
6061 // use the new dispatch convention. We lazily build a dense set for this.
6062 if (VTableDispatchMethods.empty()) {
6063 VTableDispatchMethods.insert(GetNullarySelector("alloc"));
6064 VTableDispatchMethods.insert(GetNullarySelector("class"));
6065 VTableDispatchMethods.insert(GetNullarySelector("self"));
6066 VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
6067 VTableDispatchMethods.insert(GetNullarySelector("length"));
6068 VTableDispatchMethods.insert(GetNullarySelector("count"));
6070 // These are vtable-based if GC is disabled.
6071 // Optimistically use vtable dispatch for hybrid compiles.
6072 if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
6073 VTableDispatchMethods.insert(GetNullarySelector("retain"));
6074 VTableDispatchMethods.insert(GetNullarySelector("release"));
6075 VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
6078 VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
6079 VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
6080 VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
6081 VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
6082 VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
6083 VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
6084 VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
6086 // These are vtable-based if GC is enabled.
6087 // Optimistically use vtable dispatch for hybrid compiles.
6088 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
6089 VTableDispatchMethods.insert(GetNullarySelector("hash"));
6090 VTableDispatchMethods.insert(GetUnarySelector("addObject"));
6092 // "countByEnumeratingWithState:objects:count"
6093 IdentifierInfo *KeyIdents[] = {
6094 &CGM.getContext().Idents.get("countByEnumeratingWithState"),
6095 &CGM.getContext().Idents.get("objects"),
6096 &CGM.getContext().Idents.get("count")
6098 VTableDispatchMethods.insert(
6099 CGM.getContext().Selectors.getSelector(3, KeyIdents));
6103 return VTableDispatchMethods.count(Sel);
6106 /// BuildClassRoTInitializer - generate meta-data for:
6107 /// struct _class_ro_t {
6108 /// uint32_t const flags;
6109 /// uint32_t const instanceStart;
6110 /// uint32_t const instanceSize;
6111 /// uint32_t const reserved; // only when building for 64bit targets
6112 /// const uint8_t * const ivarLayout;
6113 /// const char *const name;
6114 /// const struct _method_list_t * const baseMethods;
6115 /// const struct _protocol_list_t *const baseProtocols;
6116 /// const struct _ivar_list_t *const ivars;
6117 /// const uint8_t * const weakIvarLayout;
6118 /// const struct _prop_list_t * const properties;
6121 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
6123 unsigned InstanceStart,
6124 unsigned InstanceSize,
6125 const ObjCImplementationDecl *ID) {
6126 std::string ClassName = ID->getObjCRuntimeNameAsString();
6128 CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
6129 CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
6131 bool hasMRCWeak = false;
6132 if (CGM.getLangOpts().ObjCAutoRefCount)
6133 flags |= NonFragileABI_Class_CompiledByARC;
6134 else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
6135 flags |= NonFragileABI_Class_HasMRCWeakIvars;
6137 ConstantInitBuilder builder(CGM);
6138 auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy);
6140 values.addInt(ObjCTypes.IntTy, flags);
6141 values.addInt(ObjCTypes.IntTy, InstanceStart);
6142 values.addInt(ObjCTypes.IntTy, InstanceSize);
6143 values.add((flags & NonFragileABI_Class_Meta)
6144 ? GetIvarLayoutName(nullptr, ObjCTypes)
6145 : BuildStrongIvarLayout(ID, beginInstance, endInstance));
6146 values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
6148 // const struct _method_list_t * const baseMethods;
6149 SmallVector<const ObjCMethodDecl*, 16> methods;
6150 if (flags & NonFragileABI_Class_Meta) {
6151 for (const auto *MD : ID->class_methods())
6152 methods.push_back(MD);
6154 for (const auto *MD : ID->instance_methods())
6155 methods.push_back(MD);
6157 for (const auto *PID : ID->property_impls()) {
6158 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
6159 ObjCPropertyDecl *PD = PID->getPropertyDecl();
6161 if (auto MD = PD->getGetterMethodDecl())
6162 if (GetMethodDefinition(MD))
6163 methods.push_back(MD);
6164 if (auto MD = PD->getSetterMethodDecl())
6165 if (GetMethodDefinition(MD))
6166 methods.push_back(MD);
6171 values.add(emitMethodList(ID->getObjCRuntimeNameAsString(),
6172 (flags & NonFragileABI_Class_Meta)
6173 ? MethodListType::ClassMethods
6174 : MethodListType::InstanceMethods,
6177 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6178 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
6179 values.add(EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_"
6180 + OID->getObjCRuntimeNameAsString(),
6181 OID->all_referenced_protocol_begin(),
6182 OID->all_referenced_protocol_end()));
6184 if (flags & NonFragileABI_Class_Meta) {
6185 values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy);
6186 values.add(GetIvarLayoutName(nullptr, ObjCTypes));
6187 values.add(EmitPropertyList(
6188 "\01l_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6189 ID, ID->getClassInterface(), ObjCTypes, true));
6191 values.add(EmitIvarList(ID));
6192 values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak));
6193 values.add(EmitPropertyList(
6194 "\01l_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6195 ID, ID->getClassInterface(), ObjCTypes, false));
6198 llvm::SmallString<64> roLabel;
6199 llvm::raw_svector_ostream(roLabel)
6200 << ((flags & NonFragileABI_Class_Meta) ? "\01l_OBJC_METACLASS_RO_$_"
6201 : "\01l_OBJC_CLASS_RO_$_")
6204 llvm::GlobalVariable *CLASS_RO_GV =
6205 values.finishAndCreateGlobal(roLabel, CGM.getPointerAlign(),
6207 llvm::GlobalValue::PrivateLinkage);
6208 if (CGM.getTriple().isOSBinFormatMachO())
6209 CLASS_RO_GV->setSection("__DATA, __objc_const");
6213 /// Build the metaclass object for a class.
6215 /// struct _class_t {
6216 /// struct _class_t *isa;
6217 /// struct _class_t * const superclass;
6220 /// struct class_ro_t *ro;
6223 llvm::GlobalVariable *
6224 CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI,
6226 llvm::Constant *IsAGV,
6227 llvm::Constant *SuperClassGV,
6228 llvm::Constant *ClassRoGV,
6229 bool HiddenVisibility) {
6230 ConstantInitBuilder builder(CGM);
6231 auto values = builder.beginStruct(ObjCTypes.ClassnfABITy);
6234 values.add(SuperClassGV);
6236 values.addNullPointer(ObjCTypes.ClassnfABIPtrTy);
6238 values.add(ObjCEmptyCacheVar);
6239 values.add(ObjCEmptyVtableVar);
6240 values.add(ClassRoGV);
6242 llvm::GlobalVariable *GV =
6243 cast<llvm::GlobalVariable>(GetClassGlobal(CI, isMetaclass, ForDefinition));
6244 values.finishAndSetAsInitializer(GV);
6246 if (CGM.getTriple().isOSBinFormatMachO())
6247 GV->setSection("__DATA, __objc_data");
6249 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy));
6250 if (!CGM.getTriple().isOSBinFormatCOFF())
6251 if (HiddenVisibility)
6252 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6257 CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
6258 return OD->getClassMethod(GetNullarySelector("load")) != nullptr;
6261 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
6262 uint32_t &InstanceStart,
6263 uint32_t &InstanceSize) {
6264 const ASTRecordLayout &RL =
6265 CGM.getContext().getASTObjCImplementationLayout(OID);
6267 // InstanceSize is really instance end.
6268 InstanceSize = RL.getDataSize().getQuantity();
6270 // If there are no fields, the start is the same as the end.
6271 if (!RL.getFieldCount())
6272 InstanceStart = InstanceSize;
6274 InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
6277 static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM,
6279 IdentifierInfo &II = CGM.getContext().Idents.get(Name);
6280 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
6281 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
6283 const VarDecl *VD = nullptr;
6284 for (const auto &Result : DC->lookup(&II))
6285 if ((VD = dyn_cast<VarDecl>(Result)))
6289 return llvm::GlobalValue::DLLImportStorageClass;
6290 if (VD->hasAttr<DLLExportAttr>())
6291 return llvm::GlobalValue::DLLExportStorageClass;
6292 if (VD->hasAttr<DLLImportAttr>())
6293 return llvm::GlobalValue::DLLImportStorageClass;
6294 return llvm::GlobalValue::DefaultStorageClass;
6297 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
6298 if (!ObjCEmptyCacheVar) {
6300 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false,
6301 llvm::GlobalValue::ExternalLinkage, nullptr,
6302 "_objc_empty_cache");
6303 if (CGM.getTriple().isOSBinFormatCOFF())
6304 ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache"));
6306 // Only OS X with deployment version <10.9 use the empty vtable symbol
6307 const llvm::Triple &Triple = CGM.getTarget().getTriple();
6308 if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9))
6309 ObjCEmptyVtableVar =
6310 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false,
6311 llvm::GlobalValue::ExternalLinkage, nullptr,
6312 "_objc_empty_vtable");
6314 ObjCEmptyVtableVar =
6315 llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo());
6318 // FIXME: Is this correct (that meta class size is never computed)?
6319 uint32_t InstanceStart =
6320 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
6321 uint32_t InstanceSize = InstanceStart;
6322 uint32_t flags = NonFragileABI_Class_Meta;
6324 llvm::Constant *SuperClassGV, *IsAGV;
6326 const auto *CI = ID->getClassInterface();
6327 assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0");
6329 // Build the flags for the metaclass.
6330 bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF())
6331 ? !CI->hasAttr<DLLExportAttr>()
6332 : CI->getVisibility() == HiddenVisibility;
6334 flags |= NonFragileABI_Class_Hidden;
6336 // FIXME: why is this flag set on the metaclass?
6337 // ObjC metaclasses have no fields and don't really get constructed.
6338 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6339 flags |= NonFragileABI_Class_HasCXXStructors;
6340 if (!ID->hasNonZeroConstructors())
6341 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6344 if (!CI->getSuperClass()) {
6346 flags |= NonFragileABI_Class_Root;
6348 SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition);
6349 IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition);
6351 // Has a root. Current class is not a root.
6352 const ObjCInterfaceDecl *Root = ID->getClassInterface();
6353 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
6356 const auto *Super = CI->getSuperClass();
6357 IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition);
6358 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition);
6361 llvm::GlobalVariable *CLASS_RO_GV =
6362 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6364 llvm::GlobalVariable *MetaTClass =
6365 BuildClassObject(CI, /*metaclass*/ true,
6366 IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden);
6367 CGM.setGVProperties(MetaTClass, CI);
6368 DefinedMetaClasses.push_back(MetaTClass);
6370 // Metadata for the class
6373 flags |= NonFragileABI_Class_Hidden;
6375 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6376 flags |= NonFragileABI_Class_HasCXXStructors;
6378 // Set a flag to enable a runtime optimization when a class has
6379 // fields that require destruction but which don't require
6380 // anything except zero-initialization during construction. This
6381 // is most notably true of __strong and __weak types, but you can
6382 // also imagine there being C++ types with non-trivial default
6383 // constructors that merely set all fields to null.
6384 if (!ID->hasNonZeroConstructors())
6385 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6388 if (hasObjCExceptionAttribute(CGM.getContext(), CI))
6389 flags |= NonFragileABI_Class_Exception;
6391 if (!CI->getSuperClass()) {
6392 flags |= NonFragileABI_Class_Root;
6393 SuperClassGV = nullptr;
6395 // Has a root. Current class is not a root.
6396 const auto *Super = CI->getSuperClass();
6397 SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition);
6400 GetClassSizeInfo(ID, InstanceStart, InstanceSize);
6402 BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6404 llvm::GlobalVariable *ClassMD =
6405 BuildClassObject(CI, /*metaclass*/ false,
6406 MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden);
6407 CGM.setGVProperties(ClassMD, CI);
6408 DefinedClasses.push_back(ClassMD);
6409 ImplementedClasses.push_back(CI);
6411 // Determine if this class is also "non-lazy".
6412 if (ImplementationIsNonLazy(ID))
6413 DefinedNonLazyClasses.push_back(ClassMD);
6415 // Force the definition of the EHType if necessary.
6416 if (flags & NonFragileABI_Class_Exception)
6417 (void) GetInterfaceEHType(CI, ForDefinition);
6418 // Make sure method definition entries are all clear for next implementation.
6419 MethodDefinitions.clear();
6422 /// GenerateProtocolRef - This routine is called to generate code for
6423 /// a protocol reference expression; as in:
6425 /// @protocol(Proto1);
6427 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
6428 /// which will hold address of the protocol meta-data.
6430 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
6431 const ObjCProtocolDecl *PD) {
6433 // This routine is called for @protocol only. So, we must build definition
6434 // of protocol's meta-data (not a reference to it!)
6436 llvm::Constant *Init =
6437 llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
6438 ObjCTypes.getExternalProtocolPtrTy());
6440 std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_");
6441 ProtocolName += PD->getObjCRuntimeNameAsString();
6443 CharUnits Align = CGF.getPointerAlign();
6445 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
6447 return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6448 PTGV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6449 llvm::GlobalValue::WeakAnyLinkage, Init,
6451 PTGV->setSection(GetSectionName("__objc_protorefs",
6452 "coalesced,no_dead_strip"));
6453 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6454 PTGV->setAlignment(Align.getQuantity());
6455 if (!CGM.getTriple().isOSBinFormatMachO())
6456 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolName));
6457 CGM.addUsedGlobal(PTGV);
6458 return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6461 /// GenerateCategory - Build metadata for a category implementation.
6462 /// struct _category_t {
6463 /// const char * const name;
6464 /// struct _class_t *const cls;
6465 /// const struct _method_list_t * const instance_methods;
6466 /// const struct _method_list_t * const class_methods;
6467 /// const struct _protocol_list_t * const protocols;
6468 /// const struct _prop_list_t * const properties;
6469 /// const struct _prop_list_t * const class_properties;
6470 /// const uint32_t size;
6473 void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
6474 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
6475 const char *Prefix = "\01l_OBJC_$_CATEGORY_";
6477 llvm::SmallString<64> ExtCatName(Prefix);
6478 ExtCatName += Interface->getObjCRuntimeNameAsString();
6479 ExtCatName += "_$_";
6480 ExtCatName += OCD->getNameAsString();
6482 ConstantInitBuilder builder(CGM);
6483 auto values = builder.beginStruct(ObjCTypes.CategorynfABITy);
6484 values.add(GetClassName(OCD->getIdentifier()->getName()));
6485 // meta-class entry symbol
6486 values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition));
6487 std::string listName =
6488 (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str();
6490 SmallVector<const ObjCMethodDecl *, 16> instanceMethods;
6491 SmallVector<const ObjCMethodDecl *, 8> classMethods;
6492 for (const auto *MD : OCD->methods()) {
6493 if (MD->isInstanceMethod()) {
6494 instanceMethods.push_back(MD);
6496 classMethods.push_back(MD);
6500 values.add(emitMethodList(listName, MethodListType::CategoryInstanceMethods,
6502 values.add(emitMethodList(listName, MethodListType::CategoryClassMethods,
6505 const ObjCCategoryDecl *Category =
6506 Interface->FindCategoryDeclaration(OCD->getIdentifier());
6508 SmallString<256> ExtName;
6509 llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
6511 values.add(EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_"
6512 + Interface->getObjCRuntimeNameAsString() + "_$_"
6513 + Category->getName(),
6514 Category->protocol_begin(),
6515 Category->protocol_end()));
6516 values.add(EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
6517 OCD, Category, ObjCTypes, false));
6518 values.add(EmitPropertyList("\01l_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
6519 OCD, Category, ObjCTypes, true));
6521 values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy);
6522 values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6523 values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6526 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy);
6527 values.addInt(ObjCTypes.IntTy, Size);
6529 llvm::GlobalVariable *GCATV =
6530 values.finishAndCreateGlobal(ExtCatName.str(), CGM.getPointerAlign(),
6532 llvm::GlobalValue::PrivateLinkage);
6533 if (CGM.getTriple().isOSBinFormatMachO())
6534 GCATV->setSection("__DATA, __objc_const");
6535 CGM.addCompilerUsedGlobal(GCATV);
6536 DefinedCategories.push_back(GCATV);
6538 // Determine if this category is also "non-lazy".
6539 if (ImplementationIsNonLazy(OCD))
6540 DefinedNonLazyCategories.push_back(GCATV);
6541 // method definition entries must be clear for next implementation.
6542 MethodDefinitions.clear();
6545 /// emitMethodConstant - Return a struct objc_method constant. If
6546 /// forProtocol is true, the implementation will be null; otherwise,
6547 /// the method must have a definition registered with the runtime.
6549 /// struct _objc_method {
6551 /// char *method_type;
6554 void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
6555 const ObjCMethodDecl *MD,
6557 auto method = builder.beginStruct(ObjCTypes.MethodTy);
6558 method.addBitCast(GetMethodVarName(MD->getSelector()),
6559 ObjCTypes.SelectorPtrTy);
6560 method.add(GetMethodVarType(MD));
6563 // Protocol methods have no implementation. So, this entry is always NULL.
6564 method.addNullPointer(ObjCTypes.Int8PtrTy);
6566 llvm::Function *fn = GetMethodDefinition(MD);
6567 assert(fn && "no definition for method?");
6568 method.addBitCast(fn, ObjCTypes.Int8PtrTy);
6571 method.finishAndAddTo(builder);
6574 /// Build meta-data for method declarations.
6576 /// struct _method_list_t {
6577 /// uint32_t entsize; // sizeof(struct _objc_method)
6578 /// uint32_t method_count;
6579 /// struct _objc_method method_list[method_count];
6583 CGObjCNonFragileABIMac::emitMethodList(Twine name, MethodListType kind,
6584 ArrayRef<const ObjCMethodDecl *> methods) {
6585 // Return null for empty list.
6586 if (methods.empty())
6587 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
6592 case MethodListType::CategoryInstanceMethods:
6593 prefix = "\01l_OBJC_$_CATEGORY_INSTANCE_METHODS_";
6594 forProtocol = false;
6596 case MethodListType::CategoryClassMethods:
6597 prefix = "\01l_OBJC_$_CATEGORY_CLASS_METHODS_";
6598 forProtocol = false;
6600 case MethodListType::InstanceMethods:
6601 prefix = "\01l_OBJC_$_INSTANCE_METHODS_";
6602 forProtocol = false;
6604 case MethodListType::ClassMethods:
6605 prefix = "\01l_OBJC_$_CLASS_METHODS_";
6606 forProtocol = false;
6609 case MethodListType::ProtocolInstanceMethods:
6610 prefix = "\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_";
6613 case MethodListType::ProtocolClassMethods:
6614 prefix = "\01l_OBJC_$_PROTOCOL_CLASS_METHODS_";
6617 case MethodListType::OptionalProtocolInstanceMethods:
6618 prefix = "\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_";
6621 case MethodListType::OptionalProtocolClassMethods:
6622 prefix = "\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_";
6627 ConstantInitBuilder builder(CGM);
6628 auto values = builder.beginStruct();
6630 // sizeof(struct _objc_method)
6631 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
6632 values.addInt(ObjCTypes.IntTy, Size);
6634 values.addInt(ObjCTypes.IntTy, methods.size());
6635 auto methodArray = values.beginArray(ObjCTypes.MethodTy);
6636 for (auto MD : methods) {
6637 emitMethodConstant(methodArray, MD, forProtocol);
6639 methodArray.finishAndAddTo(values);
6641 auto *GV = values.finishAndCreateGlobal(prefix + name, CGM.getPointerAlign(),
6643 llvm::GlobalValue::PrivateLinkage);
6644 if (CGM.getTriple().isOSBinFormatMachO())
6645 GV->setSection("__DATA, __objc_const");
6646 CGM.addCompilerUsedGlobal(GV);
6647 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6650 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6652 llvm::GlobalVariable *
6653 CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
6654 const ObjCIvarDecl *Ivar) {
6655 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
6656 llvm::SmallString<64> Name("OBJC_IVAR_$_");
6657 Name += Container->getObjCRuntimeNameAsString();
6659 Name += Ivar->getName();
6660 llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name);
6661 if (!IvarOffsetGV) {
6663 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.IvarOffsetVarTy,
6664 false, llvm::GlobalValue::ExternalLinkage,
6665 nullptr, Name.str());
6666 if (CGM.getTriple().isOSBinFormatCOFF()) {
6667 bool IsPrivateOrPackage =
6668 Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6669 Ivar->getAccessControl() == ObjCIvarDecl::Package;
6671 const ObjCInterfaceDecl *ContainingID = Ivar->getContainingInterface();
6673 if (ContainingID->hasAttr<DLLImportAttr>())
6675 ->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6676 else if (ContainingID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage)
6678 ->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6681 return IvarOffsetGV;
6685 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
6686 const ObjCIvarDecl *Ivar,
6687 unsigned long int Offset) {
6688 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
6689 IvarOffsetGV->setInitializer(
6690 llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
6691 IvarOffsetGV->setAlignment(
6692 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy));
6694 if (!CGM.getTriple().isOSBinFormatCOFF()) {
6695 // FIXME: This matches gcc, but shouldn't the visibility be set on the use
6696 // as well (i.e., in ObjCIvarOffsetVariable).
6697 if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6698 Ivar->getAccessControl() == ObjCIvarDecl::Package ||
6699 ID->getVisibility() == HiddenVisibility)
6700 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6702 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
6705 if (CGM.getTriple().isOSBinFormatMachO())
6706 IvarOffsetGV->setSection("__DATA, __objc_ivar");
6707 return IvarOffsetGV;
6710 /// EmitIvarList - Emit the ivar list for the given
6711 /// implementation. The return value has type
6712 /// IvarListnfABIPtrTy.
6713 /// struct _ivar_t {
6714 /// unsigned [long] int *offset; // pointer to ivar offset location
6717 /// uint32_t alignment;
6720 /// struct _ivar_list_t {
6721 /// uint32 entsize; // sizeof(struct _ivar_t)
6723 /// struct _iver_t list[count];
6727 llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
6728 const ObjCImplementationDecl *ID) {
6730 ConstantInitBuilder builder(CGM);
6731 auto ivarList = builder.beginStruct();
6732 ivarList.addInt(ObjCTypes.IntTy,
6733 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy));
6734 auto ivarCountSlot = ivarList.addPlaceholder();
6735 auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy);
6737 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6738 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
6740 // FIXME. Consolidate this with similar code in GenerateClass.
6742 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
6743 IVD; IVD = IVD->getNextIvar()) {
6744 // Ignore unnamed bit-fields.
6745 if (!IVD->getDeclName())
6748 auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy);
6749 ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD,
6750 ComputeIvarBaseOffset(CGM, ID, IVD)));
6751 ivar.add(GetMethodVarName(IVD->getIdentifier()));
6752 ivar.add(GetMethodVarType(IVD));
6753 llvm::Type *FieldTy =
6754 CGM.getTypes().ConvertTypeForMem(IVD->getType());
6755 unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
6756 unsigned Align = CGM.getContext().getPreferredTypeAlign(
6757 IVD->getType().getTypePtr()) >> 3;
6758 Align = llvm::Log2_32(Align);
6759 ivar.addInt(ObjCTypes.IntTy, Align);
6760 // NOTE. Size of a bitfield does not match gcc's, because of the
6761 // way bitfields are treated special in each. But I am told that
6762 // 'size' for bitfield ivars is ignored by the runtime so it does
6763 // not matter. If it matters, there is enough info to get the
6765 ivar.addInt(ObjCTypes.IntTy, Size);
6766 ivar.finishAndAddTo(ivars);
6768 // Return null for empty list.
6769 if (ivars.empty()) {
6772 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
6775 auto ivarCount = ivars.size();
6776 ivars.finishAndAddTo(ivarList);
6777 ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount);
6779 const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_";
6780 llvm::GlobalVariable *GV =
6781 ivarList.finishAndCreateGlobal(Prefix + OID->getObjCRuntimeNameAsString(),
6782 CGM.getPointerAlign(), /*constant*/ false,
6783 llvm::GlobalValue::PrivateLinkage);
6784 if (CGM.getTriple().isOSBinFormatMachO())
6785 GV->setSection("__DATA, __objc_const");
6786 CGM.addCompilerUsedGlobal(GV);
6787 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
6790 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
6791 const ObjCProtocolDecl *PD) {
6792 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
6795 // We use the initializer as a marker of whether this is a forward
6796 // reference or not. At module finalization we add the empty
6797 // contents for protocols which were referenced but never defined.
6798 llvm::SmallString<64> Protocol;
6799 llvm::raw_svector_ostream(Protocol) << "\01l_OBJC_PROTOCOL_$_"
6800 << PD->getObjCRuntimeNameAsString();
6802 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
6803 false, llvm::GlobalValue::ExternalLinkage,
6805 if (!CGM.getTriple().isOSBinFormatMachO())
6806 Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol));
6812 /// GetOrEmitProtocol - Generate the protocol meta-data:
6814 /// struct _protocol_t {
6816 /// const char * const protocol_name;
6817 /// const struct _protocol_list_t * protocol_list; // super protocols
6818 /// const struct method_list_t * const instance_methods;
6819 /// const struct method_list_t * const class_methods;
6820 /// const struct method_list_t *optionalInstanceMethods;
6821 /// const struct method_list_t *optionalClassMethods;
6822 /// const struct _prop_list_t * properties;
6823 /// const uint32_t size; // sizeof(struct _protocol_t)
6824 /// const uint32_t flags; // = 0
6825 /// const char ** extendedMethodTypes;
6826 /// const char *demangledName;
6827 /// const struct _prop_list_t * class_properties;
6832 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
6833 const ObjCProtocolDecl *PD) {
6834 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
6836 // Early exit if a defining object has already been generated.
6837 if (Entry && Entry->hasInitializer())
6840 // Use the protocol definition, if there is one.
6841 assert(PD->hasDefinition() &&
6842 "emitting protocol metadata without definition");
6843 PD = PD->getDefinition();
6845 auto methodLists = ProtocolMethodLists::get(PD);
6847 ConstantInitBuilder builder(CGM);
6848 auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy);
6851 values.addNullPointer(ObjCTypes.ObjectPtrTy);
6852 values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
6853 values.add(EmitProtocolList("\01l_OBJC_$_PROTOCOL_REFS_"
6854 + PD->getObjCRuntimeNameAsString(),
6855 PD->protocol_begin(),
6856 PD->protocol_end()));
6857 values.add(methodLists.emitMethodList(this, PD,
6858 ProtocolMethodLists::RequiredInstanceMethods));
6859 values.add(methodLists.emitMethodList(this, PD,
6860 ProtocolMethodLists::RequiredClassMethods));
6861 values.add(methodLists.emitMethodList(this, PD,
6862 ProtocolMethodLists::OptionalInstanceMethods));
6863 values.add(methodLists.emitMethodList(this, PD,
6864 ProtocolMethodLists::OptionalClassMethods));
6865 values.add(EmitPropertyList(
6866 "\01l_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6867 nullptr, PD, ObjCTypes, false));
6869 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
6870 values.addInt(ObjCTypes.IntTy, Size);
6871 values.addInt(ObjCTypes.IntTy, 0);
6872 values.add(EmitProtocolMethodTypes("\01l_OBJC_$_PROTOCOL_METHOD_TYPES_"
6873 + PD->getObjCRuntimeNameAsString(),
6874 methodLists.emitExtendedTypesArray(this),
6877 // const char *demangledName;
6878 values.addNullPointer(ObjCTypes.Int8PtrTy);
6880 values.add(EmitPropertyList(
6881 "\01l_OBJC_$_CLASS_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6882 nullptr, PD, ObjCTypes, true));
6885 // Already created, fix the linkage and update the initializer.
6886 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
6887 values.finishAndSetAsInitializer(Entry);
6889 llvm::SmallString<64> symbolName;
6890 llvm::raw_svector_ostream(symbolName)
6891 << "\01l_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString();
6893 Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(),
6895 llvm::GlobalValue::WeakAnyLinkage);
6896 if (!CGM.getTriple().isOSBinFormatMachO())
6897 Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName));
6899 Protocols[PD->getIdentifier()] = Entry;
6901 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
6902 CGM.addUsedGlobal(Entry);
6904 // Use this protocol meta-data to build protocol list table in section
6905 // __DATA, __objc_protolist
6906 llvm::SmallString<64> ProtocolRef;
6907 llvm::raw_svector_ostream(ProtocolRef) << "\01l_OBJC_LABEL_PROTOCOL_$_"
6908 << PD->getObjCRuntimeNameAsString();
6910 llvm::GlobalVariable *PTGV =
6911 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
6912 false, llvm::GlobalValue::WeakAnyLinkage, Entry,
6914 if (!CGM.getTriple().isOSBinFormatMachO())
6915 PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef));
6917 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy));
6918 PTGV->setSection(GetSectionName("__objc_protolist",
6919 "coalesced,no_dead_strip"));
6920 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6921 CGM.addUsedGlobal(PTGV);
6925 /// EmitProtocolList - Generate protocol list meta-data:
6927 /// struct _protocol_list_t {
6928 /// long protocol_count; // Note, this is 32/64 bit
6929 /// struct _protocol_t[protocol_count];
6934 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
6935 ObjCProtocolDecl::protocol_iterator begin,
6936 ObjCProtocolDecl::protocol_iterator end) {
6937 SmallVector<llvm::Constant *, 16> ProtocolRefs;
6939 // Just return null for empty protocol lists
6941 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
6943 // FIXME: We shouldn't need to do this lookup here, should we?
6944 SmallString<256> TmpName;
6945 Name.toVector(TmpName);
6946 llvm::GlobalVariable *GV =
6947 CGM.getModule().getGlobalVariable(TmpName.str(), true);
6949 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
6951 ConstantInitBuilder builder(CGM);
6952 auto values = builder.beginStruct();
6953 auto countSlot = values.addPlaceholder();
6955 // A null-terminated array of protocols.
6956 auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy);
6957 for (; begin != end; ++begin)
6958 array.add(GetProtocolRef(*begin)); // Implemented???
6959 auto count = array.size();
6960 array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy);
6962 array.finishAndAddTo(values);
6963 values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
6965 GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
6967 llvm::GlobalValue::PrivateLinkage);
6968 if (CGM.getTriple().isOSBinFormatMachO())
6969 GV->setSection("__DATA, __objc_const");
6970 CGM.addCompilerUsedGlobal(GV);
6971 return llvm::ConstantExpr::getBitCast(GV,
6972 ObjCTypes.ProtocolListnfABIPtrTy);
6975 /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
6976 /// This code gen. amounts to generating code for:
6978 /// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
6981 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
6982 CodeGen::CodeGenFunction &CGF,
6984 llvm::Value *BaseValue,
6985 const ObjCIvarDecl *Ivar,
6986 unsigned CVRQualifiers) {
6987 ObjCInterfaceDecl *ID = ObjectTy->getAs<ObjCObjectType>()->getInterface();
6988 llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
6989 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
6993 llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset(
6994 CodeGen::CodeGenFunction &CGF,
6995 const ObjCInterfaceDecl *Interface,
6996 const ObjCIvarDecl *Ivar) {
6997 llvm::Value *IvarOffsetValue = ObjCIvarOffsetVariable(Interface, Ivar);
6998 IvarOffsetValue = CGF.Builder.CreateAlignedLoad(IvarOffsetValue,
6999 CGF.getSizeAlign(), "ivar");
7000 if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
7001 cast<llvm::LoadInst>(IvarOffsetValue)
7002 ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7003 llvm::MDNode::get(VMContext, None));
7005 // This could be 32bit int or 64bit integer depending on the architecture.
7006 // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
7007 // as this is what caller always expects.
7008 if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
7009 IvarOffsetValue = CGF.Builder.CreateIntCast(
7010 IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
7011 return IvarOffsetValue;
7014 static void appendSelectorForMessageRefTable(std::string &buffer,
7015 Selector selector) {
7016 if (selector.isUnarySelector()) {
7017 buffer += selector.getNameForSlot(0);
7021 for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
7022 buffer += selector.getNameForSlot(i);
7027 /// Emit a "vtable" message send. We emit a weak hidden-visibility
7028 /// struct, initially containing the selector pointer and a pointer to
7029 /// a "fixup" variant of the appropriate objc_msgSend. To call, we
7030 /// load and call the function pointer, passing the address of the
7031 /// struct as the second parameter. The runtime determines whether
7032 /// the selector is currently emitted using vtable dispatch; if so, it
7033 /// substitutes a stub function which simply tail-calls through the
7034 /// appropriate vtable slot, and if not, it substitues a stub function
7035 /// which tail-calls objc_msgSend. Both stubs adjust the selector
7036 /// argument to correctly point to the selector.
7038 CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
7039 ReturnValueSlot returnSlot,
7040 QualType resultType,
7045 const CallArgList &formalArgs,
7046 const ObjCMethodDecl *method) {
7047 // Compute the actual arguments.
7050 // First argument: the receiver / super-call structure.
7052 arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
7053 args.add(RValue::get(arg0), arg0Type);
7055 // Second argument: a pointer to the message ref structure. Leave
7056 // the actual argument value blank for now.
7057 args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);
7059 args.insert(args.end(), formalArgs.begin(), formalArgs.end());
7061 MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);
7063 NullReturnState nullReturn;
7065 // Find the function to call and the mangled name for the message
7066 // ref structure. Using a different mangled name wouldn't actually
7067 // be a problem; it would just be a waste.
7069 // The runtime currently never uses vtable dispatch for anything
7070 // except normal, non-super message-sends.
7071 // FIXME: don't use this for that.
7072 llvm::Constant *fn = nullptr;
7073 std::string messageRefName("\01l_");
7074 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
7076 fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
7077 messageRefName += "objc_msgSendSuper2_stret_fixup";
7079 nullReturn.init(CGF, arg0);
7080 fn = ObjCTypes.getMessageSendStretFixupFn();
7081 messageRefName += "objc_msgSend_stret_fixup";
7083 } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
7084 fn = ObjCTypes.getMessageSendFpretFixupFn();
7085 messageRefName += "objc_msgSend_fpret_fixup";
7088 fn = ObjCTypes.getMessageSendSuper2FixupFn();
7089 messageRefName += "objc_msgSendSuper2_fixup";
7091 fn = ObjCTypes.getMessageSendFixupFn();
7092 messageRefName += "objc_msgSend_fixup";
7095 assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend");
7096 messageRefName += '_';
7098 // Append the selector name, except use underscores anywhere we
7099 // would have used colons.
7100 appendSelectorForMessageRefTable(messageRefName, selector);
7102 llvm::GlobalVariable *messageRef
7103 = CGM.getModule().getGlobalVariable(messageRefName);
7105 // Build the message ref structure.
7106 ConstantInitBuilder builder(CGM);
7107 auto values = builder.beginStruct();
7109 values.add(GetMethodVarName(selector));
7110 messageRef = values.finishAndCreateGlobal(messageRefName,
7111 CharUnits::fromQuantity(16),
7113 llvm::GlobalValue::WeakAnyLinkage);
7114 messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
7115 messageRef->setSection(GetSectionName("__objc_msgrefs", "coalesced"));
7118 bool requiresnullCheck = false;
7119 if (CGM.getLangOpts().ObjCAutoRefCount && method)
7120 for (const auto *ParamDecl : method->parameters()) {
7121 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
7122 if (!nullReturn.NullBB)
7123 nullReturn.init(CGF, arg0);
7124 requiresnullCheck = true;
7130 Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
7131 CGF.getPointerAlign());
7133 // Update the message ref argument.
7134 args[1].setRValue(RValue::get(mref.getPointer()));
7136 // Load the function to call from the message ref table.
7137 Address calleeAddr =
7138 CGF.Builder.CreateStructGEP(mref, 0, CharUnits::Zero());
7139 llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn");
7141 calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
7142 CGCallee callee(CGCalleeInfo(), calleePtr);
7144 RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
7145 return nullReturn.complete(CGF, returnSlot, result, resultType, formalArgs,
7146 requiresnullCheck ? method : nullptr);
7149 /// Generate code for a message send expression in the nonfragile abi.
7151 CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
7152 ReturnValueSlot Return,
7153 QualType ResultType,
7155 llvm::Value *Receiver,
7156 const CallArgList &CallArgs,
7157 const ObjCInterfaceDecl *Class,
7158 const ObjCMethodDecl *Method) {
7159 return isVTableDispatchedSelector(Sel)
7160 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7161 Receiver, CGF.getContext().getObjCIdType(),
7162 false, CallArgs, Method)
7163 : EmitMessageSend(CGF, Return, ResultType,
7164 EmitSelector(CGF, Sel),
7165 Receiver, CGF.getContext().getObjCIdType(),
7166 false, CallArgs, Method, Class, ObjCTypes);
7170 CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID,
7172 ForDefinition_t isForDefinition) {
7174 (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix());
7175 return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(),
7177 ID->isWeakImported(),
7179 && CGM.getTriple().isOSBinFormatCOFF()
7180 && ID->hasAttr<DLLImportAttr>());
7184 CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
7185 ForDefinition_t IsForDefinition,
7186 bool Weak, bool DLLImport) {
7187 llvm::GlobalValue::LinkageTypes L =
7188 Weak ? llvm::GlobalValue::ExternalWeakLinkage
7189 : llvm::GlobalValue::ExternalLinkage;
7191 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
7192 if (!GV || GV->getType() != ObjCTypes.ClassnfABITy->getPointerTo()) {
7193 auto *NewGV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, L,
7197 NewGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
7200 GV->replaceAllUsesWith(
7201 llvm::ConstantExpr::getBitCast(NewGV, GV->getType()));
7202 GV->eraseFromParent();
7205 CGM.getModule().getGlobalList().push_back(GV);
7208 assert(GV->getLinkage() == L);
7213 CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
7215 const ObjCInterfaceDecl *ID) {
7216 CharUnits Align = CGF.getPointerAlign();
7217 llvm::GlobalVariable *&Entry = ClassReferences[II];
7220 llvm::Constant *ClassGV;
7222 ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7224 ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(),
7228 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7229 false, llvm::GlobalValue::PrivateLinkage,
7230 ClassGV, "OBJC_CLASSLIST_REFERENCES_$_");
7231 Entry->setAlignment(Align.getQuantity());
7232 Entry->setSection(GetSectionName("__objc_classrefs",
7233 "regular,no_dead_strip"));
7234 CGM.addCompilerUsedGlobal(Entry);
7236 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7239 llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
7240 const ObjCInterfaceDecl *ID) {
7241 // If the class has the objc_runtime_visible attribute, we need to
7242 // use the Objective-C runtime to get the class.
7243 if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
7244 return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
7246 return EmitClassRefFromId(CGF, ID->getIdentifier(), ID);
7249 llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
7250 CodeGenFunction &CGF) {
7251 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
7252 return EmitClassRefFromId(CGF, II, nullptr);
7256 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
7257 const ObjCInterfaceDecl *ID) {
7258 CharUnits Align = CGF.getPointerAlign();
7259 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
7262 auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7263 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7264 false, llvm::GlobalValue::PrivateLinkage,
7265 ClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
7266 Entry->setAlignment(Align.getQuantity());
7267 Entry->setSection(GetSectionName("__objc_superrefs",
7268 "regular,no_dead_strip"));
7269 CGM.addCompilerUsedGlobal(Entry);
7271 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7274 /// EmitMetaClassRef - Return a Value * of the address of _class_t
7277 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
7278 const ObjCInterfaceDecl *ID,
7280 CharUnits Align = CGF.getPointerAlign();
7281 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
7283 auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition);
7285 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7286 false, llvm::GlobalValue::PrivateLinkage,
7287 MetaClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
7288 Entry->setAlignment(Align.getQuantity());
7290 Entry->setSection(GetSectionName("__objc_superrefs",
7291 "regular,no_dead_strip"));
7292 CGM.addCompilerUsedGlobal(Entry);
7295 return CGF.Builder.CreateAlignedLoad(Entry, Align);
7298 /// GetClass - Return a reference to the class for the given interface
7300 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
7301 const ObjCInterfaceDecl *ID) {
7302 if (ID->isWeakImported()) {
7303 auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7305 assert(!isa<llvm::GlobalVariable>(ClassGV) ||
7306 cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage());
7309 return EmitClassRef(CGF, ID);
7312 /// Generates a message send where the super is the receiver. This is
7313 /// a message send to self with special delivery semantics indicating
7314 /// which class's method should be called.
7316 CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
7317 ReturnValueSlot Return,
7318 QualType ResultType,
7320 const ObjCInterfaceDecl *Class,
7321 bool isCategoryImpl,
7322 llvm::Value *Receiver,
7323 bool IsClassMessage,
7324 const CodeGen::CallArgList &CallArgs,
7325 const ObjCMethodDecl *Method) {
7327 // Create and init a super structure; this is a (receiver, class)
7328 // pair we will pass to objc_msgSendSuper.
7330 CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
7333 llvm::Value *ReceiverAsObject =
7334 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
7335 CGF.Builder.CreateStore(
7337 CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
7339 // If this is a class message the metaclass is passed as the target.
7340 llvm::Value *Target;
7342 Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported());
7344 Target = EmitSuperClassRef(CGF, Class);
7346 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
7348 llvm::Type *ClassTy =
7349 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
7350 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
7351 CGF.Builder.CreateStore(
7352 Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1, CGF.getPointerSize()));
7354 return (isVTableDispatchedSelector(Sel))
7355 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7356 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7357 true, CallArgs, Method)
7358 : EmitMessageSend(CGF, Return, ResultType,
7359 EmitSelector(CGF, Sel),
7360 ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7361 true, CallArgs, Method, Class, ObjCTypes);
7364 llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
7366 Address Addr = EmitSelectorAddr(CGF, Sel);
7368 llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr);
7369 LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7370 llvm::MDNode::get(VMContext, None));
7374 Address CGObjCNonFragileABIMac::EmitSelectorAddr(CodeGenFunction &CGF,
7376 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
7378 CharUnits Align = CGF.getPointerAlign();
7380 llvm::Constant *Casted =
7381 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
7382 ObjCTypes.SelectorPtrTy);
7383 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.SelectorPtrTy,
7384 false, llvm::GlobalValue::PrivateLinkage,
7385 Casted, "OBJC_SELECTOR_REFERENCES_");
7386 Entry->setExternallyInitialized(true);
7387 Entry->setSection(GetSectionName("__objc_selrefs",
7388 "literal_pointers,no_dead_strip"));
7389 Entry->setAlignment(Align.getQuantity());
7390 CGM.addCompilerUsedGlobal(Entry);
7393 return Address(Entry, Align);
7396 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
7397 /// objc_assign_ivar (id src, id *dst, ptrdiff_t)
7399 void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
7402 llvm::Value *ivarOffset) {
7403 llvm::Type * SrcTy = src->getType();
7404 if (!isa<llvm::PointerType>(SrcTy)) {
7405 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7406 assert(Size <= 8 && "does not support size > 8");
7407 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7408 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7409 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7411 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7412 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7413 llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
7414 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
7417 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
7418 /// objc_assign_strongCast (id src, id *dst)
7420 void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
7421 CodeGen::CodeGenFunction &CGF,
7422 llvm::Value *src, Address dst) {
7423 llvm::Type * SrcTy = src->getType();
7424 if (!isa<llvm::PointerType>(SrcTy)) {
7425 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7426 assert(Size <= 8 && "does not support size > 8");
7427 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7428 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7429 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7431 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7432 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7433 llvm::Value *args[] = { src, dst.getPointer() };
7434 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
7435 args, "weakassign");
7438 void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
7439 CodeGen::CodeGenFunction &CGF,
7442 llvm::Value *Size) {
7443 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
7444 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
7445 llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), Size };
7446 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
7449 /// EmitObjCWeakRead - Code gen for loading value of a __weak
7450 /// object: objc_read_weak (id *src)
7452 llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
7453 CodeGen::CodeGenFunction &CGF,
7454 Address AddrWeakObj) {
7455 llvm::Type *DestTy = AddrWeakObj.getElementType();
7456 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
7457 llvm::Value *read_weak =
7458 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
7459 AddrWeakObj.getPointer(), "weakread");
7460 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
7464 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
7465 /// objc_assign_weak (id src, id *dst)
7467 void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
7468 llvm::Value *src, Address dst) {
7469 llvm::Type * SrcTy = src->getType();
7470 if (!isa<llvm::PointerType>(SrcTy)) {
7471 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7472 assert(Size <= 8 && "does not support size > 8");
7473 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7474 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7475 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7477 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7478 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7479 llvm::Value *args[] = { src, dst.getPointer() };
7480 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
7481 args, "weakassign");
7484 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
7485 /// objc_assign_global (id src, id *dst)
7487 void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
7488 llvm::Value *src, Address dst,
7490 llvm::Type * SrcTy = src->getType();
7491 if (!isa<llvm::PointerType>(SrcTy)) {
7492 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7493 assert(Size <= 8 && "does not support size > 8");
7494 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7495 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7496 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7498 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7499 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7500 llvm::Value *args[] = { src, dst.getPointer() };
7502 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
7503 args, "globalassign");
7505 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
7506 args, "threadlocalassign");
7510 CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
7511 const ObjCAtSynchronizedStmt &S) {
7512 EmitAtSynchronizedStmt(CGF, S,
7513 cast<llvm::Function>(ObjCTypes.getSyncEnterFn()),
7514 cast<llvm::Function>(ObjCTypes.getSyncExitFn()));
7518 CGObjCNonFragileABIMac::GetEHType(QualType T) {
7519 // There's a particular fixed type info for 'id'.
7520 if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
7521 auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
7524 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7525 llvm::GlobalValue::ExternalLinkage, nullptr,
7527 if (CGM.getTriple().isOSBinFormatCOFF())
7528 IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id"));
7533 // All other types should be Objective-C interface pointer types.
7534 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
7535 assert(PT && "Invalid @catch type.");
7537 const ObjCInterfaceType *IT = PT->getInterfaceType();
7538 assert(IT && "Invalid @catch type.");
7540 return GetInterfaceEHType(IT->getDecl(), NotForDefinition);
7543 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
7544 const ObjCAtTryStmt &S) {
7545 EmitTryCatchStmt(CGF, S,
7546 cast<llvm::Function>(ObjCTypes.getObjCBeginCatchFn()),
7547 cast<llvm::Function>(ObjCTypes.getObjCEndCatchFn()),
7548 cast<llvm::Function>(ObjCTypes.getExceptionRethrowFn()));
7551 /// EmitThrowStmt - Generate code for a throw statement.
7552 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
7553 const ObjCAtThrowStmt &S,
7554 bool ClearInsertionPoint) {
7555 if (const Expr *ThrowExpr = S.getThrowExpr()) {
7556 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
7557 Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7558 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception)
7559 .setDoesNotReturn();
7561 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn())
7562 .setDoesNotReturn();
7565 CGF.Builder.CreateUnreachable();
7566 if (ClearInsertionPoint)
7567 CGF.Builder.ClearInsertionPoint();
7571 CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
7572 ForDefinition_t IsForDefinition) {
7573 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
7574 StringRef ClassName = ID->getObjCRuntimeNameAsString();
7576 // If we don't need a definition, return the entry if found or check
7577 // if we use an external reference.
7578 if (!IsForDefinition) {
7582 // If this type (or a super class) has the __objc_exception__
7583 // attribute, emit an external reference.
7584 if (hasObjCExceptionAttribute(CGM.getContext(), ID)) {
7585 std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str();
7586 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
7587 false, llvm::GlobalValue::ExternalLinkage,
7588 nullptr, EHTypeName);
7589 CGM.setGVProperties(Entry, ID);
7594 // Otherwise we need to either make a new entry or fill in the initializer.
7595 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
7597 std::string VTableName = "objc_ehtype_vtable";
7598 auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName);
7601 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false,
7602 llvm::GlobalValue::ExternalLinkage, nullptr,
7604 if (CGM.getTriple().isOSBinFormatCOFF())
7605 VTableGV->setDLLStorageClass(getStorage(CGM, VTableName));
7608 llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
7609 ConstantInitBuilder builder(CGM);
7610 auto values = builder.beginStruct(ObjCTypes.EHTypeTy);
7612 llvm::ConstantExpr::getInBoundsGetElementPtr(VTableGV->getValueType(),
7613 VTableGV, VTableIdx));
7614 values.add(GetClassName(ClassName));
7615 values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition));
7617 llvm::GlobalValue::LinkageTypes L = IsForDefinition
7618 ? llvm::GlobalValue::ExternalLinkage
7619 : llvm::GlobalValue::WeakAnyLinkage;
7621 values.finishAndSetAsInitializer(Entry);
7622 Entry->setAlignment(CGM.getPointerAlign().getQuantity());
7624 Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName,
7625 CGM.getPointerAlign(),
7628 if (hasObjCExceptionAttribute(CGM.getContext(), ID))
7629 CGM.setGVProperties(Entry, ID);
7631 assert(Entry->getLinkage() == L);
7633 if (!CGM.getTriple().isOSBinFormatCOFF())
7634 if (ID->getVisibility() == HiddenVisibility)
7635 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7637 if (IsForDefinition)
7638 if (CGM.getTriple().isOSBinFormatMachO())
7639 Entry->setSection("__DATA,__objc_const");
7646 CodeGen::CGObjCRuntime *
7647 CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
7648 switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
7649 case ObjCRuntime::FragileMacOSX:
7650 return new CGObjCMac(CGM);
7652 case ObjCRuntime::MacOSX:
7653 case ObjCRuntime::iOS:
7654 case ObjCRuntime::WatchOS:
7655 return new CGObjCNonFragileABIMac(CGM);
7657 case ObjCRuntime::GNUstep:
7658 case ObjCRuntime::GCC:
7659 case ObjCRuntime::ObjFW:
7660 llvm_unreachable("these runtimes are not Mac runtimes");
7662 llvm_unreachable("bad runtime");