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 //===----------------------------------------------------------------------===//
14 #include "CGObjCRuntime.h"
16 #include "CGCleanup.h"
17 #include "CGRecordLayout.h"
18 #include "CodeGenFunction.h"
19 #include "CodeGenModule.h"
20 #include "clang/AST/ASTContext.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/RecordLayout.h"
24 #include "clang/AST/StmtObjC.h"
25 #include "clang/Basic/LangOptions.h"
26 #include "clang/CodeGen/CGFunctionInfo.h"
27 #include "clang/Frontend/CodeGenOptions.h"
28 #include "llvm/ADT/DenseSet.h"
29 #include "llvm/ADT/SetVector.h"
30 #include "llvm/ADT/SmallPtrSet.h"
31 #include "llvm/ADT/SmallString.h"
32 #include "llvm/IR/CallSite.h"
33 #include "llvm/IR/DataLayout.h"
34 #include "llvm/IR/InlineAsm.h"
35 #include "llvm/IR/IntrinsicInst.h"
36 #include "llvm/IR/LLVMContext.h"
37 #include "llvm/IR/Module.h"
38 #include "llvm/Support/raw_ostream.h"
41 using namespace clang;
42 using namespace CodeGen;
46 // FIXME: We should find a nicer way to make the labels for metadata, string
47 // concatenation is lame.
49 class ObjCCommonTypesHelper {
51 llvm::LLVMContext &VMContext;
54 // The types of these functions don't really matter because we
55 // should always bitcast before calling them.
57 /// id objc_msgSend (id, SEL, ...)
59 /// The default messenger, used for sends whose ABI is unchanged from
60 /// the all-integer/pointer case.
61 llvm::Constant *getMessageSendFn() const {
62 // Add the non-lazy-bind attribute, since objc_msgSend is likely to
64 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
66 CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
69 llvm::AttributeSet::get(CGM.getLLVMContext(),
70 llvm::AttributeSet::FunctionIndex,
71 llvm::Attribute::NonLazyBind));
74 /// void objc_msgSend_stret (id, SEL, ...)
76 /// The messenger used when the return value is an aggregate returned
77 /// by indirect reference in the first argument, and therefore the
78 /// self and selector parameters are shifted over by one.
79 llvm::Constant *getMessageSendStretFn() const {
80 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
81 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
83 "objc_msgSend_stret");
87 /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
89 /// The messenger used when the return value is returned on the x87
90 /// floating-point stack; without a special entrypoint, the nil case
91 /// would be unbalanced.
92 llvm::Constant *getMessageSendFpretFn() const {
93 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
94 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
96 "objc_msgSend_fpret");
100 /// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
102 /// The messenger used when the return value is returned in two values on the
103 /// x87 floating point stack; without a special entrypoint, the nil case
104 /// would be unbalanced. Only used on 64-bit X86.
105 llvm::Constant *getMessageSendFp2retFn() const {
106 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
107 llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext);
108 llvm::Type *resultType =
109 llvm::StructType::get(longDoubleType, longDoubleType, NULL);
111 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType,
113 "objc_msgSend_fp2ret");
116 /// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
118 /// The messenger used for super calls, which have different dispatch
119 /// semantics. The class passed is the superclass of the current
121 llvm::Constant *getMessageSendSuperFn() const {
122 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
123 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
125 "objc_msgSendSuper");
128 /// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
130 /// A slightly different messenger used for super calls. The class
131 /// passed is the current class.
132 llvm::Constant *getMessageSendSuperFn2() const {
133 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
134 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
136 "objc_msgSendSuper2");
139 /// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super,
142 /// The messenger used for super calls which return an aggregate indirectly.
143 llvm::Constant *getMessageSendSuperStretFn() const {
144 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
145 return CGM.CreateRuntimeFunction(
146 llvm::FunctionType::get(CGM.VoidTy, params, true),
147 "objc_msgSendSuper_stret");
150 /// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
153 /// objc_msgSendSuper_stret with the super2 semantics.
154 llvm::Constant *getMessageSendSuperStretFn2() const {
155 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
156 return CGM.CreateRuntimeFunction(
157 llvm::FunctionType::get(CGM.VoidTy, params, true),
158 "objc_msgSendSuper2_stret");
161 llvm::Constant *getMessageSendSuperFpretFn() const {
162 // There is no objc_msgSendSuper_fpret? How can that work?
163 return getMessageSendSuperFn();
166 llvm::Constant *getMessageSendSuperFpretFn2() const {
167 // There is no objc_msgSendSuper_fpret? How can that work?
168 return getMessageSendSuperFn2();
172 CodeGen::CodeGenModule &CGM;
175 llvm::Type *ShortTy, *IntTy, *LongTy, *LongLongTy;
176 llvm::Type *Int8PtrTy, *Int8PtrPtrTy;
177 llvm::Type *IvarOffsetVarTy;
179 /// ObjectPtrTy - LLVM type for object handles (typeof(id))
180 llvm::Type *ObjectPtrTy;
182 /// PtrObjectPtrTy - LLVM type for id *
183 llvm::Type *PtrObjectPtrTy;
185 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
186 llvm::Type *SelectorPtrTy;
189 /// ProtocolPtrTy - LLVM type for external protocol handles
190 /// (typeof(Protocol))
191 llvm::Type *ExternalProtocolPtrTy;
194 llvm::Type *getExternalProtocolPtrTy() {
195 if (!ExternalProtocolPtrTy) {
196 // FIXME: It would be nice to unify this with the opaque type, so that the
197 // IR comes out a bit cleaner.
198 CodeGen::CodeGenTypes &Types = CGM.getTypes();
199 ASTContext &Ctx = CGM.getContext();
200 llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
201 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
204 return ExternalProtocolPtrTy;
207 // SuperCTy - clang type for struct objc_super.
209 // SuperPtrCTy - clang type for struct objc_super *.
210 QualType SuperPtrCTy;
212 /// SuperTy - LLVM type for struct objc_super.
213 llvm::StructType *SuperTy;
214 /// SuperPtrTy - LLVM type for struct objc_super *.
215 llvm::Type *SuperPtrTy;
217 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
218 /// in GCC parlance).
219 llvm::StructType *PropertyTy;
221 /// PropertyListTy - LLVM type for struct objc_property_list
222 /// (_prop_list_t in GCC parlance).
223 llvm::StructType *PropertyListTy;
224 /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
225 llvm::Type *PropertyListPtrTy;
227 // MethodTy - LLVM type for struct objc_method.
228 llvm::StructType *MethodTy;
230 /// CacheTy - LLVM type for struct objc_cache.
232 /// CachePtrTy - LLVM type for struct objc_cache *.
233 llvm::Type *CachePtrTy;
235 llvm::Constant *getGetPropertyFn() {
236 CodeGen::CodeGenTypes &Types = CGM.getTypes();
237 ASTContext &Ctx = CGM.getContext();
238 // id objc_getProperty (id, SEL, ptrdiff_t, bool)
239 SmallVector<CanQualType,4> Params;
240 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
241 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
242 Params.push_back(IdType);
243 Params.push_back(SelType);
244 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
245 Params.push_back(Ctx.BoolTy);
246 llvm::FunctionType *FTy =
247 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(IdType, false, Params,
248 FunctionType::ExtInfo(),
250 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
253 llvm::Constant *getSetPropertyFn() {
254 CodeGen::CodeGenTypes &Types = CGM.getTypes();
255 ASTContext &Ctx = CGM.getContext();
256 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
257 SmallVector<CanQualType,6> Params;
258 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
259 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
260 Params.push_back(IdType);
261 Params.push_back(SelType);
262 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
263 Params.push_back(IdType);
264 Params.push_back(Ctx.BoolTy);
265 Params.push_back(Ctx.BoolTy);
266 llvm::FunctionType *FTy =
267 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy, false,
269 FunctionType::ExtInfo(),
271 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
274 llvm::Constant *getOptimizedSetPropertyFn(bool atomic, bool copy) {
275 CodeGen::CodeGenTypes &Types = CGM.getTypes();
276 ASTContext &Ctx = CGM.getContext();
277 // void objc_setProperty_atomic(id self, SEL _cmd,
278 // id newValue, ptrdiff_t offset);
279 // void objc_setProperty_nonatomic(id self, SEL _cmd,
280 // id newValue, ptrdiff_t offset);
281 // void objc_setProperty_atomic_copy(id self, SEL _cmd,
282 // id newValue, ptrdiff_t offset);
283 // void objc_setProperty_nonatomic_copy(id self, SEL _cmd,
284 // id newValue, ptrdiff_t offset);
286 SmallVector<CanQualType,4> Params;
287 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
288 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
289 Params.push_back(IdType);
290 Params.push_back(SelType);
291 Params.push_back(IdType);
292 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
293 llvm::FunctionType *FTy =
294 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy, false,
296 FunctionType::ExtInfo(),
300 name = "objc_setProperty_atomic_copy";
301 else if (atomic && !copy)
302 name = "objc_setProperty_atomic";
303 else if (!atomic && copy)
304 name = "objc_setProperty_nonatomic_copy";
306 name = "objc_setProperty_nonatomic";
308 return CGM.CreateRuntimeFunction(FTy, name);
311 llvm::Constant *getCopyStructFn() {
312 CodeGen::CodeGenTypes &Types = CGM.getTypes();
313 ASTContext &Ctx = CGM.getContext();
314 // void objc_copyStruct (void *, const void *, size_t, bool, bool)
315 SmallVector<CanQualType,5> Params;
316 Params.push_back(Ctx.VoidPtrTy);
317 Params.push_back(Ctx.VoidPtrTy);
318 Params.push_back(Ctx.LongTy);
319 Params.push_back(Ctx.BoolTy);
320 Params.push_back(Ctx.BoolTy);
321 llvm::FunctionType *FTy =
322 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy, false,
324 FunctionType::ExtInfo(),
326 return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
329 /// This routine declares and returns address of:
330 /// void objc_copyCppObjectAtomic(
331 /// void *dest, const void *src,
332 /// void (*copyHelper) (void *dest, const void *source));
333 llvm::Constant *getCppAtomicObjectFunction() {
334 CodeGen::CodeGenTypes &Types = CGM.getTypes();
335 ASTContext &Ctx = CGM.getContext();
336 /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
337 SmallVector<CanQualType,3> Params;
338 Params.push_back(Ctx.VoidPtrTy);
339 Params.push_back(Ctx.VoidPtrTy);
340 Params.push_back(Ctx.VoidPtrTy);
341 llvm::FunctionType *FTy =
342 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy, false,
344 FunctionType::ExtInfo(),
346 return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
349 llvm::Constant *getEnumerationMutationFn() {
350 CodeGen::CodeGenTypes &Types = CGM.getTypes();
351 ASTContext &Ctx = CGM.getContext();
352 // void objc_enumerationMutation (id)
353 SmallVector<CanQualType,1> Params;
354 Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
355 llvm::FunctionType *FTy =
356 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy, false,
358 FunctionType::ExtInfo(),
360 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
363 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
364 llvm::Constant *getGcReadWeakFn() {
365 // id objc_read_weak (id *)
366 llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
367 llvm::FunctionType *FTy =
368 llvm::FunctionType::get(ObjectPtrTy, args, false);
369 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
372 /// GcAssignWeakFn -- LLVM objc_assign_weak function.
373 llvm::Constant *getGcAssignWeakFn() {
374 // id objc_assign_weak (id, id *)
375 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
376 llvm::FunctionType *FTy =
377 llvm::FunctionType::get(ObjectPtrTy, args, false);
378 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
381 /// GcAssignGlobalFn -- LLVM objc_assign_global function.
382 llvm::Constant *getGcAssignGlobalFn() {
383 // id objc_assign_global(id, id *)
384 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
385 llvm::FunctionType *FTy =
386 llvm::FunctionType::get(ObjectPtrTy, args, false);
387 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
390 /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
391 llvm::Constant *getGcAssignThreadLocalFn() {
392 // id objc_assign_threadlocal(id src, id * dest)
393 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
394 llvm::FunctionType *FTy =
395 llvm::FunctionType::get(ObjectPtrTy, args, false);
396 return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
399 /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
400 llvm::Constant *getGcAssignIvarFn() {
401 // id objc_assign_ivar(id, id *, ptrdiff_t)
402 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
404 llvm::FunctionType *FTy =
405 llvm::FunctionType::get(ObjectPtrTy, args, false);
406 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
409 /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
410 llvm::Constant *GcMemmoveCollectableFn() {
411 // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
412 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
413 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
414 return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
417 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
418 llvm::Constant *getGcAssignStrongCastFn() {
419 // id objc_assign_strongCast(id, id *)
420 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
421 llvm::FunctionType *FTy =
422 llvm::FunctionType::get(ObjectPtrTy, args, false);
423 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
426 /// ExceptionThrowFn - LLVM objc_exception_throw function.
427 llvm::Constant *getExceptionThrowFn() {
428 // void objc_exception_throw(id)
429 llvm::Type *args[] = { ObjectPtrTy };
430 llvm::FunctionType *FTy =
431 llvm::FunctionType::get(CGM.VoidTy, args, false);
432 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
435 /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
436 llvm::Constant *getExceptionRethrowFn() {
437 // void objc_exception_rethrow(void)
438 llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
439 return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
442 /// SyncEnterFn - LLVM object_sync_enter function.
443 llvm::Constant *getSyncEnterFn() {
444 // int objc_sync_enter (id)
445 llvm::Type *args[] = { ObjectPtrTy };
446 llvm::FunctionType *FTy =
447 llvm::FunctionType::get(CGM.IntTy, args, false);
448 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
451 /// SyncExitFn - LLVM object_sync_exit function.
452 llvm::Constant *getSyncExitFn() {
453 // int objc_sync_exit (id)
454 llvm::Type *args[] = { ObjectPtrTy };
455 llvm::FunctionType *FTy =
456 llvm::FunctionType::get(CGM.IntTy, args, false);
457 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
460 llvm::Constant *getSendFn(bool IsSuper) const {
461 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
464 llvm::Constant *getSendFn2(bool IsSuper) const {
465 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
468 llvm::Constant *getSendStretFn(bool IsSuper) const {
469 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
472 llvm::Constant *getSendStretFn2(bool IsSuper) const {
473 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
476 llvm::Constant *getSendFpretFn(bool IsSuper) const {
477 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
480 llvm::Constant *getSendFpretFn2(bool IsSuper) const {
481 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
484 llvm::Constant *getSendFp2retFn(bool IsSuper) const {
485 return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
488 llvm::Constant *getSendFp2RetFn2(bool IsSuper) const {
489 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn();
492 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
493 ~ObjCCommonTypesHelper(){}
496 /// ObjCTypesHelper - Helper class that encapsulates lazy
497 /// construction of varies types used during ObjC generation.
498 class ObjCTypesHelper : public ObjCCommonTypesHelper {
500 /// SymtabTy - LLVM type for struct objc_symtab.
501 llvm::StructType *SymtabTy;
502 /// SymtabPtrTy - LLVM type for struct objc_symtab *.
503 llvm::Type *SymtabPtrTy;
504 /// ModuleTy - LLVM type for struct objc_module.
505 llvm::StructType *ModuleTy;
507 /// ProtocolTy - LLVM type for struct objc_protocol.
508 llvm::StructType *ProtocolTy;
509 /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
510 llvm::Type *ProtocolPtrTy;
511 /// ProtocolExtensionTy - LLVM type for struct
512 /// objc_protocol_extension.
513 llvm::StructType *ProtocolExtensionTy;
514 /// ProtocolExtensionTy - LLVM type for struct
515 /// objc_protocol_extension *.
516 llvm::Type *ProtocolExtensionPtrTy;
517 /// MethodDescriptionTy - LLVM type for struct
518 /// objc_method_description.
519 llvm::StructType *MethodDescriptionTy;
520 /// MethodDescriptionListTy - LLVM type for struct
521 /// objc_method_description_list.
522 llvm::StructType *MethodDescriptionListTy;
523 /// MethodDescriptionListPtrTy - LLVM type for struct
524 /// objc_method_description_list *.
525 llvm::Type *MethodDescriptionListPtrTy;
526 /// ProtocolListTy - LLVM type for struct objc_property_list.
527 llvm::StructType *ProtocolListTy;
528 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
529 llvm::Type *ProtocolListPtrTy;
530 /// CategoryTy - LLVM type for struct objc_category.
531 llvm::StructType *CategoryTy;
532 /// ClassTy - LLVM type for struct objc_class.
533 llvm::StructType *ClassTy;
534 /// ClassPtrTy - LLVM type for struct objc_class *.
535 llvm::Type *ClassPtrTy;
536 /// ClassExtensionTy - LLVM type for struct objc_class_ext.
537 llvm::StructType *ClassExtensionTy;
538 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
539 llvm::Type *ClassExtensionPtrTy;
540 // IvarTy - LLVM type for struct objc_ivar.
541 llvm::StructType *IvarTy;
542 /// IvarListTy - LLVM type for struct objc_ivar_list.
543 llvm::Type *IvarListTy;
544 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
545 llvm::Type *IvarListPtrTy;
546 /// MethodListTy - LLVM type for struct objc_method_list.
547 llvm::Type *MethodListTy;
548 /// MethodListPtrTy - LLVM type for struct objc_method_list *.
549 llvm::Type *MethodListPtrTy;
551 /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
552 llvm::Type *ExceptionDataTy;
554 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
555 llvm::Constant *getExceptionTryEnterFn() {
556 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
557 return CGM.CreateRuntimeFunction(
558 llvm::FunctionType::get(CGM.VoidTy, params, false),
559 "objc_exception_try_enter");
562 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
563 llvm::Constant *getExceptionTryExitFn() {
564 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
565 return CGM.CreateRuntimeFunction(
566 llvm::FunctionType::get(CGM.VoidTy, params, false),
567 "objc_exception_try_exit");
570 /// ExceptionExtractFn - LLVM objc_exception_extract function.
571 llvm::Constant *getExceptionExtractFn() {
572 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
573 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
575 "objc_exception_extract");
578 /// ExceptionMatchFn - LLVM objc_exception_match function.
579 llvm::Constant *getExceptionMatchFn() {
580 llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
581 return CGM.CreateRuntimeFunction(
582 llvm::FunctionType::get(CGM.Int32Ty, params, false),
583 "objc_exception_match");
587 /// SetJmpFn - LLVM _setjmp function.
588 llvm::Constant *getSetJmpFn() {
589 // This is specifically the prototype for x86.
590 llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
592 CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty,
595 llvm::AttributeSet::get(CGM.getLLVMContext(),
596 llvm::AttributeSet::FunctionIndex,
597 llvm::Attribute::NonLazyBind));
601 ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
602 ~ObjCTypesHelper() {}
605 /// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
607 class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
610 // MethodListnfABITy - LLVM for struct _method_list_t
611 llvm::StructType *MethodListnfABITy;
613 // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
614 llvm::Type *MethodListnfABIPtrTy;
616 // ProtocolnfABITy = LLVM for struct _protocol_t
617 llvm::StructType *ProtocolnfABITy;
619 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
620 llvm::Type *ProtocolnfABIPtrTy;
622 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
623 llvm::StructType *ProtocolListnfABITy;
625 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
626 llvm::Type *ProtocolListnfABIPtrTy;
628 // ClassnfABITy - LLVM for struct _class_t
629 llvm::StructType *ClassnfABITy;
631 // ClassnfABIPtrTy - LLVM for struct _class_t*
632 llvm::Type *ClassnfABIPtrTy;
634 // IvarnfABITy - LLVM for struct _ivar_t
635 llvm::StructType *IvarnfABITy;
637 // IvarListnfABITy - LLVM for struct _ivar_list_t
638 llvm::StructType *IvarListnfABITy;
640 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
641 llvm::Type *IvarListnfABIPtrTy;
643 // ClassRonfABITy - LLVM for struct _class_ro_t
644 llvm::StructType *ClassRonfABITy;
646 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
647 llvm::Type *ImpnfABITy;
649 // CategorynfABITy - LLVM for struct _category_t
650 llvm::StructType *CategorynfABITy;
652 // New types for nonfragile abi messaging.
654 // MessageRefTy - LLVM for:
655 // struct _message_ref_t {
659 llvm::StructType *MessageRefTy;
660 // MessageRefCTy - clang type for struct _message_ref_t
661 QualType MessageRefCTy;
663 // MessageRefPtrTy - LLVM for struct _message_ref_t*
664 llvm::Type *MessageRefPtrTy;
665 // MessageRefCPtrTy - clang type for struct _message_ref_t*
666 QualType MessageRefCPtrTy;
668 // MessengerTy - Type of the messenger (shown as IMP above)
669 llvm::FunctionType *MessengerTy;
671 // SuperMessageRefTy - LLVM for:
672 // struct _super_message_ref_t {
673 // SUPER_IMP messenger;
676 llvm::StructType *SuperMessageRefTy;
678 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
679 llvm::Type *SuperMessageRefPtrTy;
681 llvm::Constant *getMessageSendFixupFn() {
682 // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
683 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
684 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
686 "objc_msgSend_fixup");
689 llvm::Constant *getMessageSendFpretFixupFn() {
690 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
691 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
692 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
694 "objc_msgSend_fpret_fixup");
697 llvm::Constant *getMessageSendStretFixupFn() {
698 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
699 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
700 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
702 "objc_msgSend_stret_fixup");
705 llvm::Constant *getMessageSendSuper2FixupFn() {
706 // id objc_msgSendSuper2_fixup (struct objc_super *,
707 // struct _super_message_ref_t*, ...)
708 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
709 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
711 "objc_msgSendSuper2_fixup");
714 llvm::Constant *getMessageSendSuper2StretFixupFn() {
715 // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
716 // struct _super_message_ref_t*, ...)
717 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
718 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
720 "objc_msgSendSuper2_stret_fixup");
723 llvm::Constant *getObjCEndCatchFn() {
724 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
729 llvm::Constant *getObjCBeginCatchFn() {
730 llvm::Type *params[] = { Int8PtrTy };
731 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
736 llvm::StructType *EHTypeTy;
737 llvm::Type *EHTypePtrTy;
739 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
740 ~ObjCNonFragileABITypesHelper(){}
743 class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
745 // FIXME - accessibility
748 unsigned ivar_bytepos;
750 GC_IVAR(unsigned bytepos = 0, unsigned size = 0)
751 : ivar_bytepos(bytepos), ivar_size(size) {}
753 // Allow sorting based on byte pos.
754 bool operator<(const GC_IVAR &b) const {
755 return ivar_bytepos < b.ivar_bytepos;
763 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
764 : skip(_skip), scan(_scan) {}
767 /// opcode for captured block variables layout 'instructions'.
768 /// In the following descriptions, 'I' is the value of the immediate field.
769 /// (field following the opcode).
771 enum BLOCK_LAYOUT_OPCODE {
772 /// An operator which affects how the following layout should be
774 /// I == 0: Halt interpretation and treat everything else as
775 /// a non-pointer. Note that this instruction is equal
777 /// I != 0: Currently unused.
778 BLOCK_LAYOUT_OPERATOR = 0,
780 /// The next I+1 bytes do not contain a value of object pointer type.
781 /// Note that this can leave the stream unaligned, meaning that
782 /// subsequent word-size instructions do not begin at a multiple of
783 /// the pointer size.
784 BLOCK_LAYOUT_NON_OBJECT_BYTES = 1,
786 /// The next I+1 words do not contain a value of object pointer type.
787 /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
788 /// when the required skip quantity is a multiple of the pointer size.
789 BLOCK_LAYOUT_NON_OBJECT_WORDS = 2,
791 /// The next I+1 words are __strong pointers to Objective-C
792 /// objects or blocks.
793 BLOCK_LAYOUT_STRONG = 3,
795 /// The next I+1 words are pointers to __block variables.
796 BLOCK_LAYOUT_BYREF = 4,
798 /// The next I+1 words are __weak pointers to Objective-C
799 /// objects or blocks.
800 BLOCK_LAYOUT_WEAK = 5,
802 /// The next I+1 words are __unsafe_unretained pointers to
803 /// Objective-C objects or blocks.
804 BLOCK_LAYOUT_UNRETAINED = 6
806 /// The next I+1 words are block or object pointers with some
807 /// as-yet-unspecified ownership semantics. If we add more
808 /// flavors of ownership semantics, values will be taken from
811 /// This is included so that older tools can at least continue
812 /// processing the layout past such things.
813 //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
815 /// All other opcodes are reserved. Halt interpretation and
816 /// treat everything else as opaque.
821 enum BLOCK_LAYOUT_OPCODE opcode;
822 CharUnits block_var_bytepos;
823 CharUnits block_var_size;
824 RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
825 CharUnits BytePos = CharUnits::Zero(),
826 CharUnits Size = CharUnits::Zero())
827 : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {}
829 // Allow sorting based on byte pos.
830 bool operator<(const RUN_SKIP &b) const {
831 return block_var_bytepos < b.block_var_bytepos;
836 llvm::LLVMContext &VMContext;
837 // FIXME! May not be needing this after all.
840 // gc ivar layout bitmap calculation helper caches.
841 SmallVector<GC_IVAR, 16> SkipIvars;
842 SmallVector<GC_IVAR, 16> IvarsInfo;
844 // arc/mrr layout of captured block literal variables.
845 SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
847 /// LazySymbols - Symbols to generate a lazy reference for. See
848 /// DefinedSymbols and FinishModule().
849 llvm::SetVector<IdentifierInfo*> LazySymbols;
851 /// DefinedSymbols - External symbols which are defined by this
852 /// module. The symbols in this list and LazySymbols are used to add
853 /// special linker symbols which ensure that Objective-C modules are
855 llvm::SetVector<IdentifierInfo*> DefinedSymbols;
857 /// ClassNames - uniqued class names.
858 llvm::StringMap<llvm::GlobalVariable*> ClassNames;
860 /// MethodVarNames - uniqued method variable names.
861 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
863 /// DefinedCategoryNames - list of category names in form Class_Category.
864 llvm::SetVector<std::string> DefinedCategoryNames;
866 /// MethodVarTypes - uniqued method type signatures. We have to use
867 /// a StringMap here because have no other unique reference.
868 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
870 /// MethodDefinitions - map of methods which have been defined in
871 /// this translation unit.
872 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
874 /// PropertyNames - uniqued method variable names.
875 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
877 /// ClassReferences - uniqued class references.
878 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
880 /// SelectorReferences - uniqued selector references.
881 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
883 /// Protocols - Protocols for which an objc_protocol structure has
884 /// been emitted. Forward declarations are handled by creating an
885 /// empty structure whose initializer is filled in when/if defined.
886 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
888 /// DefinedProtocols - Protocols which have actually been
889 /// defined. We should not need this, see FIXME in GenerateProtocol.
890 llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
892 /// DefinedClasses - List of defined classes.
893 SmallVector<llvm::GlobalValue*, 16> DefinedClasses;
895 /// ImplementedClasses - List of @implemented classes.
896 SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses;
898 /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
899 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
901 /// DefinedCategories - List of defined categories.
902 SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
904 /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
905 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
907 /// GetNameForMethod - Return a name for the given method.
908 /// \param[out] NameOut - The return value.
909 void GetNameForMethod(const ObjCMethodDecl *OMD,
910 const ObjCContainerDecl *CD,
911 SmallVectorImpl<char> &NameOut);
913 /// GetMethodVarName - Return a unique constant for the given
914 /// selector's name. The return value has type char *.
915 llvm::Constant *GetMethodVarName(Selector Sel);
916 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
918 /// GetMethodVarType - Return a unique constant for the given
919 /// method's type encoding string. The return value has type char *.
921 // FIXME: This is a horrible name.
922 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
923 bool Extended = false);
924 llvm::Constant *GetMethodVarType(const FieldDecl *D);
926 /// GetPropertyName - Return a unique constant for the given
927 /// name. The return value has type char *.
928 llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
930 // FIXME: This can be dropped once string functions are unified.
931 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
932 const Decl *Container);
934 /// GetClassName - Return a unique constant for the given selector's
935 /// runtime name (which may change via use of objc_runtime_name attribute on
936 /// class or protocol definition. The return value has type char *.
937 llvm::Constant *GetClassName(StringRef RuntimeName);
939 llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
941 /// BuildIvarLayout - Builds ivar layout bitmap for the class
942 /// implementation for the __strong or __weak case.
944 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
945 bool ForStrongLayout);
947 llvm::Constant *BuildIvarLayoutBitmap(std::string &BitMap);
949 void BuildAggrIvarRecordLayout(const RecordType *RT,
950 unsigned int BytePos, bool ForStrongLayout,
952 void BuildAggrIvarLayout(const ObjCImplementationDecl *OI,
953 const llvm::StructLayout *Layout,
954 const RecordDecl *RD,
955 ArrayRef<const FieldDecl*> RecFields,
956 unsigned int BytePos, bool ForStrongLayout,
959 Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
961 void UpdateRunSkipBlockVars(bool IsByref,
962 Qualifiers::ObjCLifetime LifeTime,
963 CharUnits FieldOffset,
964 CharUnits FieldSize);
966 void BuildRCBlockVarRecordLayout(const RecordType *RT,
967 CharUnits BytePos, bool &HasUnion,
968 bool ByrefLayout=false);
970 void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
971 const RecordDecl *RD,
972 ArrayRef<const FieldDecl*> RecFields,
973 CharUnits BytePos, bool &HasUnion,
976 uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
978 llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
981 /// GetIvarLayoutName - Returns a unique constant for the given
982 /// ivar layout bitmap.
983 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
984 const ObjCCommonTypesHelper &ObjCTypes);
986 /// EmitPropertyList - Emit the given property list. The return
987 /// value has type PropertyListPtrTy.
988 llvm::Constant *EmitPropertyList(Twine Name,
989 const Decl *Container,
990 const ObjCContainerDecl *OCD,
991 const ObjCCommonTypesHelper &ObjCTypes);
993 /// EmitProtocolMethodTypes - Generate the array of extended method type
994 /// strings. The return value has type Int8PtrPtrTy.
995 llvm::Constant *EmitProtocolMethodTypes(Twine Name,
996 ArrayRef<llvm::Constant*> MethodTypes,
997 const ObjCCommonTypesHelper &ObjCTypes);
999 /// PushProtocolProperties - Push protocol's property on the input stack.
1000 void PushProtocolProperties(
1001 llvm::SmallPtrSet<const IdentifierInfo*, 16> &PropertySet,
1002 SmallVectorImpl<llvm::Constant*> &Properties,
1003 const Decl *Container,
1004 const ObjCProtocolDecl *Proto,
1005 const ObjCCommonTypesHelper &ObjCTypes);
1007 /// GetProtocolRef - Return a reference to the internal protocol
1008 /// description, creating an empty one if it has not been
1009 /// defined. The return value has type ProtocolPtrTy.
1010 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
1012 /// CreateMetadataVar - Create a global variable with internal
1013 /// linkage for use by the Objective-C runtime.
1015 /// This is a convenience wrapper which not only creates the
1016 /// variable, but also sets the section and alignment and adds the
1017 /// global to the "llvm.used" list.
1019 /// \param Name - The variable name.
1020 /// \param Init - The variable initializer; this is also used to
1021 /// define the type of the variable.
1022 /// \param Section - The section the variable should go into, or empty.
1023 /// \param Align - The alignment for the variable, or 0.
1024 /// \param AddToUsed - Whether the variable should be added to
1026 llvm::GlobalVariable *CreateMetadataVar(Twine Name, llvm::Constant *Init,
1027 StringRef Section, unsigned Align,
1030 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1031 ReturnValueSlot Return,
1032 QualType ResultType,
1037 const CallArgList &CallArgs,
1038 const ObjCMethodDecl *OMD,
1039 const ObjCCommonTypesHelper &ObjCTypes);
1041 /// EmitImageInfo - Emit the image info marker used to encode some module
1042 /// level information.
1043 void EmitImageInfo();
1046 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) :
1047 CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) { }
1049 llvm::Constant *GenerateConstantString(const StringLiteral *SL) override;
1051 llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1052 const ObjCContainerDecl *CD=nullptr) override;
1054 void GenerateProtocol(const ObjCProtocolDecl *PD) override;
1056 /// GetOrEmitProtocol - Get the protocol object for the given
1057 /// declaration, emitting it if necessary. The return value has type
1059 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
1061 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1062 /// object for the given declaration, emitting it if needed. These
1063 /// forward references will be filled in with empty bodies if no
1064 /// definition is seen. The return value has type ProtocolPtrTy.
1065 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1066 llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1067 const CGBlockInfo &blockInfo) override;
1068 llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1069 const CGBlockInfo &blockInfo) override;
1071 llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1072 QualType T) override;
1075 class CGObjCMac : public CGObjCCommonMac {
1077 ObjCTypesHelper ObjCTypes;
1079 /// EmitModuleInfo - Another marker encoding module level
1081 void EmitModuleInfo();
1083 /// EmitModuleSymols - Emit module symbols, the list of defined
1084 /// classes and categories. The result has type SymtabPtrTy.
1085 llvm::Constant *EmitModuleSymbols();
1087 /// FinishModule - Write out global data structures at the end of
1088 /// processing a translation unit.
1089 void FinishModule();
1091 /// EmitClassExtension - Generate the class extension structure used
1092 /// to store the weak ivar layout and properties. The return value
1093 /// has type ClassExtensionPtrTy.
1094 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID);
1096 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1097 /// for the given class.
1098 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1099 const ObjCInterfaceDecl *ID);
1101 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1102 IdentifierInfo *II);
1104 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1106 /// EmitSuperClassRef - Emits reference to class's main metadata class.
1107 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1109 /// EmitIvarList - Emit the ivar list for the given
1110 /// implementation. If ForClass is true the list of class ivars
1111 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1112 /// interface ivars will be emitted. The return value has type
1114 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1117 /// EmitMetaClass - Emit a forward reference to the class structure
1118 /// for the metaclass of the given interface. The return value has
1119 /// type ClassPtrTy.
1120 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1122 /// EmitMetaClass - Emit a class structure for the metaclass of the
1123 /// given implementation. The return value has type ClassPtrTy.
1124 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1125 llvm::Constant *Protocols,
1126 ArrayRef<llvm::Constant*> Methods);
1128 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
1130 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
1132 /// EmitMethodList - Emit the method list for the given
1133 /// implementation. The return value has type MethodListPtrTy.
1134 llvm::Constant *EmitMethodList(Twine Name,
1135 const char *Section,
1136 ArrayRef<llvm::Constant*> Methods);
1138 /// EmitMethodDescList - Emit a method description list for a list of
1139 /// method declarations.
1140 /// - TypeName: The name for the type containing the methods.
1141 /// - IsProtocol: True iff these methods are for a protocol.
1142 /// - ClassMethds: True iff these are class methods.
1143 /// - Required: When true, only "required" methods are
1144 /// listed. Similarly, when false only "optional" methods are
1145 /// listed. For classes this should always be true.
1146 /// - begin, end: The method list to output.
1148 /// The return value has type MethodDescriptionListPtrTy.
1149 llvm::Constant *EmitMethodDescList(Twine Name,
1150 const char *Section,
1151 ArrayRef<llvm::Constant*> Methods);
1153 /// GetOrEmitProtocol - Get the protocol object for the given
1154 /// declaration, emitting it if necessary. The return value has type
1156 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1158 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1159 /// object for the given declaration, emitting it if needed. These
1160 /// forward references will be filled in with empty bodies if no
1161 /// definition is seen. The return value has type ProtocolPtrTy.
1162 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1164 /// EmitProtocolExtension - Generate the protocol extension
1165 /// structure used to store optional instance and class methods, and
1166 /// protocol properties. The return value has type
1167 /// ProtocolExtensionPtrTy.
1169 EmitProtocolExtension(const ObjCProtocolDecl *PD,
1170 ArrayRef<llvm::Constant*> OptInstanceMethods,
1171 ArrayRef<llvm::Constant*> OptClassMethods,
1172 ArrayRef<llvm::Constant*> MethodTypesExt);
1174 /// EmitProtocolList - Generate the list of referenced
1175 /// protocols. The return value has type ProtocolListPtrTy.
1176 llvm::Constant *EmitProtocolList(Twine Name,
1177 ObjCProtocolDecl::protocol_iterator begin,
1178 ObjCProtocolDecl::protocol_iterator end);
1180 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1181 /// for the given selector.
1182 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel,
1186 CGObjCMac(CodeGen::CodeGenModule &cgm);
1188 llvm::Function *ModuleInitFunction() override;
1190 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1191 ReturnValueSlot Return,
1192 QualType ResultType,
1193 Selector Sel, llvm::Value *Receiver,
1194 const CallArgList &CallArgs,
1195 const ObjCInterfaceDecl *Class,
1196 const ObjCMethodDecl *Method) override;
1199 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1200 ReturnValueSlot Return, QualType ResultType,
1201 Selector Sel, const ObjCInterfaceDecl *Class,
1202 bool isCategoryImpl, llvm::Value *Receiver,
1203 bool IsClassMessage, const CallArgList &CallArgs,
1204 const ObjCMethodDecl *Method) override;
1206 llvm::Value *GetClass(CodeGenFunction &CGF,
1207 const ObjCInterfaceDecl *ID) override;
1209 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel,
1210 bool lval = false) override;
1212 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1214 llvm::Value *GetSelector(CodeGenFunction &CGF,
1215 const ObjCMethodDecl *Method) override;
1217 llvm::Constant *GetEHType(QualType T) override;
1219 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1221 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1223 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1225 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1226 const ObjCProtocolDecl *PD) override;
1228 llvm::Constant *GetPropertyGetFunction() override;
1229 llvm::Constant *GetPropertySetFunction() override;
1230 llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1231 bool copy) override;
1232 llvm::Constant *GetGetStructFunction() override;
1233 llvm::Constant *GetSetStructFunction() override;
1234 llvm::Constant *GetCppAtomicObjectGetFunction() override;
1235 llvm::Constant *GetCppAtomicObjectSetFunction() override;
1236 llvm::Constant *EnumerationMutationFunction() override;
1238 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1239 const ObjCAtTryStmt &S) override;
1240 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1241 const ObjCAtSynchronizedStmt &S) override;
1242 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1243 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1244 bool ClearInsertionPoint=true) override;
1245 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1246 llvm::Value *AddrWeakObj) override;
1247 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1248 llvm::Value *src, llvm::Value *dst) override;
1249 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1250 llvm::Value *src, llvm::Value *dest,
1251 bool threadlocal = false) override;
1252 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1253 llvm::Value *src, llvm::Value *dest,
1254 llvm::Value *ivarOffset) override;
1255 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1256 llvm::Value *src, llvm::Value *dest) override;
1257 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1258 llvm::Value *dest, llvm::Value *src,
1259 llvm::Value *size) override;
1261 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1262 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1263 unsigned CVRQualifiers) override;
1264 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1265 const ObjCInterfaceDecl *Interface,
1266 const ObjCIvarDecl *Ivar) override;
1268 /// GetClassGlobal - Return the global variable for the Objective-C
1269 /// class of the given name.
1270 llvm::GlobalVariable *GetClassGlobal(const std::string &Name,
1271 bool Weak = false) override {
1272 llvm_unreachable("CGObjCMac::GetClassGlobal");
1276 class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1278 ObjCNonFragileABITypesHelper ObjCTypes;
1279 llvm::GlobalVariable* ObjCEmptyCacheVar;
1280 llvm::GlobalVariable* ObjCEmptyVtableVar;
1282 /// SuperClassReferences - uniqued super class references.
1283 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1285 /// MetaClassReferences - uniqued meta class references.
1286 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1288 /// EHTypeReferences - uniqued class ehtype references.
1289 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1291 /// VTableDispatchMethods - List of methods for which we generate
1292 /// vtable-based message dispatch.
1293 llvm::DenseSet<Selector> VTableDispatchMethods;
1295 /// DefinedMetaClasses - List of defined meta-classes.
1296 std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1298 /// isVTableDispatchedSelector - Returns true if SEL is a
1299 /// vtable-based selector.
1300 bool isVTableDispatchedSelector(Selector Sel);
1302 /// FinishNonFragileABIModule - Write out global data structures at the end of
1303 /// processing a translation unit.
1304 void FinishNonFragileABIModule();
1306 /// AddModuleClassList - Add the given list of class pointers to the
1307 /// module with the provided symbol and section names.
1308 void AddModuleClassList(ArrayRef<llvm::GlobalValue*> Container,
1309 const char *SymbolName,
1310 const char *SectionName);
1312 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1313 unsigned InstanceStart,
1314 unsigned InstanceSize,
1315 const ObjCImplementationDecl *ID);
1316 llvm::GlobalVariable * BuildClassMetaData(const std::string &ClassName,
1317 llvm::Constant *IsAGV,
1318 llvm::Constant *SuperClassGV,
1319 llvm::Constant *ClassRoGV,
1320 bool HiddenVisibility,
1323 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
1325 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
1327 /// EmitMethodList - Emit the method list for the given
1328 /// implementation. The return value has type MethodListnfABITy.
1329 llvm::Constant *EmitMethodList(Twine Name,
1330 const char *Section,
1331 ArrayRef<llvm::Constant*> Methods);
1332 /// EmitIvarList - Emit the ivar list for the given
1333 /// implementation. If ForClass is true the list of class ivars
1334 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1335 /// interface ivars will be emitted. The return value has type
1336 /// IvarListnfABIPtrTy.
1337 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
1339 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1340 const ObjCIvarDecl *Ivar,
1341 unsigned long int offset);
1343 /// GetOrEmitProtocol - Get the protocol object for the given
1344 /// declaration, emitting it if necessary. The return value has type
1346 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1348 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1349 /// object for the given declaration, emitting it if needed. These
1350 /// forward references will be filled in with empty bodies if no
1351 /// definition is seen. The return value has type ProtocolPtrTy.
1352 llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1354 /// EmitProtocolList - Generate the list of referenced
1355 /// protocols. The return value has type ProtocolListPtrTy.
1356 llvm::Constant *EmitProtocolList(Twine Name,
1357 ObjCProtocolDecl::protocol_iterator begin,
1358 ObjCProtocolDecl::protocol_iterator end);
1360 CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1361 ReturnValueSlot Return,
1362 QualType ResultType,
1364 llvm::Value *Receiver,
1367 const CallArgList &CallArgs,
1368 const ObjCMethodDecl *Method);
1370 /// GetClassGlobal - Return the global variable for the Objective-C
1371 /// class of the given name.
1372 llvm::GlobalVariable *GetClassGlobal(const std::string &Name,
1373 bool Weak = false) override;
1375 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1376 /// for the given class reference.
1377 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1378 const ObjCInterfaceDecl *ID);
1380 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1381 IdentifierInfo *II, bool Weak,
1382 const ObjCInterfaceDecl *ID);
1384 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1386 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1387 /// for the given super class reference.
1388 llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1389 const ObjCInterfaceDecl *ID);
1391 /// EmitMetaClassRef - Return a Value * of the address of _class_t
1393 llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1394 const ObjCInterfaceDecl *ID, bool Weak);
1396 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1399 llvm::GlobalVariable * ObjCIvarOffsetVariable(
1400 const ObjCInterfaceDecl *ID,
1401 const ObjCIvarDecl *Ivar);
1403 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1404 /// for the given selector.
1405 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel,
1408 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1409 /// interface. The return value has type EHTypePtrTy.
1410 llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1411 bool ForDefinition);
1413 const char *getMetaclassSymbolPrefix() const {
1414 return "OBJC_METACLASS_$_";
1417 const char *getClassSymbolPrefix() const {
1418 return "OBJC_CLASS_$_";
1421 void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1422 uint32_t &InstanceStart,
1423 uint32_t &InstanceSize);
1425 // Shamelessly stolen from Analysis/CFRefCount.cpp
1426 Selector GetNullarySelector(const char* name) const {
1427 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1428 return CGM.getContext().Selectors.getSelector(0, &II);
1431 Selector GetUnarySelector(const char* name) const {
1432 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1433 return CGM.getContext().Selectors.getSelector(1, &II);
1436 /// ImplementationIsNonLazy - Check whether the given category or
1437 /// class implementation is "non-lazy".
1438 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1440 bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1441 const ObjCIvarDecl *IV) {
1442 // Annotate the load as an invariant load iff inside an instance method
1443 // and ivar belongs to instance method's class and one of its super class.
1444 // This check is needed because the ivar offset is a lazily
1445 // initialised value that may depend on objc_msgSend to perform a fixup on
1446 // the first message dispatch.
1448 // An additional opportunity to mark the load as invariant arises when the
1449 // base of the ivar access is a parameter to an Objective C method.
1450 // However, because the parameters are not available in the current
1451 // interface, we cannot perform this check.
1452 if (const ObjCMethodDecl *MD =
1453 dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1454 if (MD->isInstanceMethod())
1455 if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1456 return IV->getContainingInterface()->isSuperClassOf(ID);
1461 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1462 // FIXME. All stubs for now!
1463 llvm::Function *ModuleInitFunction() override;
1465 CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1466 ReturnValueSlot Return,
1467 QualType ResultType, Selector Sel,
1468 llvm::Value *Receiver,
1469 const CallArgList &CallArgs,
1470 const ObjCInterfaceDecl *Class,
1471 const ObjCMethodDecl *Method) override;
1474 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1475 ReturnValueSlot Return, QualType ResultType,
1476 Selector Sel, const ObjCInterfaceDecl *Class,
1477 bool isCategoryImpl, llvm::Value *Receiver,
1478 bool IsClassMessage, const CallArgList &CallArgs,
1479 const ObjCMethodDecl *Method) override;
1481 llvm::Value *GetClass(CodeGenFunction &CGF,
1482 const ObjCInterfaceDecl *ID) override;
1484 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel,
1485 bool lvalue = false) override
1486 { return EmitSelector(CGF, Sel, lvalue); }
1488 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1490 llvm::Value *GetSelector(CodeGenFunction &CGF,
1491 const ObjCMethodDecl *Method) override
1492 { return EmitSelector(CGF, Method->getSelector()); }
1494 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1496 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1498 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1500 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1501 const ObjCProtocolDecl *PD) override;
1503 llvm::Constant *GetEHType(QualType T) override;
1505 llvm::Constant *GetPropertyGetFunction() override {
1506 return ObjCTypes.getGetPropertyFn();
1508 llvm::Constant *GetPropertySetFunction() override {
1509 return ObjCTypes.getSetPropertyFn();
1512 llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1513 bool copy) override {
1514 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1517 llvm::Constant *GetSetStructFunction() override {
1518 return ObjCTypes.getCopyStructFn();
1520 llvm::Constant *GetGetStructFunction() override {
1521 return ObjCTypes.getCopyStructFn();
1523 llvm::Constant *GetCppAtomicObjectSetFunction() override {
1524 return ObjCTypes.getCppAtomicObjectFunction();
1526 llvm::Constant *GetCppAtomicObjectGetFunction() override {
1527 return ObjCTypes.getCppAtomicObjectFunction();
1530 llvm::Constant *EnumerationMutationFunction() override {
1531 return ObjCTypes.getEnumerationMutationFn();
1534 void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1535 const ObjCAtTryStmt &S) override;
1536 void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1537 const ObjCAtSynchronizedStmt &S) override;
1538 void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1539 bool ClearInsertionPoint=true) override;
1540 llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1541 llvm::Value *AddrWeakObj) override;
1542 void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1543 llvm::Value *src, llvm::Value *dst) override;
1544 void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1545 llvm::Value *src, llvm::Value *dest,
1546 bool threadlocal = false) override;
1547 void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1548 llvm::Value *src, llvm::Value *dest,
1549 llvm::Value *ivarOffset) override;
1550 void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1551 llvm::Value *src, llvm::Value *dest) override;
1552 void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1553 llvm::Value *dest, llvm::Value *src,
1554 llvm::Value *size) override;
1555 LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1556 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1557 unsigned CVRQualifiers) override;
1558 llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1559 const ObjCInterfaceDecl *Interface,
1560 const ObjCIvarDecl *Ivar) override;
1563 /// A helper class for performing the null-initialization of a return
1565 struct NullReturnState {
1566 llvm::BasicBlock *NullBB;
1567 NullReturnState() : NullBB(nullptr) {}
1569 /// Perform a null-check of the given receiver.
1570 void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1571 // Make blocks for the null-receiver and call edges.
1572 NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1573 llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1575 // Check for a null receiver and, if there is one, jump to the
1576 // null-receiver block. There's no point in trying to avoid it:
1577 // we're always going to put *something* there, because otherwise
1578 // we shouldn't have done this null-check in the first place.
1579 llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1580 CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1582 // Otherwise, start performing the call.
1583 CGF.EmitBlock(callBB);
1586 /// Complete the null-return operation. It is valid to call this
1587 /// regardless of whether 'init' has been called.
1588 RValue complete(CodeGenFunction &CGF, RValue result, QualType resultType,
1589 const CallArgList &CallArgs,
1590 const ObjCMethodDecl *Method) {
1591 // If we never had to do a null-check, just use the raw result.
1592 if (!NullBB) return result;
1594 // The continuation block. This will be left null if we don't have an
1595 // IP, which can happen if the method we're calling is marked noreturn.
1596 llvm::BasicBlock *contBB = nullptr;
1598 // Finish the call path.
1599 llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1601 contBB = CGF.createBasicBlock("msgSend.cont");
1602 CGF.Builder.CreateBr(contBB);
1605 // Okay, start emitting the null-receiver block.
1606 CGF.EmitBlock(NullBB);
1608 // Release any consumed arguments we've got.
1610 CallArgList::const_iterator I = CallArgs.begin();
1611 for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
1612 e = Method->param_end(); i != e; ++i, ++I) {
1613 const ParmVarDecl *ParamDecl = (*i);
1614 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1616 assert(RV.isScalar() &&
1617 "NullReturnState::complete - arg not on object");
1618 CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime);
1623 // The phi code below assumes that we haven't needed any control flow yet.
1624 assert(CGF.Builder.GetInsertBlock() == NullBB);
1626 // If we've got a void return, just jump to the continuation block.
1627 if (result.isScalar() && resultType->isVoidType()) {
1628 // No jumps required if the message-send was noreturn.
1629 if (contBB) CGF.EmitBlock(contBB);
1633 // If we've got a scalar return, build a phi.
1634 if (result.isScalar()) {
1635 // Derive the null-initialization value.
1636 llvm::Constant *null = CGF.CGM.EmitNullConstant(resultType);
1638 // If no join is necessary, just flow out.
1639 if (!contBB) return RValue::get(null);
1641 // Otherwise, build a phi.
1642 CGF.EmitBlock(contBB);
1643 llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1644 phi->addIncoming(result.getScalarVal(), callBB);
1645 phi->addIncoming(null, NullBB);
1646 return RValue::get(phi);
1649 // If we've got an aggregate return, null the buffer out.
1650 // FIXME: maybe we should be doing things differently for all the
1651 // cases where the ABI has us returning (1) non-agg values in
1652 // memory or (2) agg values in registers.
1653 if (result.isAggregate()) {
1654 assert(result.isAggregate() && "null init of non-aggregate result?");
1655 CGF.EmitNullInitialization(result.getAggregateAddr(), resultType);
1656 if (contBB) CGF.EmitBlock(contBB);
1661 CGF.EmitBlock(contBB);
1662 CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1664 // Find the scalar type and its zero value.
1665 llvm::Type *scalarTy = callResult.first->getType();
1666 llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1668 // Build phis for both coordinates.
1669 llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1670 real->addIncoming(callResult.first, callBB);
1671 real->addIncoming(scalarZero, NullBB);
1672 llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1673 imag->addIncoming(callResult.second, callBB);
1674 imag->addIncoming(scalarZero, NullBB);
1675 return RValue::getComplex(real, imag);
1679 } // end anonymous namespace
1681 /* *** Helper Functions *** */
1683 /// getConstantGEP() - Help routine to construct simple GEPs.
1684 static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1688 llvm::Value *Idxs[] = {
1689 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1690 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1692 return llvm::ConstantExpr::getGetElementPtr(C, Idxs);
1695 /// hasObjCExceptionAttribute - Return true if this class or any super
1696 /// class has the __objc_exception__ attribute.
1697 static bool hasObjCExceptionAttribute(ASTContext &Context,
1698 const ObjCInterfaceDecl *OID) {
1699 if (OID->hasAttr<ObjCExceptionAttr>())
1701 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1702 return hasObjCExceptionAttribute(Context, Super);
1706 /* *** CGObjCMac Public Interface *** */
1708 CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1714 /// GetClass - Return a reference to the class for the given interface
1716 llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1717 const ObjCInterfaceDecl *ID) {
1718 return EmitClassRef(CGF, ID);
1721 /// GetSelector - Return the pointer to the unique'd string for this selector.
1722 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel,
1724 return EmitSelector(CGF, Sel, lval);
1726 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1728 return EmitSelector(CGF, Method->getSelector());
1731 llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1732 if (T->isObjCIdType() ||
1733 T->isObjCQualifiedIdType()) {
1734 return CGM.GetAddrOfRTTIDescriptor(
1735 CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1737 if (T->isObjCClassType() ||
1738 T->isObjCQualifiedClassType()) {
1739 return CGM.GetAddrOfRTTIDescriptor(
1740 CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1742 if (T->isObjCObjectPointerType())
1743 return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true);
1745 llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1748 /// Generate a constant CFString object.
1750 struct __builtin_CFString {
1751 const int *isa; // point to __CFConstantStringClassReference
1758 /// or Generate a constant NSString object.
1760 struct __builtin_NSString {
1761 const int *isa; // point to __NSConstantStringClassReference
1763 unsigned int length;
1767 llvm::Constant *CGObjCCommonMac::GenerateConstantString(
1768 const StringLiteral *SL) {
1769 return (CGM.getLangOpts().NoConstantCFStrings == 0 ?
1770 CGM.GetAddrOfConstantCFString(SL) :
1771 CGM.GetAddrOfConstantString(SL));
1775 kCFTaggedObjectID_Integer = (1 << 1) + 1
1778 /// Generates a message send where the super is the receiver. This is
1779 /// a message send to self with special delivery semantics indicating
1780 /// which class's method should be called.
1782 CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1783 ReturnValueSlot Return,
1784 QualType ResultType,
1786 const ObjCInterfaceDecl *Class,
1787 bool isCategoryImpl,
1788 llvm::Value *Receiver,
1789 bool IsClassMessage,
1790 const CodeGen::CallArgList &CallArgs,
1791 const ObjCMethodDecl *Method) {
1792 // Create and init a super structure; this is a (receiver, class)
1793 // pair we will pass to objc_msgSendSuper.
1794 llvm::Value *ObjCSuper =
1795 CGF.CreateTempAlloca(ObjCTypes.SuperTy, "objc_super");
1796 llvm::Value *ReceiverAsObject =
1797 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
1798 CGF.Builder.CreateStore(ReceiverAsObject,
1799 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
1801 // If this is a class message the metaclass is passed as the target.
1802 llvm::Value *Target;
1803 if (IsClassMessage) {
1804 if (isCategoryImpl) {
1805 // Message sent to 'super' in a class method defined in a category
1806 // implementation requires an odd treatment.
1807 // If we are in a class method, we must retrieve the
1808 // _metaclass_ for the current class, pointed at by
1809 // the class's "isa" pointer. The following assumes that
1810 // isa" is the first ivar in a class (which it must be).
1811 Target = EmitClassRef(CGF, Class->getSuperClass());
1812 Target = CGF.Builder.CreateStructGEP(Target, 0);
1813 Target = CGF.Builder.CreateLoad(Target);
1815 llvm::Value *MetaClassPtr = EmitMetaClassRef(Class);
1816 llvm::Value *SuperPtr = CGF.Builder.CreateStructGEP(MetaClassPtr, 1);
1817 llvm::Value *Super = CGF.Builder.CreateLoad(SuperPtr);
1821 else if (isCategoryImpl)
1822 Target = EmitClassRef(CGF, Class->getSuperClass());
1824 llvm::Value *ClassPtr = EmitSuperClassRef(Class);
1825 ClassPtr = CGF.Builder.CreateStructGEP(ClassPtr, 1);
1826 Target = CGF.Builder.CreateLoad(ClassPtr);
1828 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
1830 llvm::Type *ClassTy =
1831 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
1832 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
1833 CGF.Builder.CreateStore(Target,
1834 CGF.Builder.CreateStructGEP(ObjCSuper, 1));
1835 return EmitMessageSend(CGF, Return, ResultType,
1836 EmitSelector(CGF, Sel),
1837 ObjCSuper, ObjCTypes.SuperPtrCTy,
1838 true, CallArgs, Method, ObjCTypes);
1841 /// Generate code for a message send expression.
1842 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1843 ReturnValueSlot Return,
1844 QualType ResultType,
1846 llvm::Value *Receiver,
1847 const CallArgList &CallArgs,
1848 const ObjCInterfaceDecl *Class,
1849 const ObjCMethodDecl *Method) {
1850 return EmitMessageSend(CGF, Return, ResultType,
1851 EmitSelector(CGF, Sel),
1852 Receiver, CGF.getContext().getObjCIdType(),
1853 false, CallArgs, Method, ObjCTypes);
1857 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1858 ReturnValueSlot Return,
1859 QualType ResultType,
1864 const CallArgList &CallArgs,
1865 const ObjCMethodDecl *Method,
1866 const ObjCCommonTypesHelper &ObjCTypes) {
1867 CallArgList ActualArgs;
1869 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
1870 ActualArgs.add(RValue::get(Arg0), Arg0Ty);
1871 ActualArgs.add(RValue::get(Sel), CGF.getContext().getObjCSelType());
1872 ActualArgs.addFrom(CallArgs);
1874 // If we're calling a method, use the formal signature.
1875 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
1878 assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==
1879 CGM.getContext().getCanonicalType(ResultType) &&
1880 "Result type mismatch!");
1882 NullReturnState nullReturn;
1884 llvm::Constant *Fn = nullptr;
1885 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
1886 if (!IsSuper) nullReturn.init(CGF, Arg0);
1887 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
1888 : ObjCTypes.getSendStretFn(IsSuper);
1889 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
1890 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
1891 : ObjCTypes.getSendFpretFn(IsSuper);
1892 } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
1893 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
1894 : ObjCTypes.getSendFp2retFn(IsSuper);
1896 // arm64 uses objc_msgSend for stret methods and yet null receiver check
1897 // must be made for it.
1898 if (!IsSuper && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
1899 nullReturn.init(CGF, Arg0);
1900 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
1901 : ObjCTypes.getSendFn(IsSuper);
1904 bool requiresnullCheck = false;
1905 if (CGM.getLangOpts().ObjCAutoRefCount && Method)
1906 for (const auto *ParamDecl : Method->params()) {
1907 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1908 if (!nullReturn.NullBB)
1909 nullReturn.init(CGF, Arg0);
1910 requiresnullCheck = true;
1915 Fn = llvm::ConstantExpr::getBitCast(Fn, MSI.MessengerType);
1916 RValue rvalue = CGF.EmitCall(MSI.CallInfo, Fn, Return, ActualArgs);
1917 return nullReturn.complete(CGF, rvalue, ResultType, CallArgs,
1918 requiresnullCheck ? Method : nullptr);
1921 static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT) {
1922 if (FQT.isObjCGCStrong())
1923 return Qualifiers::Strong;
1925 if (FQT.isObjCGCWeak() || FQT.getObjCLifetime() == Qualifiers::OCL_Weak)
1926 return Qualifiers::Weak;
1928 // check for __unsafe_unretained
1929 if (FQT.getObjCLifetime() == Qualifiers::OCL_ExplicitNone)
1930 return Qualifiers::GCNone;
1932 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
1933 return Qualifiers::Strong;
1935 if (const PointerType *PT = FQT->getAs<PointerType>())
1936 return GetGCAttrTypeForType(Ctx, PT->getPointeeType());
1938 return Qualifiers::GCNone;
1941 llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
1942 const CGBlockInfo &blockInfo) {
1944 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
1945 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
1946 !CGM.getLangOpts().ObjCAutoRefCount)
1949 bool hasUnion = false;
1952 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
1953 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
1955 // __isa is the first field in block descriptor and must assume by runtime's
1956 // convention that it is GC'able.
1957 IvarsInfo.push_back(GC_IVAR(0, 1));
1959 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
1961 // Calculate the basic layout of the block structure.
1962 const llvm::StructLayout *layout =
1963 CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
1965 // Ignore the optional 'this' capture: C++ objects are not assumed
1968 // Walk the captured variables.
1969 for (const auto &CI : blockDecl->captures()) {
1970 const VarDecl *variable = CI.getVariable();
1971 QualType type = variable->getType();
1973 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
1975 // Ignore constant captures.
1976 if (capture.isConstant()) continue;
1978 uint64_t fieldOffset = layout->getElementOffset(capture.getIndex());
1980 // __block variables are passed by their descriptor address.
1982 IvarsInfo.push_back(GC_IVAR(fieldOffset, /*size in words*/ 1));
1986 assert(!type->isArrayType() && "array variable should not be caught");
1987 if (const RecordType *record = type->getAs<RecordType>()) {
1988 BuildAggrIvarRecordLayout(record, fieldOffset, true, hasUnion);
1992 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);
1993 unsigned fieldSize = CGM.getContext().getTypeSize(type);
1995 if (GCAttr == Qualifiers::Strong)
1996 IvarsInfo.push_back(GC_IVAR(fieldOffset,
1997 fieldSize / WordSizeInBits));
1998 else if (GCAttr == Qualifiers::GCNone || GCAttr == Qualifiers::Weak)
1999 SkipIvars.push_back(GC_IVAR(fieldOffset,
2000 fieldSize / ByteSizeInBits));
2003 if (IvarsInfo.empty())
2006 // Sort on byte position; captures might not be allocated in order,
2007 // and unions can do funny things.
2008 llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
2009 llvm::array_pod_sort(SkipIvars.begin(), SkipIvars.end());
2012 llvm::Constant *C = BuildIvarLayoutBitmap(BitMap);
2013 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2014 printf("\n block variable layout for block: ");
2015 const unsigned char *s = (const unsigned char*)BitMap.c_str();
2016 for (unsigned i = 0, e = BitMap.size(); i < e; i++)
2018 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2020 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
2027 /// getBlockCaptureLifetime - This routine returns life time of the captured
2028 /// block variable for the purpose of block layout meta-data generation. FQT is
2029 /// the type of the variable captured in the block.
2030 Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2032 if (CGM.getLangOpts().ObjCAutoRefCount)
2033 return FQT.getObjCLifetime();
2036 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2037 return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong;
2039 return Qualifiers::OCL_None;
2042 void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2043 Qualifiers::ObjCLifetime LifeTime,
2044 CharUnits FieldOffset,
2045 CharUnits FieldSize) {
2046 // __block variables are passed by their descriptor address.
2048 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2050 else if (LifeTime == Qualifiers::OCL_Strong)
2051 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2053 else if (LifeTime == Qualifiers::OCL_Weak)
2054 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2056 else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2057 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2060 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2065 void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2066 const RecordDecl *RD,
2067 ArrayRef<const FieldDecl*> RecFields,
2068 CharUnits BytePos, bool &HasUnion,
2070 bool IsUnion = (RD && RD->isUnion());
2071 CharUnits MaxUnionSize = CharUnits::Zero();
2072 const FieldDecl *MaxField = nullptr;
2073 const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2074 CharUnits MaxFieldOffset = CharUnits::Zero();
2075 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2077 if (RecFields.empty())
2079 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2081 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
2082 const FieldDecl *Field = RecFields[i];
2083 // Note that 'i' here is actually the field index inside RD of Field,
2084 // although this dependency is hidden.
2085 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2086 CharUnits FieldOffset =
2087 CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i));
2089 // Skip over unnamed or bitfields
2090 if (!Field->getIdentifier() || Field->isBitField()) {
2091 LastFieldBitfieldOrUnnamed = Field;
2092 LastBitfieldOrUnnamedOffset = FieldOffset;
2096 LastFieldBitfieldOrUnnamed = nullptr;
2097 QualType FQT = Field->getType();
2098 if (FQT->isRecordType() || FQT->isUnionType()) {
2099 if (FQT->isUnionType())
2102 BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
2103 BytePos + FieldOffset, HasUnion);
2107 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2108 const ConstantArrayType *CArray =
2109 dyn_cast_or_null<ConstantArrayType>(Array);
2110 uint64_t ElCount = CArray->getSize().getZExtValue();
2111 assert(CArray && "only array with known element size is supported");
2112 FQT = CArray->getElementType();
2113 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2114 const ConstantArrayType *CArray =
2115 dyn_cast_or_null<ConstantArrayType>(Array);
2116 ElCount *= CArray->getSize().getZExtValue();
2117 FQT = CArray->getElementType();
2119 if (FQT->isRecordType() && ElCount) {
2120 int OldIndex = RunSkipBlockVars.size() - 1;
2121 const RecordType *RT = FQT->getAs<RecordType>();
2122 BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset,
2125 // Replicate layout information for each array element. Note that
2126 // one element is already done.
2128 for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2129 CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2130 for (int i = OldIndex+1; i <= FirstIndex; ++i)
2131 RunSkipBlockVars.push_back(
2132 RUN_SKIP(RunSkipBlockVars[i].opcode,
2133 RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2134 RunSkipBlockVars[i].block_var_size));
2139 CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2141 CharUnits UnionIvarSize = FieldSize;
2142 if (UnionIvarSize > MaxUnionSize) {
2143 MaxUnionSize = UnionIvarSize;
2145 MaxFieldOffset = FieldOffset;
2148 UpdateRunSkipBlockVars(false,
2149 getBlockCaptureLifetime(FQT, ByrefLayout),
2150 BytePos + FieldOffset,
2155 if (LastFieldBitfieldOrUnnamed) {
2156 if (LastFieldBitfieldOrUnnamed->isBitField()) {
2157 // Last field was a bitfield. Must update the info.
2158 uint64_t BitFieldSize
2159 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2160 unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2161 ((BitFieldSize % ByteSizeInBits) != 0);
2162 CharUnits Size = CharUnits::fromQuantity(UnsSize);
2163 Size += LastBitfieldOrUnnamedOffset;
2164 UpdateRunSkipBlockVars(false,
2165 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2167 BytePos + LastBitfieldOrUnnamedOffset,
2170 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2171 // Last field was unnamed. Must update skip info.
2173 = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2174 UpdateRunSkipBlockVars(false,
2175 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2177 BytePos + LastBitfieldOrUnnamedOffset,
2183 UpdateRunSkipBlockVars(false,
2184 getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2185 BytePos + MaxFieldOffset,
2189 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2193 const RecordDecl *RD = RT->getDecl();
2194 SmallVector<const FieldDecl*, 16> Fields(RD->fields());
2195 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2196 const llvm::StructLayout *RecLayout =
2197 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2199 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2202 /// InlineLayoutInstruction - This routine produce an inline instruction for the
2203 /// block variable layout if it can. If not, it returns 0. Rules are as follow:
2204 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2205 /// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2206 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2207 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2208 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2209 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2210 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2211 uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2212 SmallVectorImpl<unsigned char> &Layout) {
2213 uint64_t Result = 0;
2214 if (Layout.size() <= 3) {
2215 unsigned size = Layout.size();
2216 unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2218 enum BLOCK_LAYOUT_OPCODE opcode ;
2222 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2223 if (opcode == BLOCK_LAYOUT_STRONG)
2224 strong_word_count = (inst & 0xF)+1;
2228 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2229 if (opcode == BLOCK_LAYOUT_BYREF)
2230 byref_word_count = (inst & 0xF)+1;
2234 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2235 if (opcode == BLOCK_LAYOUT_WEAK)
2236 weak_word_count = (inst & 0xF)+1;
2243 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2244 if (opcode == BLOCK_LAYOUT_STRONG) {
2245 strong_word_count = (inst & 0xF)+1;
2247 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2248 if (opcode == BLOCK_LAYOUT_BYREF)
2249 byref_word_count = (inst & 0xF)+1;
2250 else if (opcode == BLOCK_LAYOUT_WEAK)
2251 weak_word_count = (inst & 0xF)+1;
2255 else if (opcode == BLOCK_LAYOUT_BYREF) {
2256 byref_word_count = (inst & 0xF)+1;
2258 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2259 if (opcode == BLOCK_LAYOUT_WEAK)
2260 weak_word_count = (inst & 0xF)+1;
2270 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2271 if (opcode == BLOCK_LAYOUT_STRONG)
2272 strong_word_count = (inst & 0xF)+1;
2273 else if (opcode == BLOCK_LAYOUT_BYREF)
2274 byref_word_count = (inst & 0xF)+1;
2275 else if (opcode == BLOCK_LAYOUT_WEAK)
2276 weak_word_count = (inst & 0xF)+1;
2285 // Cannot inline when any of the word counts is 15. Because this is one less
2286 // than the actual work count (so 15 means 16 actual word counts),
2287 // and we can only display 0 thru 15 word counts.
2288 if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2292 (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2294 if (size == count) {
2295 if (strong_word_count)
2296 Result = strong_word_count;
2298 if (byref_word_count)
2299 Result += byref_word_count;
2301 if (weak_word_count)
2302 Result += weak_word_count;
2308 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2309 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2310 if (RunSkipBlockVars.empty())
2312 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2313 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2314 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2316 // Sort on byte position; captures might not be allocated in order,
2317 // and unions can do funny things.
2318 llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2319 SmallVector<unsigned char, 16> Layout;
2321 unsigned size = RunSkipBlockVars.size();
2322 for (unsigned i = 0; i < size; i++) {
2323 enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2324 CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2325 CharUnits end_byte_pos = start_byte_pos;
2328 if (opcode == RunSkipBlockVars[j].opcode) {
2329 end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2335 CharUnits size_in_bytes =
2336 end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2339 RunSkipBlockVars[j].block_var_bytepos -
2340 RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2341 size_in_bytes += gap;
2343 CharUnits residue_in_bytes = CharUnits::Zero();
2344 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2345 residue_in_bytes = size_in_bytes % WordSizeInBytes;
2346 size_in_bytes -= residue_in_bytes;
2347 opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2350 unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2351 while (size_in_words >= 16) {
2352 // Note that value in imm. is one less that the actual
2353 // value. So, 0xf means 16 words follow!
2354 unsigned char inst = (opcode << 4) | 0xf;
2355 Layout.push_back(inst);
2356 size_in_words -= 16;
2358 if (size_in_words > 0) {
2359 // Note that value in imm. is one less that the actual
2360 // value. So, we subtract 1 away!
2361 unsigned char inst = (opcode << 4) | (size_in_words-1);
2362 Layout.push_back(inst);
2364 if (residue_in_bytes > CharUnits::Zero()) {
2365 unsigned char inst =
2366 (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2367 Layout.push_back(inst);
2371 int e = Layout.size()-1;
2373 unsigned char inst = Layout[e--];
2374 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2375 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2381 uint64_t Result = InlineLayoutInstruction(Layout);
2383 // Block variable layout instruction has been inlined.
2384 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2385 if (ComputeByrefLayout)
2386 printf("\n Inline instruction for BYREF variable layout: ");
2388 printf("\n Inline instruction for block variable layout: ");
2389 printf("0x0%" PRIx64 "\n", Result);
2391 if (WordSizeInBytes == 8) {
2392 const llvm::APInt Instruction(64, Result);
2393 return llvm::Constant::getIntegerValue(CGM.Int64Ty, Instruction);
2396 const llvm::APInt Instruction(32, Result);
2397 return llvm::Constant::getIntegerValue(CGM.Int32Ty, Instruction);
2401 unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2402 Layout.push_back(inst);
2404 for (unsigned i = 0, e = Layout.size(); i != e; i++)
2405 BitMap += Layout[i];
2407 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2408 if (ComputeByrefLayout)
2409 printf("\n BYREF variable layout: ");
2411 printf("\n block variable layout: ");
2412 for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2413 unsigned char inst = BitMap[i];
2414 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2417 case BLOCK_LAYOUT_OPERATOR:
2418 printf("BL_OPERATOR:");
2421 case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2422 printf("BL_NON_OBJECT_BYTES:");
2424 case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2425 printf("BL_NON_OBJECT_WORD:");
2427 case BLOCK_LAYOUT_STRONG:
2428 printf("BL_STRONG:");
2430 case BLOCK_LAYOUT_BYREF:
2431 printf("BL_BYREF:");
2433 case BLOCK_LAYOUT_WEAK:
2436 case BLOCK_LAYOUT_UNRETAINED:
2437 printf("BL_UNRETAINED:");
2440 // Actual value of word count is one more that what is in the imm.
2441 // field of the instruction
2442 printf("%d", (inst & 0xf) + delta);
2450 llvm::GlobalVariable * Entry =
2451 CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
2452 llvm::ConstantDataArray::getString(VMContext, BitMap,false),
2453 "__TEXT,__objc_classname,cstring_literals", 1, true);
2454 return getConstantGEP(VMContext, Entry, 0, 0);
2457 llvm::Constant *CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2458 const CGBlockInfo &blockInfo) {
2459 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2461 RunSkipBlockVars.clear();
2462 bool hasUnion = false;
2464 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2465 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2466 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2468 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2470 // Calculate the basic layout of the block structure.
2471 const llvm::StructLayout *layout =
2472 CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2474 // Ignore the optional 'this' capture: C++ objects are not assumed
2476 if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2477 UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2478 blockInfo.BlockHeaderForcedGapOffset,
2479 blockInfo.BlockHeaderForcedGapSize);
2480 // Walk the captured variables.
2481 for (const auto &CI : blockDecl->captures()) {
2482 const VarDecl *variable = CI.getVariable();
2483 QualType type = variable->getType();
2485 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2487 // Ignore constant captures.
2488 if (capture.isConstant()) continue;
2490 CharUnits fieldOffset =
2491 CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2493 assert(!type->isArrayType() && "array variable should not be caught");
2495 if (const RecordType *record = type->getAs<RecordType>()) {
2496 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2499 CharUnits fieldSize;
2501 fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2503 fieldSize = CGM.getContext().getTypeSizeInChars(type);
2504 UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2505 fieldOffset, fieldSize);
2507 return getBitmapBlockLayout(false);
2511 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
2513 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2514 assert(!T->isArrayType() && "__block array variable should not be caught");
2515 CharUnits fieldOffset;
2516 RunSkipBlockVars.clear();
2517 bool hasUnion = false;
2518 if (const RecordType *record = T->getAs<RecordType>()) {
2519 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
2520 llvm::Constant *Result = getBitmapBlockLayout(true);
2523 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2527 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
2528 const ObjCProtocolDecl *PD) {
2529 // FIXME: I don't understand why gcc generates this, or where it is
2530 // resolved. Investigate. Its also wasteful to look this up over and over.
2531 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2533 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
2534 ObjCTypes.getExternalProtocolPtrTy());
2537 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
2538 // FIXME: We shouldn't need this, the protocol decl should contain enough
2539 // information to tell us whether this was a declaration or a definition.
2540 DefinedProtocols.insert(PD->getIdentifier());
2542 // If we have generated a forward reference to this protocol, emit
2543 // it now. Otherwise do nothing, the protocol objects are lazily
2545 if (Protocols.count(PD->getIdentifier()))
2546 GetOrEmitProtocol(PD);
2549 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
2550 if (DefinedProtocols.count(PD->getIdentifier()))
2551 return GetOrEmitProtocol(PD);
2553 return GetOrEmitProtocolRef(PD);
2556 static void assertPrivateName(const llvm::GlobalValue *GV) {
2557 StringRef NameRef = GV->getName();
2559 assert(NameRef[0] == '\01' && (NameRef[1] == 'L' || NameRef[1] == 'l'));
2560 assert(GV->getVisibility() == llvm::GlobalValue::DefaultVisibility);
2561 assert(GV->hasPrivateLinkage());
2565 // Objective-C 1.0 extensions
2566 struct _objc_protocol {
2567 struct _objc_protocol_extension *isa;
2568 char *protocol_name;
2569 struct _objc_protocol_list *protocol_list;
2570 struct _objc__method_prototype_list *instance_methods;
2571 struct _objc__method_prototype_list *class_methods
2574 See EmitProtocolExtension().
2576 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
2577 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
2579 // Early exit if a defining object has already been generated.
2580 if (Entry && Entry->hasInitializer())
2583 // Use the protocol definition, if there is one.
2584 if (const ObjCProtocolDecl *Def = PD->getDefinition())
2587 // FIXME: I don't understand why gcc generates this, or where it is
2588 // resolved. Investigate. Its also wasteful to look this up over and over.
2589 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2591 // Construct method lists.
2592 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
2593 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
2594 std::vector<llvm::Constant*> MethodTypesExt, OptMethodTypesExt;
2595 for (const auto *MD : PD->instance_methods()) {
2596 llvm::Constant *C = GetMethodDescriptionConstant(MD);
2598 return GetOrEmitProtocolRef(PD);
2600 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
2601 OptInstanceMethods.push_back(C);
2602 OptMethodTypesExt.push_back(GetMethodVarType(MD, true));
2604 InstanceMethods.push_back(C);
2605 MethodTypesExt.push_back(GetMethodVarType(MD, true));
2609 for (const auto *MD : PD->class_methods()) {
2610 llvm::Constant *C = GetMethodDescriptionConstant(MD);
2612 return GetOrEmitProtocolRef(PD);
2614 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
2615 OptClassMethods.push_back(C);
2616 OptMethodTypesExt.push_back(GetMethodVarType(MD, true));
2618 ClassMethods.push_back(C);
2619 MethodTypesExt.push_back(GetMethodVarType(MD, true));
2623 MethodTypesExt.insert(MethodTypesExt.end(),
2624 OptMethodTypesExt.begin(), OptMethodTypesExt.end());
2626 llvm::Constant *Values[] = {
2627 EmitProtocolExtension(PD, OptInstanceMethods, OptClassMethods,
2629 GetClassName(PD->getObjCRuntimeNameAsString()),
2630 EmitProtocolList("\01L_OBJC_PROTOCOL_REFS_" + PD->getName(),
2631 PD->protocol_begin(),
2632 PD->protocol_end()),
2633 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_" + PD->getName(),
2634 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
2636 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_" + PD->getName(),
2637 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2640 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
2644 // Already created, update the initializer.
2645 assert(Entry->hasPrivateLinkage());
2646 Entry->setInitializer(Init);
2649 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, false,
2650 llvm::GlobalValue::PrivateLinkage,
2652 "\01L_OBJC_PROTOCOL_" + PD->getName());
2653 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
2654 // FIXME: Is this necessary? Why only for protocol?
2655 Entry->setAlignment(4);
2657 Protocols[PD->getIdentifier()] = Entry;
2659 assertPrivateName(Entry);
2660 CGM.addCompilerUsedGlobal(Entry);
2665 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
2666 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
2669 // We use the initializer as a marker of whether this is a forward
2670 // reference or not. At module finalization we add the empty
2671 // contents for protocols which were referenced but never defined.
2673 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, false,
2674 llvm::GlobalValue::PrivateLinkage,
2676 "\01L_OBJC_PROTOCOL_" + PD->getName());
2677 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
2678 // FIXME: Is this necessary? Why only for protocol?
2679 Entry->setAlignment(4);
2681 assertPrivateName(Entry);
2687 struct _objc_protocol_extension {
2689 struct objc_method_description_list *optional_instance_methods;
2690 struct objc_method_description_list *optional_class_methods;
2691 struct objc_property_list *instance_properties;
2692 const char ** extendedMethodTypes;
2696 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
2697 ArrayRef<llvm::Constant*> OptInstanceMethods,
2698 ArrayRef<llvm::Constant*> OptClassMethods,
2699 ArrayRef<llvm::Constant*> MethodTypesExt) {
2701 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
2702 llvm::Constant *Values[] = {
2703 llvm::ConstantInt::get(ObjCTypes.IntTy, Size),
2704 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_OPT_"
2706 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
2707 OptInstanceMethods),
2708 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_OPT_" + PD->getName(),
2709 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2711 EmitPropertyList("\01L_OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr,
2713 EmitProtocolMethodTypes("\01L_OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
2714 MethodTypesExt, ObjCTypes)
2717 // Return null if no extension bits are used.
2718 if (Values[1]->isNullValue() && Values[2]->isNullValue() &&
2719 Values[3]->isNullValue() && Values[4]->isNullValue())
2720 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
2722 llvm::Constant *Init =
2723 llvm::ConstantStruct::get(ObjCTypes.ProtocolExtensionTy, Values);
2725 // No special section, but goes in llvm.used
2726 return CreateMetadataVar("\01l_OBJC_PROTOCOLEXT_" + PD->getName(), Init,
2727 StringRef(), 0, true);
2731 struct objc_protocol_list {
2732 struct objc_protocol_list *next;
2738 CGObjCMac::EmitProtocolList(Twine Name,
2739 ObjCProtocolDecl::protocol_iterator begin,
2740 ObjCProtocolDecl::protocol_iterator end) {
2741 SmallVector<llvm::Constant *, 16> ProtocolRefs;
2743 for (; begin != end; ++begin)
2744 ProtocolRefs.push_back(GetProtocolRef(*begin));
2746 // Just return null for empty protocol lists
2747 if (ProtocolRefs.empty())
2748 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
2750 // This list is null terminated.
2751 ProtocolRefs.push_back(llvm::Constant::getNullValue(ObjCTypes.ProtocolPtrTy));
2753 llvm::Constant *Values[3];
2754 // This field is only used by the runtime.
2755 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
2756 Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy,
2757 ProtocolRefs.size() - 1);
2759 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolPtrTy,
2760 ProtocolRefs.size()),
2763 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
2764 llvm::GlobalVariable *GV =
2765 CreateMetadataVar(Name, Init, "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2767 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
2770 void CGObjCCommonMac::
2771 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
2772 SmallVectorImpl<llvm::Constant *> &Properties,
2773 const Decl *Container,
2774 const ObjCProtocolDecl *Proto,
2775 const ObjCCommonTypesHelper &ObjCTypes) {
2776 for (const auto *P : Proto->protocols())
2777 PushProtocolProperties(PropertySet, Properties, Container, P, ObjCTypes);
2778 for (const auto *PD : Proto->properties()) {
2779 if (!PropertySet.insert(PD->getIdentifier()))
2781 llvm::Constant *Prop[] = {
2782 GetPropertyName(PD->getIdentifier()),
2783 GetPropertyTypeString(PD, Container)
2785 Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy, Prop));
2790 struct _objc_property {
2791 const char * const name;
2792 const char * const attributes;
2795 struct _objc_property_list {
2796 uint32_t entsize; // sizeof (struct _objc_property)
2797 uint32_t prop_count;
2798 struct _objc_property[prop_count];
2801 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
2802 const Decl *Container,
2803 const ObjCContainerDecl *OCD,
2804 const ObjCCommonTypesHelper &ObjCTypes) {
2805 SmallVector<llvm::Constant *, 16> Properties;
2806 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
2807 for (const auto *PD : OCD->properties()) {
2808 PropertySet.insert(PD->getIdentifier());
2809 llvm::Constant *Prop[] = {
2810 GetPropertyName(PD->getIdentifier()),
2811 GetPropertyTypeString(PD, Container)
2813 Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy,
2816 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
2817 for (const auto *P : OID->all_referenced_protocols())
2818 PushProtocolProperties(PropertySet, Properties, Container, P, ObjCTypes);
2820 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
2821 for (const auto *P : CD->protocols())
2822 PushProtocolProperties(PropertySet, Properties, Container, P, ObjCTypes);
2825 // Return null for empty list.
2826 if (Properties.empty())
2827 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
2829 unsigned PropertySize =
2830 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
2831 llvm::Constant *Values[3];
2832 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, PropertySize);
2833 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Properties.size());
2834 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.PropertyTy,
2836 Values[2] = llvm::ConstantArray::get(AT, Properties);
2837 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
2839 llvm::GlobalVariable *GV =
2840 CreateMetadataVar(Name, Init,
2841 (ObjCABI == 2) ? "__DATA, __objc_const" :
2842 "__OBJC,__property,regular,no_dead_strip",
2843 (ObjCABI == 2) ? 8 : 4,
2845 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
2849 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
2850 ArrayRef<llvm::Constant*> MethodTypes,
2851 const ObjCCommonTypesHelper &ObjCTypes) {
2852 // Return null for empty list.
2853 if (MethodTypes.empty())
2854 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
2856 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
2857 MethodTypes.size());
2858 llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
2860 llvm::GlobalVariable *GV = CreateMetadataVar(
2861 Name, Init, (ObjCABI == 2) ? "__DATA, __objc_const" : StringRef(),
2862 (ObjCABI == 2) ? 8 : 4, true);
2863 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
2867 struct objc_method_description_list {
2869 struct objc_method_description list[];
2873 CGObjCMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
2874 llvm::Constant *Desc[] = {
2875 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
2876 ObjCTypes.SelectorPtrTy),
2877 GetMethodVarType(MD)
2882 return llvm::ConstantStruct::get(ObjCTypes.MethodDescriptionTy,
2887 CGObjCMac::EmitMethodDescList(Twine Name, const char *Section,
2888 ArrayRef<llvm::Constant*> Methods) {
2889 // Return null for empty list.
2890 if (Methods.empty())
2891 return llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
2893 llvm::Constant *Values[2];
2894 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
2895 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodDescriptionTy,
2897 Values[1] = llvm::ConstantArray::get(AT, Methods);
2898 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
2900 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 4, true);
2901 return llvm::ConstantExpr::getBitCast(GV,
2902 ObjCTypes.MethodDescriptionListPtrTy);
2906 struct _objc_category {
2907 char *category_name;
2909 struct _objc_method_list *instance_methods;
2910 struct _objc_method_list *class_methods;
2911 struct _objc_protocol_list *protocols;
2912 uint32_t size; // <rdar://4585769>
2913 struct _objc_property_list *instance_properties;
2916 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
2917 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
2919 // FIXME: This is poor design, the OCD should have a pointer to the category
2920 // decl. Additionally, note that Category can be null for the @implementation
2921 // w/o an @interface case. Sema should just create one for us as it does for
2922 // @implementation so everyone else can live life under a clear blue sky.
2923 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
2924 const ObjCCategoryDecl *Category =
2925 Interface->FindCategoryDeclaration(OCD->getIdentifier());
2927 SmallString<256> ExtName;
2928 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
2931 SmallVector<llvm::Constant *, 16> InstanceMethods, ClassMethods;
2932 for (const auto *I : OCD->instance_methods())
2933 // Instance methods should always be defined.
2934 InstanceMethods.push_back(GetMethodConstant(I));
2936 for (const auto *I : OCD->class_methods())
2937 // Class methods should always be defined.
2938 ClassMethods.push_back(GetMethodConstant(I));
2940 llvm::Constant *Values[7];
2941 Values[0] = GetClassName(OCD->getName());
2942 Values[1] = GetClassName(Interface->getObjCRuntimeNameAsString());
2943 LazySymbols.insert(Interface->getIdentifier());
2945 EmitMethodList("\01L_OBJC_CATEGORY_INSTANCE_METHODS_" + ExtName.str(),
2946 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
2949 EmitMethodList("\01L_OBJC_CATEGORY_CLASS_METHODS_" + ExtName.str(),
2950 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2954 EmitProtocolList("\01L_OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
2955 Category->protocol_begin(),
2956 Category->protocol_end());
2958 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
2960 Values[5] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
2962 // If there is no category @interface then there can be no properties.
2964 Values[6] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
2965 OCD, Category, ObjCTypes);
2967 Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
2970 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.CategoryTy,
2973 llvm::GlobalVariable *GV =
2974 CreateMetadataVar("\01L_OBJC_CATEGORY_" + ExtName.str(), Init,
2975 "__OBJC,__category,regular,no_dead_strip",
2977 DefinedCategories.push_back(GV);
2978 DefinedCategoryNames.insert(ExtName.str());
2979 // method definition entries must be clear for next implementation.
2980 MethodDefinitions.clear();
2983 enum FragileClassFlags {
2984 FragileABI_Class_Factory = 0x00001,
2985 FragileABI_Class_Meta = 0x00002,
2986 FragileABI_Class_HasCXXStructors = 0x02000,
2987 FragileABI_Class_Hidden = 0x20000
2990 enum NonFragileClassFlags {
2991 /// Is a meta-class.
2992 NonFragileABI_Class_Meta = 0x00001,
2994 /// Is a root class.
2995 NonFragileABI_Class_Root = 0x00002,
2997 /// Has a C++ constructor and destructor.
2998 NonFragileABI_Class_HasCXXStructors = 0x00004,
3000 /// Has hidden visibility.
3001 NonFragileABI_Class_Hidden = 0x00010,
3003 /// Has the exception attribute.
3004 NonFragileABI_Class_Exception = 0x00020,
3006 /// (Obsolete) ARC-specific: this class has a .release_ivars method
3007 NonFragileABI_Class_HasIvarReleaser = 0x00040,
3009 /// Class implementation was compiled under ARC.
3010 NonFragileABI_Class_CompiledByARC = 0x00080,
3012 /// Class has non-trivial destructors, but zero-initialization is okay.
3013 NonFragileABI_Class_HasCXXDestructorOnly = 0x00100
3017 struct _objc_class {
3024 struct _objc_ivar_list *ivars;
3025 struct _objc_method_list *methods;
3026 struct _objc_cache *cache;
3027 struct _objc_protocol_list *protocols;
3028 // Objective-C 1.0 extensions (<rdr://4585769>)
3029 const char *ivar_layout;
3030 struct _objc_class_ext *ext;
3033 See EmitClassExtension();
3035 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3036 DefinedSymbols.insert(ID->getIdentifier());
3038 std::string ClassName = ID->getNameAsString();
3040 ObjCInterfaceDecl *Interface =
3041 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3042 llvm::Constant *Protocols =
3043 EmitProtocolList("\01L_OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3044 Interface->all_referenced_protocol_begin(),
3045 Interface->all_referenced_protocol_end());
3046 unsigned Flags = FragileABI_Class_Factory;
3047 if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3048 Flags |= FragileABI_Class_HasCXXStructors;
3050 CGM.getContext().getASTObjCImplementationLayout(ID).getSize().getQuantity();
3052 // FIXME: Set CXX-structors flag.
3053 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3054 Flags |= FragileABI_Class_Hidden;
3056 SmallVector<llvm::Constant *, 16> InstanceMethods, ClassMethods;
3057 for (const auto *I : ID->instance_methods())
3058 // Instance methods should always be defined.
3059 InstanceMethods.push_back(GetMethodConstant(I));
3061 for (const auto *I : ID->class_methods())
3062 // Class methods should always be defined.
3063 ClassMethods.push_back(GetMethodConstant(I));
3065 for (const auto *PID : ID->property_impls()) {
3066 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3067 ObjCPropertyDecl *PD = PID->getPropertyDecl();
3069 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
3070 if (llvm::Constant *C = GetMethodConstant(MD))
3071 InstanceMethods.push_back(C);
3072 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
3073 if (llvm::Constant *C = GetMethodConstant(MD))
3074 InstanceMethods.push_back(C);
3078 llvm::Constant *Values[12];
3079 Values[ 0] = EmitMetaClass(ID, Protocols, ClassMethods);
3080 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3081 // Record a reference to the super class.
3082 LazySymbols.insert(Super->getIdentifier());
3085 llvm::ConstantExpr::getBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3086 ObjCTypes.ClassPtrTy);
3088 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
3090 Values[ 2] = GetClassName(ID->getObjCRuntimeNameAsString());
3091 // Version is always 0.
3092 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
3093 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
3094 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
3095 Values[ 6] = EmitIvarList(ID, false);
3097 EmitMethodList("\01L_OBJC_INSTANCE_METHODS_" + ID->getName(),
3098 "__OBJC,__inst_meth,regular,no_dead_strip",
3100 // cache is always NULL.
3101 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
3102 Values[ 9] = Protocols;
3103 Values[10] = BuildIvarLayout(ID, true);
3104 Values[11] = EmitClassExtension(ID);
3105 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
3107 std::string Name("\01L_OBJC_CLASS_");
3109 const char *Section = "__OBJC,__class,regular,no_dead_strip";
3110 // Check for a forward reference.
3111 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3113 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3114 "Forward metaclass reference has incorrect type.");
3115 GV->setInitializer(Init);
3116 GV->setSection(Section);
3117 GV->setAlignment(4);
3118 CGM.addCompilerUsedGlobal(GV);
3120 GV = CreateMetadataVar(Name, Init, Section, 4, true);
3121 assertPrivateName(GV);
3122 DefinedClasses.push_back(GV);
3123 ImplementedClasses.push_back(Interface);
3124 // method definition entries must be clear for next implementation.
3125 MethodDefinitions.clear();
3128 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3129 llvm::Constant *Protocols,
3130 ArrayRef<llvm::Constant*> Methods) {
3131 unsigned Flags = FragileABI_Class_Meta;
3132 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3134 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3135 Flags |= FragileABI_Class_Hidden;
3137 llvm::Constant *Values[12];
3138 // The isa for the metaclass is the root of the hierarchy.
3139 const ObjCInterfaceDecl *Root = ID->getClassInterface();
3140 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3143 llvm::ConstantExpr::getBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3144 ObjCTypes.ClassPtrTy);
3145 // The super class for the metaclass is emitted as the name of the
3146 // super class. The runtime fixes this up to point to the
3147 // *metaclass* for the super class.
3148 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3150 llvm::ConstantExpr::getBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3151 ObjCTypes.ClassPtrTy);
3153 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
3155 Values[ 2] = GetClassName(ID->getObjCRuntimeNameAsString());
3156 // Version is always 0.
3157 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
3158 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
3159 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
3160 Values[ 6] = EmitIvarList(ID, true);
3162 EmitMethodList("\01L_OBJC_CLASS_METHODS_" + ID->getNameAsString(),
3163 "__OBJC,__cls_meth,regular,no_dead_strip",
3165 // cache is always NULL.
3166 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
3167 Values[ 9] = Protocols;
3168 // ivar_layout for metaclass is always NULL.
3169 Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
3170 // The class extension is always unused for metaclasses.
3171 Values[11] = llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3172 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
3175 std::string Name("\01L_OBJC_METACLASS_");
3176 Name += ID->getName();
3178 // Check for a forward reference.
3179 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3181 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3182 "Forward metaclass reference has incorrect type.");
3183 GV->setInitializer(Init);
3185 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3186 llvm::GlobalValue::PrivateLinkage,
3189 assertPrivateName(GV);
3190 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3191 GV->setAlignment(4);
3192 CGM.addCompilerUsedGlobal(GV);
3197 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3198 std::string Name = "\01L_OBJC_METACLASS_" + ID->getNameAsString();
3200 // FIXME: Should we look these up somewhere other than the module. Its a bit
3201 // silly since we only generate these while processing an implementation, so
3202 // exactly one pointer would work if know when we entered/exitted an
3203 // implementation block.
3205 // Check for an existing forward reference.
3206 // Previously, metaclass with internal linkage may have been defined.
3207 // pass 'true' as 2nd argument so it is returned.
3208 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3210 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3211 llvm::GlobalValue::PrivateLinkage, nullptr,
3214 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3215 "Forward metaclass reference has incorrect type.");
3216 assertPrivateName(GV);
3220 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3221 std::string Name = "\01L_OBJC_CLASS_" + ID->getNameAsString();
3222 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3225 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3226 llvm::GlobalValue::PrivateLinkage, nullptr,
3229 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3230 "Forward class metadata reference has incorrect type.");
3231 assertPrivateName(GV);
3236 struct objc_class_ext {
3238 const char *weak_ivar_layout;
3239 struct _objc_property_list *properties;
3243 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID) {
3245 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3247 llvm::Constant *Values[3];
3248 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
3249 Values[1] = BuildIvarLayout(ID, false);
3250 Values[2] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getName(),
3251 ID, ID->getClassInterface(), ObjCTypes);
3253 // Return null if no extension bits are used.
3254 if (Values[1]->isNullValue() && Values[2]->isNullValue())
3255 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3257 llvm::Constant *Init =
3258 llvm::ConstantStruct::get(ObjCTypes.ClassExtensionTy, Values);
3259 return CreateMetadataVar("\01L_OBJC_CLASSEXT_" + ID->getName(),
3260 Init, "__OBJC,__class_ext,regular,no_dead_strip",
3271 struct objc_ivar_list {
3273 struct objc_ivar list[count];
3276 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3278 std::vector<llvm::Constant*> Ivars;
3280 // When emitting the root class GCC emits ivar entries for the
3281 // actual class structure. It is not clear if we need to follow this
3282 // behavior; for now lets try and get away with not doing it. If so,
3283 // the cleanest solution would be to make up an ObjCInterfaceDecl
3286 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3288 const ObjCInterfaceDecl *OID = ID->getClassInterface();
3290 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3291 IVD; IVD = IVD->getNextIvar()) {
3292 // Ignore unnamed bit-fields.
3293 if (!IVD->getDeclName())
3295 llvm::Constant *Ivar[] = {
3296 GetMethodVarName(IVD->getIdentifier()),
3297 GetMethodVarType(IVD),
3298 llvm::ConstantInt::get(ObjCTypes.IntTy,
3299 ComputeIvarBaseOffset(CGM, OID, IVD))
3301 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarTy, Ivar));
3304 // Return null for empty list.
3306 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3308 llvm::Constant *Values[2];
3309 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
3310 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarTy,
3312 Values[1] = llvm::ConstantArray::get(AT, Ivars);
3313 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
3315 llvm::GlobalVariable *GV;
3317 GV = CreateMetadataVar("\01L_OBJC_CLASS_VARIABLES_" + ID->getName(),
3318 Init, "__OBJC,__class_vars,regular,no_dead_strip",
3321 GV = CreateMetadataVar("\01L_OBJC_INSTANCE_VARIABLES_" + ID->getName(),
3322 Init, "__OBJC,__instance_vars,regular,no_dead_strip",
3324 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3328 struct objc_method {
3334 struct objc_method_list {
3335 struct objc_method_list *obsolete;
3337 struct objc_method methods_list[count];
3341 /// GetMethodConstant - Return a struct objc_method constant for the
3342 /// given method if it has been defined. The result is null if the
3343 /// method has not been defined. The return value has type MethodPtrTy.
3344 llvm::Constant *CGObjCMac::GetMethodConstant(const ObjCMethodDecl *MD) {
3345 llvm::Function *Fn = GetMethodDefinition(MD);
3349 llvm::Constant *Method[] = {
3350 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
3351 ObjCTypes.SelectorPtrTy),
3352 GetMethodVarType(MD),
3353 llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy)
3355 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
3358 llvm::Constant *CGObjCMac::EmitMethodList(Twine Name,
3359 const char *Section,
3360 ArrayRef<llvm::Constant*> Methods) {
3361 // Return null for empty list.
3362 if (Methods.empty())
3363 return llvm::Constant::getNullValue(ObjCTypes.MethodListPtrTy);
3365 llvm::Constant *Values[3];
3366 Values[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
3367 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
3368 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
3370 Values[2] = llvm::ConstantArray::get(AT, Methods);
3371 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
3373 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 4, true);
3374 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
3377 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
3378 const ObjCContainerDecl *CD) {
3379 SmallString<256> Name;
3380 GetNameForMethod(OMD, CD, Name);
3382 CodeGenTypes &Types = CGM.getTypes();
3383 llvm::FunctionType *MethodTy =
3384 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
3385 llvm::Function *Method =
3386 llvm::Function::Create(MethodTy,
3387 llvm::GlobalValue::InternalLinkage,
3390 MethodDefinitions.insert(std::make_pair(OMD, Method));
3395 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3396 llvm::Constant *Init,
3400 llvm::Type *Ty = Init->getType();
3401 llvm::GlobalVariable *GV =
3402 new llvm::GlobalVariable(CGM.getModule(), Ty, false,
3403 llvm::GlobalValue::PrivateLinkage, Init, Name);
3404 assertPrivateName(GV);
3405 if (!Section.empty())
3406 GV->setSection(Section);
3408 GV->setAlignment(Align);
3410 CGM.addCompilerUsedGlobal(GV);
3414 llvm::Function *CGObjCMac::ModuleInitFunction() {
3415 // Abuse this interface function as a place to finalize.
3420 llvm::Constant *CGObjCMac::GetPropertyGetFunction() {
3421 return ObjCTypes.getGetPropertyFn();
3424 llvm::Constant *CGObjCMac::GetPropertySetFunction() {
3425 return ObjCTypes.getSetPropertyFn();
3428 llvm::Constant *CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
3430 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
3433 llvm::Constant *CGObjCMac::GetGetStructFunction() {
3434 return ObjCTypes.getCopyStructFn();
3436 llvm::Constant *CGObjCMac::GetSetStructFunction() {
3437 return ObjCTypes.getCopyStructFn();
3440 llvm::Constant *CGObjCMac::GetCppAtomicObjectGetFunction() {
3441 return ObjCTypes.getCppAtomicObjectFunction();
3443 llvm::Constant *CGObjCMac::GetCppAtomicObjectSetFunction() {
3444 return ObjCTypes.getCppAtomicObjectFunction();
3447 llvm::Constant *CGObjCMac::EnumerationMutationFunction() {
3448 return ObjCTypes.getEnumerationMutationFn();
3451 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
3452 return EmitTryOrSynchronizedStmt(CGF, S);
3455 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
3456 const ObjCAtSynchronizedStmt &S) {
3457 return EmitTryOrSynchronizedStmt(CGF, S);
3461 struct PerformFragileFinally : EHScopeStack::Cleanup {
3463 llvm::Value *SyncArgSlot;
3464 llvm::Value *CallTryExitVar;
3465 llvm::Value *ExceptionData;
3466 ObjCTypesHelper &ObjCTypes;
3467 PerformFragileFinally(const Stmt *S,
3468 llvm::Value *SyncArgSlot,
3469 llvm::Value *CallTryExitVar,
3470 llvm::Value *ExceptionData,
3471 ObjCTypesHelper *ObjCTypes)
3472 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
3473 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
3475 void Emit(CodeGenFunction &CGF, Flags flags) override {
3476 // Check whether we need to call objc_exception_try_exit.
3477 // In optimized code, this branch will always be folded.
3478 llvm::BasicBlock *FinallyCallExit =
3479 CGF.createBasicBlock("finally.call_exit");
3480 llvm::BasicBlock *FinallyNoCallExit =
3481 CGF.createBasicBlock("finally.no_call_exit");
3482 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
3483 FinallyCallExit, FinallyNoCallExit);
3485 CGF.EmitBlock(FinallyCallExit);
3486 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
3489 CGF.EmitBlock(FinallyNoCallExit);
3491 if (isa<ObjCAtTryStmt>(S)) {
3492 if (const ObjCAtFinallyStmt* FinallyStmt =
3493 cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
3494 // Don't try to do the @finally if this is an EH cleanup.
3495 if (flags.isForEHCleanup()) return;
3497 // Save the current cleanup destination in case there's
3498 // control flow inside the finally statement.
3499 llvm::Value *CurCleanupDest =
3500 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
3502 CGF.EmitStmt(FinallyStmt->getFinallyBody());
3504 if (CGF.HaveInsertPoint()) {
3505 CGF.Builder.CreateStore(CurCleanupDest,
3506 CGF.getNormalCleanupDestSlot());
3508 // Currently, the end of the cleanup must always exist.
3509 CGF.EnsureInsertPoint();
3513 // Emit objc_sync_exit(expr); as finally's sole statement for
3515 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
3516 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
3521 class FragileHazards {
3522 CodeGenFunction &CGF;
3523 SmallVector<llvm::Value*, 20> Locals;
3524 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
3526 llvm::InlineAsm *ReadHazard;
3527 llvm::InlineAsm *WriteHazard;
3529 llvm::FunctionType *GetAsmFnType();
3531 void collectLocals();
3532 void emitReadHazard(CGBuilderTy &Builder);
3535 FragileHazards(CodeGenFunction &CGF);
3537 void emitWriteHazard();
3538 void emitHazardsInNewBlocks();
3542 /// Create the fragile-ABI read and write hazards based on the current
3543 /// state of the function, which is presumed to be immediately prior
3544 /// to a @try block. These hazards are used to maintain correct
3545 /// semantics in the face of optimization and the fragile ABI's
3546 /// cavalier use of setjmp/longjmp.
3547 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
3550 if (Locals.empty()) return;
3552 // Collect all the blocks in the function.
3553 for (llvm::Function::iterator
3554 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
3555 BlocksBeforeTry.insert(&*I);
3557 llvm::FunctionType *AsmFnTy = GetAsmFnType();
3559 // Create a read hazard for the allocas. This inhibits dead-store
3560 // optimizations and forces the values to memory. This hazard is
3561 // inserted before any 'throwing' calls in the protected scope to
3562 // reflect the possibility that the variables might be read from the
3563 // catch block if the call throws.
3565 std::string Constraint;
3566 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
3567 if (I) Constraint += ',';
3571 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
3574 // Create a write hazard for the allocas. This inhibits folding
3575 // loads across the hazard. This hazard is inserted at the
3576 // beginning of the catch path to reflect the possibility that the
3577 // variables might have been written within the protected scope.
3579 std::string Constraint;
3580 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
3581 if (I) Constraint += ',';
3582 Constraint += "=*m";
3585 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
3589 /// Emit a write hazard at the current location.
3590 void FragileHazards::emitWriteHazard() {
3591 if (Locals.empty()) return;
3593 CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
3596 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
3597 assert(!Locals.empty());
3598 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
3599 call->setDoesNotThrow();
3600 call->setCallingConv(CGF.getRuntimeCC());
3603 /// Emit read hazards in all the protected blocks, i.e. all the blocks
3604 /// which have been inserted since the beginning of the try.
3605 void FragileHazards::emitHazardsInNewBlocks() {
3606 if (Locals.empty()) return;
3608 CGBuilderTy Builder(CGF.getLLVMContext());
3610 // Iterate through all blocks, skipping those prior to the try.
3611 for (llvm::Function::iterator
3612 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
3613 llvm::BasicBlock &BB = *FI;
3614 if (BlocksBeforeTry.count(&BB)) continue;
3616 // Walk through all the calls in the block.
3617 for (llvm::BasicBlock::iterator
3618 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
3619 llvm::Instruction &I = *BI;
3621 // Ignore instructions that aren't non-intrinsic calls.
3622 // These are the only calls that can possibly call longjmp.
3623 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) continue;
3624 if (isa<llvm::IntrinsicInst>(I))
3627 // Ignore call sites marked nounwind. This may be questionable,
3628 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
3629 llvm::CallSite CS(&I);
3630 if (CS.doesNotThrow()) continue;
3632 // Insert a read hazard before the call. This will ensure that
3633 // any writes to the locals are performed before making the
3634 // call. If the call throws, then this is sufficient to
3635 // guarantee correctness as long as it doesn't also write to any
3637 Builder.SetInsertPoint(&BB, BI);
3638 emitReadHazard(Builder);
3643 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, llvm::Value *V) {
3647 void FragileHazards::collectLocals() {
3648 // Compute a set of allocas to ignore.
3649 llvm::DenseSet<llvm::Value*> AllocasToIgnore;
3650 addIfPresent(AllocasToIgnore, CGF.ReturnValue);
3651 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
3653 // Collect all the allocas currently in the function. This is
3654 // probably way too aggressive.
3655 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
3656 for (llvm::BasicBlock::iterator
3657 I = Entry.begin(), E = Entry.end(); I != E; ++I)
3658 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
3659 Locals.push_back(&*I);
3662 llvm::FunctionType *FragileHazards::GetAsmFnType() {
3663 SmallVector<llvm::Type *, 16> tys(Locals.size());
3664 for (unsigned i = 0, e = Locals.size(); i != e; ++i)
3665 tys[i] = Locals[i]->getType();
3666 return llvm::FunctionType::get(CGF.VoidTy, tys, false);
3671 Objective-C setjmp-longjmp (sjlj) Exception Handling
3674 A catch buffer is a setjmp buffer plus:
3675 - a pointer to the exception that was caught
3676 - a pointer to the previous exception data buffer
3677 - two pointers of reserved storage
3678 Therefore catch buffers form a stack, with a pointer to the top
3679 of the stack kept in thread-local storage.
3681 objc_exception_try_enter pushes a catch buffer onto the EH stack.
3682 objc_exception_try_exit pops the given catch buffer, which is
3683 required to be the top of the EH stack.
3684 objc_exception_throw pops the top of the EH stack, writes the
3685 thrown exception into the appropriate field, and longjmps
3686 to the setjmp buffer. It crashes the process (with a printf
3687 and an abort()) if there are no catch buffers on the stack.
3688 objc_exception_extract just reads the exception pointer out of the
3691 There's no reason an implementation couldn't use a light-weight
3692 setjmp here --- something like __builtin_setjmp, but API-compatible
3693 with the heavyweight setjmp. This will be more important if we ever
3694 want to implement correct ObjC/C++ exception interactions for the
3697 Note that for this use of setjmp/longjmp to be correct, we may need
3698 to mark some local variables volatile: if a non-volatile local
3699 variable is modified between the setjmp and the longjmp, it has
3700 indeterminate value. For the purposes of LLVM IR, it may be
3701 sufficient to make loads and stores within the @try (to variables
3702 declared outside the @try) volatile. This is necessary for
3703 optimized correctness, but is not currently being done; this is
3704 being tracked as rdar://problem/8160285
3706 The basic framework for a @try-catch-finally is as follows:
3708 objc_exception_data d;
3710 bool _call_try_exit = true;
3712 objc_exception_try_enter(&d);
3713 if (!setjmp(d.jmp_buf)) {
3717 id _caught = objc_exception_extract(&d);
3719 // enter new try scope for handlers
3720 if (!setjmp(d.jmp_buf)) {
3721 ... match exception and execute catch blocks ...
3723 // fell off end, rethrow.
3725 ... jump-through-finally to finally_rethrow ...
3727 // exception in catch block
3728 _rethrow = objc_exception_extract(&d);
3729 _call_try_exit = false;
3730 ... jump-through-finally to finally_rethrow ...
3733 ... jump-through-finally to finally_end ...
3737 objc_exception_try_exit(&d);
3739 ... finally block ....
3740 ... dispatch to finally destination ...
3743 objc_exception_throw(_rethrow);
3748 This framework differs slightly from the one gcc uses, in that gcc
3749 uses _rethrow to determine if objc_exception_try_exit should be called
3750 and if the object should be rethrown. This breaks in the face of
3751 throwing nil and introduces unnecessary branches.
3753 We specialize this framework for a few particular circumstances:
3755 - If there are no catch blocks, then we avoid emitting the second
3756 exception handling context.
3758 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
3759 e)) we avoid emitting the code to rethrow an uncaught exception.
3761 - FIXME: If there is no @finally block we can do a few more
3764 Rethrows and Jumps-Through-Finally
3767 '@throw;' is supported by pushing the currently-caught exception
3768 onto ObjCEHStack while the @catch blocks are emitted.
3770 Branches through the @finally block are handled with an ordinary
3771 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
3772 exceptions are not compatible with C++ exceptions, and this is
3773 hardly the only place where this will go wrong.
3775 @synchronized(expr) { stmt; } is emitted as if it were:
3776 id synch_value = expr;
3777 objc_sync_enter(synch_value);
3778 @try { stmt; } @finally { objc_sync_exit(synch_value); }
3781 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
3783 bool isTry = isa<ObjCAtTryStmt>(S);
3785 // A destination for the fall-through edges of the catch handlers to
3787 CodeGenFunction::JumpDest FinallyEnd =
3788 CGF.getJumpDestInCurrentScope("finally.end");
3790 // A destination for the rethrow edge of the catch handlers to jump
3792 CodeGenFunction::JumpDest FinallyRethrow =
3793 CGF.getJumpDestInCurrentScope("finally.rethrow");
3795 // For @synchronized, call objc_sync_enter(sync.expr). The
3796 // evaluation of the expression must occur before we enter the
3797 // @synchronized. We can't avoid a temp here because we need the
3798 // value to be preserved. If the backend ever does liveness
3799 // correctly after setjmp, this will be unnecessary.
3800 llvm::Value *SyncArgSlot = nullptr;
3802 llvm::Value *SyncArg =
3803 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
3804 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
3805 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
3807 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(), "sync.arg");
3808 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
3811 // Allocate memory for the setjmp buffer. This needs to be kept
3812 // live throughout the try and catch blocks.
3813 llvm::Value *ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
3814 "exceptiondata.ptr");
3816 // Create the fragile hazards. Note that this will not capture any
3817 // of the allocas required for exception processing, but will
3818 // capture the current basic block (which extends all the way to the
3819 // setjmp call) as "before the @try".
3820 FragileHazards Hazards(CGF);
3822 // Create a flag indicating whether the cleanup needs to call
3823 // objc_exception_try_exit. This is true except when
3824 // - no catches match and we're branching through the cleanup
3825 // just to rethrow the exception, or
3826 // - a catch matched and we're falling out of the catch handler.
3827 // The setjmp-safety rule here is that we should always store to this
3828 // variable in a place that dominates the branch through the cleanup
3829 // without passing through any setjmps.
3830 llvm::Value *CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
3833 // A slot containing the exception to rethrow. Only needed when we
3834 // have both a @catch and a @finally.
3835 llvm::Value *PropagatingExnVar = nullptr;
3837 // Push a normal cleanup to leave the try scope.
3838 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
3844 // Enter a try block:
3845 // - Call objc_exception_try_enter to push ExceptionData on top of
3847 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(), ExceptionData);
3849 // - Call setjmp on the exception data buffer.
3850 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
3851 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
3852 llvm::Value *SetJmpBuffer =
3853 CGF.Builder.CreateGEP(ExceptionData, GEPIndexes, "setjmp_buffer");
3854 llvm::CallInst *SetJmpResult =
3855 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
3856 SetJmpResult->setCanReturnTwice();
3858 // If setjmp returned 0, enter the protected block; otherwise,
3859 // branch to the handler.
3860 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
3861 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
3862 llvm::Value *DidCatch =
3863 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
3864 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
3866 // Emit the protected block.
3867 CGF.EmitBlock(TryBlock);
3868 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
3869 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
3870 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
3872 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
3874 // Emit the exception handler block.
3875 CGF.EmitBlock(TryHandler);
3877 // Don't optimize loads of the in-scope locals across this point.
3878 Hazards.emitWriteHazard();
3880 // For a @synchronized (or a @try with no catches), just branch
3881 // through the cleanup to the rethrow block.
3882 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
3883 // Tell the cleanup not to re-pop the exit.
3884 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
3885 CGF.EmitBranchThroughCleanup(FinallyRethrow);
3887 // Otherwise, we have to match against the caught exceptions.
3889 // Retrieve the exception object. We may emit multiple blocks but
3890 // nothing can cross this so the value is already in SSA form.
3891 llvm::CallInst *Caught =
3892 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
3893 ExceptionData, "caught");
3895 // Push the exception to rethrow onto the EH value stack for the
3896 // benefit of any @throws in the handlers.
3897 CGF.ObjCEHValueStack.push_back(Caught);
3899 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
3901 bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
3903 llvm::BasicBlock *CatchBlock = nullptr;
3904 llvm::BasicBlock *CatchHandler = nullptr;
3906 // Save the currently-propagating exception before
3907 // objc_exception_try_enter clears the exception slot.
3908 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
3909 "propagating_exception");
3910 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
3912 // Enter a new exception try block (in case a @catch block
3913 // throws an exception).
3914 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
3917 llvm::CallInst *SetJmpResult =
3918 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
3919 SetJmpBuffer, "setjmp.result");
3920 SetJmpResult->setCanReturnTwice();
3922 llvm::Value *Threw =
3923 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
3925 CatchBlock = CGF.createBasicBlock("catch");
3926 CatchHandler = CGF.createBasicBlock("catch_for_catch");
3927 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
3929 CGF.EmitBlock(CatchBlock);
3932 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
3934 // Handle catch list. As a special case we check if everything is
3935 // matched and avoid generating code for falling off the end if
3937 bool AllMatched = false;
3938 for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
3939 const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
3941 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
3942 const ObjCObjectPointerType *OPT = nullptr;
3944 // catch(...) always matches.
3948 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
3950 // catch(id e) always matches under this ABI, since only
3951 // ObjC exceptions end up here in the first place.
3952 // FIXME: For the time being we also match id<X>; this should
3953 // be rejected by Sema instead.
3954 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
3958 // If this is a catch-all, we don't need to test anything.
3960 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
3963 CGF.EmitAutoVarDecl(*CatchParam);
3964 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
3966 // These types work out because ConvertType(id) == i8*.
3967 CGF.Builder.CreateStore(Caught, CGF.GetAddrOfLocalVar(CatchParam));
3970 CGF.EmitStmt(CatchStmt->getCatchBody());
3972 // The scope of the catch variable ends right here.
3973 CatchVarCleanups.ForceCleanup();
3975 CGF.EmitBranchThroughCleanup(FinallyEnd);
3979 assert(OPT && "Unexpected non-object pointer type in @catch");
3980 const ObjCObjectType *ObjTy = OPT->getObjectType();
3982 // FIXME: @catch (Class c) ?
3983 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
3984 assert(IDecl && "Catch parameter must have Objective-C type!");
3986 // Check if the @catch block matches the exception object.
3987 llvm::Value *Class = EmitClassRef(CGF, IDecl);
3989 llvm::Value *matchArgs[] = { Class, Caught };
3990 llvm::CallInst *Match =
3991 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
3992 matchArgs, "match");
3994 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
3995 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
3997 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
3998 MatchedBlock, NextCatchBlock);
4000 // Emit the @catch block.
4001 CGF.EmitBlock(MatchedBlock);
4003 // Collect any cleanups for the catch variable. The scope lasts until
4004 // the end of the catch body.
4005 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4007 CGF.EmitAutoVarDecl(*CatchParam);
4008 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4010 // Initialize the catch variable.
4012 CGF.Builder.CreateBitCast(Caught,
4013 CGF.ConvertType(CatchParam->getType()));
4014 CGF.Builder.CreateStore(Tmp, CGF.GetAddrOfLocalVar(CatchParam));
4016 CGF.EmitStmt(CatchStmt->getCatchBody());
4018 // We're done with the catch variable.
4019 CatchVarCleanups.ForceCleanup();
4021 CGF.EmitBranchThroughCleanup(FinallyEnd);
4023 CGF.EmitBlock(NextCatchBlock);
4026 CGF.ObjCEHValueStack.pop_back();
4028 // If nothing wanted anything to do with the caught exception,
4029 // kill the extract call.
4030 if (Caught->use_empty())
4031 Caught->eraseFromParent();
4034 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4037 // Emit the exception handler for the @catch blocks.
4038 CGF.EmitBlock(CatchHandler);
4040 // In theory we might now need a write hazard, but actually it's
4041 // unnecessary because there's no local-accessing code between
4042 // the try's write hazard and here.
4043 //Hazards.emitWriteHazard();
4045 // Extract the new exception and save it to the
4046 // propagating-exception slot.
4047 assert(PropagatingExnVar);
4048 llvm::CallInst *NewCaught =
4049 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4050 ExceptionData, "caught");
4051 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4053 // Don't pop the catch handler; the throw already did.
4054 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4055 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4059 // Insert read hazards as required in the new blocks.
4060 Hazards.emitHazardsInNewBlocks();
4063 CGF.Builder.restoreIP(TryFallthroughIP);
4064 if (CGF.HaveInsertPoint())
4065 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4066 CGF.PopCleanupBlock();
4067 CGF.EmitBlock(FinallyEnd.getBlock(), true);
4069 // Emit the rethrow block.
4070 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4071 CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4072 if (CGF.HaveInsertPoint()) {
4073 // If we have a propagating-exception variable, check it.
4074 llvm::Value *PropagatingExn;
4075 if (PropagatingExnVar) {
4076 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4078 // Otherwise, just look in the buffer for the exception to throw.
4080 llvm::CallInst *Caught =
4081 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4083 PropagatingExn = Caught;
4086 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4088 CGF.Builder.CreateUnreachable();
4091 CGF.Builder.restoreIP(SavedIP);
4094 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4095 const ObjCAtThrowStmt &S,
4096 bool ClearInsertionPoint) {
4097 llvm::Value *ExceptionAsObject;
4099 if (const Expr *ThrowExpr = S.getThrowExpr()) {
4100 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4102 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4104 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4105 "Unexpected rethrow outside @catch block.");
4106 ExceptionAsObject = CGF.ObjCEHValueStack.back();
4109 CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4110 ->setDoesNotReturn();
4111 CGF.Builder.CreateUnreachable();
4113 // Clear the insertion point to indicate we are in unreachable code.
4114 if (ClearInsertionPoint)
4115 CGF.Builder.ClearInsertionPoint();
4118 /// EmitObjCWeakRead - Code gen for loading value of a __weak
4119 /// object: objc_read_weak (id *src)
4121 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4122 llvm::Value *AddrWeakObj) {
4123 llvm::Type* DestTy =
4124 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType();
4125 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4126 ObjCTypes.PtrObjectPtrTy);
4127 llvm::Value *read_weak =
4128 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4129 AddrWeakObj, "weakread");
4130 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4134 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4135 /// objc_assign_weak (id src, id *dst)
4137 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4138 llvm::Value *src, llvm::Value *dst) {
4139 llvm::Type * SrcTy = src->getType();
4140 if (!isa<llvm::PointerType>(SrcTy)) {
4141 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4142 assert(Size <= 8 && "does not support size > 8");
4143 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4144 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4145 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4147 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4148 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4149 llvm::Value *args[] = { src, dst };
4150 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4151 args, "weakassign");
4155 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4156 /// objc_assign_global (id src, id *dst)
4158 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4159 llvm::Value *src, llvm::Value *dst,
4161 llvm::Type * SrcTy = src->getType();
4162 if (!isa<llvm::PointerType>(SrcTy)) {
4163 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4164 assert(Size <= 8 && "does not support size > 8");
4165 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4166 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4167 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4169 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4170 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4171 llvm::Value *args[] = { src, dst };
4173 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4174 args, "globalassign");
4176 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4177 args, "threadlocalassign");
4181 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4182 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4184 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4185 llvm::Value *src, llvm::Value *dst,
4186 llvm::Value *ivarOffset) {
4187 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
4188 llvm::Type * SrcTy = src->getType();
4189 if (!isa<llvm::PointerType>(SrcTy)) {
4190 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4191 assert(Size <= 8 && "does not support size > 8");
4192 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4193 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4194 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4196 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4197 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4198 llvm::Value *args[] = { src, dst, ivarOffset };
4199 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
4203 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
4204 /// objc_assign_strongCast (id src, id *dst)
4206 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
4207 llvm::Value *src, llvm::Value *dst) {
4208 llvm::Type * SrcTy = src->getType();
4209 if (!isa<llvm::PointerType>(SrcTy)) {
4210 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4211 assert(Size <= 8 && "does not support size > 8");
4212 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4213 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4214 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4216 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4217 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4218 llvm::Value *args[] = { src, dst };
4219 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
4220 args, "weakassign");
4224 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
4225 llvm::Value *DestPtr,
4226 llvm::Value *SrcPtr,
4227 llvm::Value *size) {
4228 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
4229 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
4230 llvm::Value *args[] = { DestPtr, SrcPtr, size };
4231 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
4234 /// EmitObjCValueForIvar - Code Gen for ivar reference.
4236 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
4238 llvm::Value *BaseValue,
4239 const ObjCIvarDecl *Ivar,
4240 unsigned CVRQualifiers) {
4241 const ObjCInterfaceDecl *ID =
4242 ObjectTy->getAs<ObjCObjectType>()->getInterface();
4243 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
4244 EmitIvarOffset(CGF, ID, Ivar));
4247 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
4248 const ObjCInterfaceDecl *Interface,
4249 const ObjCIvarDecl *Ivar) {
4250 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
4251 return llvm::ConstantInt::get(
4252 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
4256 /* *** Private Interface *** */
4258 /// EmitImageInfo - Emit the image info marker used to encode some module
4259 /// level information.
4261 /// See: <rdr://4810609&4810587&4810587>
4262 /// struct IMAGE_INFO {
4263 /// unsigned version;
4266 enum ImageInfoFlags {
4267 eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang.
4268 eImageInfo_GarbageCollected = (1 << 1),
4269 eImageInfo_GCOnly = (1 << 2),
4270 eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache.
4272 // A flag indicating that the module has no instances of a @synthesize of a
4273 // superclass variable. <rdar://problem/6803242>
4274 eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
4275 eImageInfo_ImageIsSimulated = (1 << 5)
4278 void CGObjCCommonMac::EmitImageInfo() {
4279 unsigned version = 0; // Version is unused?
4280 const char *Section = (ObjCABI == 1) ?
4281 "__OBJC, __image_info,regular" :
4282 "__DATA, __objc_imageinfo, regular, no_dead_strip";
4284 // Generate module-level named metadata to convey this information to the
4285 // linker and code-gen.
4286 llvm::Module &Mod = CGM.getModule();
4288 // Add the ObjC ABI version to the module flags.
4289 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
4290 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
4292 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
4293 llvm::MDString::get(VMContext,Section));
4295 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
4296 // Non-GC overrides those files which specify GC.
4297 Mod.addModuleFlag(llvm::Module::Override,
4298 "Objective-C Garbage Collection", (uint32_t)0);
4300 // Add the ObjC garbage collection value.
4301 Mod.addModuleFlag(llvm::Module::Error,
4302 "Objective-C Garbage Collection",
4303 eImageInfo_GarbageCollected);
4305 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
4306 // Add the ObjC GC Only value.
4307 Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
4310 // Require that GC be specified and set to eImageInfo_GarbageCollected.
4311 llvm::Value *Ops[2] = {
4312 llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
4313 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
4314 eImageInfo_GarbageCollected)
4316 Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
4317 llvm::MDNode::get(VMContext, Ops));
4321 // Indicate whether we're compiling this to run on a simulator.
4322 const llvm::Triple &Triple = CGM.getTarget().getTriple();
4323 if (Triple.isiOS() &&
4324 (Triple.getArch() == llvm::Triple::x86 ||
4325 Triple.getArch() == llvm::Triple::x86_64))
4326 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
4327 eImageInfo_ImageIsSimulated);
4330 // struct objc_module {
4331 // unsigned long version;
4332 // unsigned long size;
4333 // const char *name;
4337 // FIXME: Get from somewhere
4338 static const int ModuleVersion = 7;
4340 void CGObjCMac::EmitModuleInfo() {
4341 uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
4343 llvm::Constant *Values[] = {
4344 llvm::ConstantInt::get(ObjCTypes.LongTy, ModuleVersion),
4345 llvm::ConstantInt::get(ObjCTypes.LongTy, Size),
4346 // This used to be the filename, now it is unused. <rdr://4327263>
4347 GetClassName(StringRef("")),
4350 CreateMetadataVar("\01L_OBJC_MODULES",
4351 llvm::ConstantStruct::get(ObjCTypes.ModuleTy, Values),
4352 "__OBJC,__module_info,regular,no_dead_strip",
4356 llvm::Constant *CGObjCMac::EmitModuleSymbols() {
4357 unsigned NumClasses = DefinedClasses.size();
4358 unsigned NumCategories = DefinedCategories.size();
4360 // Return null if no symbols were defined.
4361 if (!NumClasses && !NumCategories)
4362 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
4364 llvm::Constant *Values[5];
4365 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
4366 Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy);
4367 Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses);
4368 Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories);
4370 // The runtime expects exactly the list of defined classes followed
4371 // by the list of defined categories, in a single array.
4372 SmallVector<llvm::Constant*, 8> Symbols(NumClasses + NumCategories);
4373 for (unsigned i=0; i<NumClasses; i++) {
4374 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
4376 if (ObjCImplementationDecl *IMP = ID->getImplementation())
4377 // We are implementing a weak imported interface. Give it external linkage
4378 if (ID->isWeakImported() && !IMP->isWeakImported())
4379 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
4381 Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i],
4382 ObjCTypes.Int8PtrTy);
4384 for (unsigned i=0; i<NumCategories; i++)
4385 Symbols[NumClasses + i] =
4386 llvm::ConstantExpr::getBitCast(DefinedCategories[i],
4387 ObjCTypes.Int8PtrTy);
4390 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
4394 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
4396 llvm::GlobalVariable *GV =
4397 CreateMetadataVar("\01L_OBJC_SYMBOLS", Init,
4398 "__OBJC,__symbols,regular,no_dead_strip",
4400 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
4403 llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
4404 IdentifierInfo *II) {
4405 LazySymbols.insert(II);
4407 llvm::GlobalVariable *&Entry = ClassReferences[II];
4410 llvm::Constant *Casted =
4411 llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
4412 ObjCTypes.ClassPtrTy);
4414 CreateMetadataVar("\01L_OBJC_CLASS_REFERENCES_", Casted,
4415 "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
4419 return CGF.Builder.CreateLoad(Entry);
4422 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
4423 const ObjCInterfaceDecl *ID) {
4424 return EmitClassRefFromId(CGF, ID->getIdentifier());
4427 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
4428 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
4429 return EmitClassRefFromId(CGF, II);
4432 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel,
4434 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
4437 llvm::Constant *Casted =
4438 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
4439 ObjCTypes.SelectorPtrTy);
4441 CreateMetadataVar("\01L_OBJC_SELECTOR_REFERENCES_", Casted,
4442 "__OBJC,__message_refs,literal_pointers,no_dead_strip",
4444 Entry->setExternallyInitialized(true);
4449 return CGF.Builder.CreateLoad(Entry);
4452 llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
4453 llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
4455 Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
4456 llvm::ConstantDataArray::getString(VMContext,
4459 "__TEXT,__objc_classname,cstring_literals" :
4460 "__TEXT,__cstring,cstring_literals"),
4462 return getConstantGEP(VMContext, Entry, 0, 0);
4465 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
4466 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
4467 I = MethodDefinitions.find(MD);
4468 if (I != MethodDefinitions.end())
4474 /// GetIvarLayoutName - Returns a unique constant for the given
4475 /// ivar layout bitmap.
4476 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
4477 const ObjCCommonTypesHelper &ObjCTypes) {
4478 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
4481 void CGObjCCommonMac::BuildAggrIvarRecordLayout(const RecordType *RT,
4482 unsigned int BytePos,
4483 bool ForStrongLayout,
4485 const RecordDecl *RD = RT->getDecl();
4486 // FIXME - Use iterator.
4487 SmallVector<const FieldDecl*, 16> Fields(RD->fields());
4488 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
4489 const llvm::StructLayout *RecLayout =
4490 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
4492 BuildAggrIvarLayout(nullptr, RecLayout, RD, Fields, BytePos, ForStrongLayout,
4496 void CGObjCCommonMac::BuildAggrIvarLayout(const ObjCImplementationDecl *OI,
4497 const llvm::StructLayout *Layout,
4498 const RecordDecl *RD,
4499 ArrayRef<const FieldDecl*> RecFields,
4500 unsigned int BytePos, bool ForStrongLayout,
4502 bool IsUnion = (RD && RD->isUnion());
4503 uint64_t MaxUnionIvarSize = 0;
4504 uint64_t MaxSkippedUnionIvarSize = 0;
4505 const FieldDecl *MaxField = nullptr;
4506 const FieldDecl *MaxSkippedField = nullptr;
4507 const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
4508 uint64_t MaxFieldOffset = 0;
4509 uint64_t MaxSkippedFieldOffset = 0;
4510 uint64_t LastBitfieldOrUnnamedOffset = 0;
4511 uint64_t FirstFieldDelta = 0;
4513 if (RecFields.empty())
4515 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
4516 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
4517 if (!RD && CGM.getLangOpts().ObjCAutoRefCount) {
4518 const FieldDecl *FirstField = RecFields[0];
4520 ComputeIvarBaseOffset(CGM, OI, cast<ObjCIvarDecl>(FirstField));
4523 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
4524 const FieldDecl *Field = RecFields[i];
4525 uint64_t FieldOffset;
4527 // Note that 'i' here is actually the field index inside RD of Field,
4528 // although this dependency is hidden.
4529 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
4530 FieldOffset = (RL.getFieldOffset(i) / ByteSizeInBits) - FirstFieldDelta;
4533 ComputeIvarBaseOffset(CGM, OI, cast<ObjCIvarDecl>(Field)) - FirstFieldDelta;
4535 // Skip over unnamed or bitfields
4536 if (!Field->getIdentifier() || Field->isBitField()) {
4537 LastFieldBitfieldOrUnnamed = Field;
4538 LastBitfieldOrUnnamedOffset = FieldOffset;
4542 LastFieldBitfieldOrUnnamed = nullptr;
4543 QualType FQT = Field->getType();
4544 if (FQT->isRecordType() || FQT->isUnionType()) {
4545 if (FQT->isUnionType())
4548 BuildAggrIvarRecordLayout(FQT->getAs<RecordType>(),
4549 BytePos + FieldOffset,
4550 ForStrongLayout, HasUnion);
4554 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
4555 const ConstantArrayType *CArray =
4556 dyn_cast_or_null<ConstantArrayType>(Array);
4557 uint64_t ElCount = CArray->getSize().getZExtValue();
4558 assert(CArray && "only array with known element size is supported");
4559 FQT = CArray->getElementType();
4560 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
4561 const ConstantArrayType *CArray =
4562 dyn_cast_or_null<ConstantArrayType>(Array);
4563 ElCount *= CArray->getSize().getZExtValue();
4564 FQT = CArray->getElementType();
4566 if (FQT->isRecordType() && ElCount) {
4567 int OldIndex = IvarsInfo.size() - 1;
4568 int OldSkIndex = SkipIvars.size() -1;
4570 const RecordType *RT = FQT->getAs<RecordType>();
4571 BuildAggrIvarRecordLayout(RT, BytePos + FieldOffset,
4572 ForStrongLayout, HasUnion);
4574 // Replicate layout information for each array element. Note that
4575 // one element is already done.
4577 for (int FirstIndex = IvarsInfo.size() - 1,
4578 FirstSkIndex = SkipIvars.size() - 1 ;ElIx < ElCount; ElIx++) {
4579 uint64_t Size = CGM.getContext().getTypeSize(RT)/ByteSizeInBits;
4580 for (int i = OldIndex+1; i <= FirstIndex; ++i)
4581 IvarsInfo.push_back(GC_IVAR(IvarsInfo[i].ivar_bytepos + Size*ElIx,
4582 IvarsInfo[i].ivar_size));
4583 for (int i = OldSkIndex+1; i <= FirstSkIndex; ++i)
4584 SkipIvars.push_back(GC_IVAR(SkipIvars[i].ivar_bytepos + Size*ElIx,
4585 SkipIvars[i].ivar_size));
4590 // At this point, we are done with Record/Union and array there of.
4591 // For other arrays we are down to its element type.
4592 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), FQT);
4594 unsigned FieldSize = CGM.getContext().getTypeSize(Field->getType());
4595 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
4596 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
4598 uint64_t UnionIvarSize = FieldSize / WordSizeInBits;
4599 if (UnionIvarSize > MaxUnionIvarSize) {
4600 MaxUnionIvarSize = UnionIvarSize;
4602 MaxFieldOffset = FieldOffset;
4605 IvarsInfo.push_back(GC_IVAR(BytePos + FieldOffset,
4606 FieldSize / WordSizeInBits));
4608 } else if ((ForStrongLayout &&
4609 (GCAttr == Qualifiers::GCNone || GCAttr == Qualifiers::Weak))
4610 || (!ForStrongLayout && GCAttr != Qualifiers::Weak)) {
4612 // FIXME: Why the asymmetry? We divide by word size in bits on other
4614 uint64_t UnionIvarSize = FieldSize / ByteSizeInBits;
4615 if (UnionIvarSize > MaxSkippedUnionIvarSize) {
4616 MaxSkippedUnionIvarSize = UnionIvarSize;
4617 MaxSkippedField = Field;
4618 MaxSkippedFieldOffset = FieldOffset;
4621 // FIXME: Why the asymmetry, we divide by byte size in bits here?
4622 SkipIvars.push_back(GC_IVAR(BytePos + FieldOffset,
4623 FieldSize / ByteSizeInBits));
4628 if (LastFieldBitfieldOrUnnamed) {
4629 if (LastFieldBitfieldOrUnnamed->isBitField()) {
4630 // Last field was a bitfield. Must update skip info.
4631 uint64_t BitFieldSize
4632 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
4634 skivar.ivar_bytepos = BytePos + LastBitfieldOrUnnamedOffset;
4635 skivar.ivar_size = (BitFieldSize / ByteSizeInBits)
4636 + ((BitFieldSize % ByteSizeInBits) != 0);
4637 SkipIvars.push_back(skivar);
4639 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
4640 // Last field was unnamed. Must update skip info.
4642 = CGM.getContext().getTypeSize(LastFieldBitfieldOrUnnamed->getType());
4643 SkipIvars.push_back(GC_IVAR(BytePos + LastBitfieldOrUnnamedOffset,
4644 FieldSize / ByteSizeInBits));
4649 IvarsInfo.push_back(GC_IVAR(BytePos + MaxFieldOffset,
4651 if (MaxSkippedField)
4652 SkipIvars.push_back(GC_IVAR(BytePos + MaxSkippedFieldOffset,
4653 MaxSkippedUnionIvarSize));
4656 /// BuildIvarLayoutBitmap - This routine is the horsework for doing all
4657 /// the computations and returning the layout bitmap (for ivar or blocks) in
4658 /// the given argument BitMap string container. Routine reads
4659 /// two containers, IvarsInfo and SkipIvars which are assumed to be
4660 /// filled already by the caller.
4661 llvm::Constant *CGObjCCommonMac::BuildIvarLayoutBitmap(std::string &BitMap) {
4662 unsigned int WordsToScan, WordsToSkip;
4663 llvm::Type *PtrTy = CGM.Int8PtrTy;
4665 // Build the string of skip/scan nibbles
4666 SmallVector<SKIP_SCAN, 32> SkipScanIvars;
4667 unsigned int WordSize =
4668 CGM.getTypes().getDataLayout().getTypeAllocSize(PtrTy);
4669 if (IvarsInfo[0].ivar_bytepos == 0) {
4671 WordsToScan = IvarsInfo[0].ivar_size;
4673 WordsToSkip = IvarsInfo[0].ivar_bytepos/WordSize;
4674 WordsToScan = IvarsInfo[0].ivar_size;
4676 for (unsigned int i=1, Last=IvarsInfo.size(); i != Last; i++) {
4677 unsigned int TailPrevGCObjC =
4678 IvarsInfo[i-1].ivar_bytepos + IvarsInfo[i-1].ivar_size * WordSize;
4679 if (IvarsInfo[i].ivar_bytepos == TailPrevGCObjC) {
4680 // consecutive 'scanned' object pointers.
4681 WordsToScan += IvarsInfo[i].ivar_size;
4683 // Skip over 'gc'able object pointer which lay over each other.
4684 if (TailPrevGCObjC > IvarsInfo[i].ivar_bytepos)
4686 // Must skip over 1 or more words. We save current skip/scan values
4687 // and start a new pair.
4689 SkScan.skip = WordsToSkip;
4690 SkScan.scan = WordsToScan;
4691 SkipScanIvars.push_back(SkScan);
4694 SkScan.skip = (IvarsInfo[i].ivar_bytepos - TailPrevGCObjC) / WordSize;
4696 SkipScanIvars.push_back(SkScan);
4698 WordsToScan = IvarsInfo[i].ivar_size;
4701 if (WordsToScan > 0) {
4703 SkScan.skip = WordsToSkip;
4704 SkScan.scan = WordsToScan;
4705 SkipScanIvars.push_back(SkScan);
4708 if (!SkipIvars.empty()) {
4709 unsigned int LastIndex = SkipIvars.size()-1;
4710 int LastByteSkipped =
4711 SkipIvars[LastIndex].ivar_bytepos + SkipIvars[LastIndex].ivar_size;
4712 LastIndex = IvarsInfo.size()-1;
4713 int LastByteScanned =
4714 IvarsInfo[LastIndex].ivar_bytepos +
4715 IvarsInfo[LastIndex].ivar_size * WordSize;
4716 // Compute number of bytes to skip at the tail end of the last ivar scanned.
4717 if (LastByteSkipped > LastByteScanned) {
4718 unsigned int TotalWords = (LastByteSkipped + (WordSize -1)) / WordSize;
4720 SkScan.skip = TotalWords - (LastByteScanned/WordSize);
4722 SkipScanIvars.push_back(SkScan);
4725 // Mini optimization of nibbles such that an 0xM0 followed by 0x0N is produced
4727 int SkipScan = SkipScanIvars.size()-1;
4728 for (int i = 0; i <= SkipScan; i++) {
4729 if ((i < SkipScan) && SkipScanIvars[i].skip && SkipScanIvars[i].scan == 0
4730 && SkipScanIvars[i+1].skip == 0 && SkipScanIvars[i+1].scan) {
4731 // 0xM0 followed by 0x0N detected.
4732 SkipScanIvars[i].scan = SkipScanIvars[i+1].scan;
4733 for (int j = i+1; j < SkipScan; j++)
4734 SkipScanIvars[j] = SkipScanIvars[j+1];
4739 // Generate the string.
4740 for (int i = 0; i <= SkipScan; i++) {
4742 unsigned int skip_small = SkipScanIvars[i].skip % 0xf;
4743 unsigned int scan_small = SkipScanIvars[i].scan % 0xf;
4744 unsigned int skip_big = SkipScanIvars[i].skip / 0xf;
4745 unsigned int scan_big = SkipScanIvars[i].scan / 0xf;
4748 for (unsigned int ix = 0; ix < skip_big; ix++)
4749 BitMap += (unsigned char)(0xf0);
4751 // next (skip small, scan)
4753 byte = skip_small << 4;
4757 } else if (scan_small) {
4764 for (unsigned int ix = 0; ix < scan_big; ix++)
4765 BitMap += (unsigned char)(0x0f);
4772 // null terminate string.
4773 unsigned char zero = 0;
4776 llvm::GlobalVariable * Entry =
4777 CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
4778 llvm::ConstantDataArray::getString(VMContext, BitMap,false),
4780 "__TEXT,__objc_classname,cstring_literals" :
4781 "__TEXT,__cstring,cstring_literals"),
4783 return getConstantGEP(VMContext, Entry, 0, 0);
4786 /// BuildIvarLayout - Builds ivar layout bitmap for the class
4787 /// implementation for the __strong or __weak case.
4788 /// The layout map displays which words in ivar list must be skipped
4789 /// and which must be scanned by GC (see below). String is built of bytes.
4790 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
4791 /// of words to skip and right nibble is count of words to scan. So, each
4792 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is
4793 /// represented by a 0x00 byte which also ends the string.
4794 /// 1. when ForStrongLayout is true, following ivars are scanned:
4797 /// - __strong anything
4799 /// 2. When ForStrongLayout is false, following ivars are scanned:
4800 /// - __weak anything
4802 llvm::Constant *CGObjCCommonMac::BuildIvarLayout(
4803 const ObjCImplementationDecl *OMD,
4804 bool ForStrongLayout) {
4805 bool hasUnion = false;
4807 llvm::Type *PtrTy = CGM.Int8PtrTy;
4808 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
4809 !CGM.getLangOpts().ObjCAutoRefCount)
4810 return llvm::Constant::getNullValue(PtrTy);
4812 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
4813 SmallVector<const FieldDecl*, 32> RecFields;
4814 if (CGM.getLangOpts().ObjCAutoRefCount) {
4815 for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
4816 IVD; IVD = IVD->getNextIvar())
4817 RecFields.push_back(cast<FieldDecl>(IVD));
4820 SmallVector<const ObjCIvarDecl*, 32> Ivars;
4821 CGM.getContext().DeepCollectObjCIvars(OI, true, Ivars);
4823 // FIXME: This is not ideal; we shouldn't have to do this copy.
4824 RecFields.append(Ivars.begin(), Ivars.end());
4827 if (RecFields.empty())
4828 return llvm::Constant::getNullValue(PtrTy);
4833 BuildAggrIvarLayout(OMD, nullptr, nullptr, RecFields, 0, ForStrongLayout,
4835 if (IvarsInfo.empty())
4836 return llvm::Constant::getNullValue(PtrTy);
4837 // Sort on byte position in case we encounterred a union nested in
4839 if (hasUnion && !IvarsInfo.empty())
4840 std::sort(IvarsInfo.begin(), IvarsInfo.end());
4841 if (hasUnion && !SkipIvars.empty())
4842 std::sort(SkipIvars.begin(), SkipIvars.end());
4845 llvm::Constant *C = BuildIvarLayoutBitmap(BitMap);
4847 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
4848 printf("\n%s ivar layout for class '%s': ",
4849 ForStrongLayout ? "strong" : "weak",
4850 OMD->getClassInterface()->getName().str().c_str());
4851 const unsigned char *s = (const unsigned char*)BitMap.c_str();
4852 for (unsigned i = 0, e = BitMap.size(); i < e; i++)
4854 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
4856 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
4862 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
4863 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
4865 // FIXME: Avoid std::string in "Sel.getAsString()"
4867 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_NAME_",
4868 llvm::ConstantDataArray::getString(VMContext, Sel.getAsString()),
4870 "__TEXT,__objc_methname,cstring_literals" :
4871 "__TEXT,__cstring,cstring_literals"),
4874 return getConstantGEP(VMContext, Entry, 0, 0);
4877 // FIXME: Merge into a single cstring creation function.
4878 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
4879 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
4882 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
4883 std::string TypeStr;
4884 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
4886 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
4889 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_",
4890 llvm::ConstantDataArray::getString(VMContext, TypeStr),
4892 "__TEXT,__objc_methtype,cstring_literals" :
4893 "__TEXT,__cstring,cstring_literals"),
4896 return getConstantGEP(VMContext, Entry, 0, 0);
4899 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
4901 std::string TypeStr;
4902 if (CGM.getContext().getObjCEncodingForMethodDecl(D, TypeStr, Extended))
4905 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
4908 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_",
4909 llvm::ConstantDataArray::getString(VMContext, TypeStr),
4911 "__TEXT,__objc_methtype,cstring_literals" :
4912 "__TEXT,__cstring,cstring_literals"),
4915 return getConstantGEP(VMContext, Entry, 0, 0);
4918 // FIXME: Merge into a single cstring creation function.
4919 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
4920 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
4923 Entry = CreateMetadataVar(
4924 "\01L_OBJC_PROP_NAME_ATTR_",
4925 llvm::ConstantDataArray::getString(VMContext, Ident->getName()),
4926 "__TEXT,__cstring,cstring_literals", 1, true);
4928 return getConstantGEP(VMContext, Entry, 0, 0);
4931 // FIXME: Merge into a single cstring creation function.
4932 // FIXME: This Decl should be more precise.
4934 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
4935 const Decl *Container) {
4936 std::string TypeStr;
4937 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr);
4938 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
4941 void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
4942 const ObjCContainerDecl *CD,
4943 SmallVectorImpl<char> &Name) {
4944 llvm::raw_svector_ostream OS(Name);
4945 assert (CD && "Missing container decl in GetNameForMethod");
4946 OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
4947 << '[' << CD->getName();
4948 if (const ObjCCategoryImplDecl *CID =
4949 dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
4950 OS << '(' << *CID << ')';
4951 OS << ' ' << D->getSelector().getAsString() << ']';
4954 void CGObjCMac::FinishModule() {
4957 // Emit the dummy bodies for any protocols which were referenced but
4959 for (llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*>::iterator
4960 I = Protocols.begin(), e = Protocols.end(); I != e; ++I) {
4961 if (I->second->hasInitializer())
4964 llvm::Constant *Values[5];
4965 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
4966 Values[1] = GetClassName(I->first->getName());
4967 Values[2] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
4968 Values[3] = Values[4] =
4969 llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
4970 assertPrivateName(I->second);
4971 I->second->setInitializer(llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
4973 CGM.addCompilerUsedGlobal(I->second);
4976 // Add assembler directives to add lazy undefined symbol references
4977 // for classes which are referenced but not defined. This is
4978 // important for correct linker interaction.
4980 // FIXME: It would be nice if we had an LLVM construct for this.
4981 if (!LazySymbols.empty() || !DefinedSymbols.empty()) {
4982 SmallString<256> Asm;
4983 Asm += CGM.getModule().getModuleInlineAsm();
4984 if (!Asm.empty() && Asm.back() != '\n')
4987 llvm::raw_svector_ostream OS(Asm);
4988 for (llvm::SetVector<IdentifierInfo*>::iterator I = DefinedSymbols.begin(),
4989 e = DefinedSymbols.end(); I != e; ++I)
4990 OS << "\t.objc_class_name_" << (*I)->getName() << "=0\n"
4991 << "\t.globl .objc_class_name_" << (*I)->getName() << "\n";
4992 for (llvm::SetVector<IdentifierInfo*>::iterator I = LazySymbols.begin(),
4993 e = LazySymbols.end(); I != e; ++I) {
4994 OS << "\t.lazy_reference .objc_class_name_" << (*I)->getName() << "\n";
4997 for (size_t i = 0, e = DefinedCategoryNames.size(); i < e; ++i) {
4998 OS << "\t.objc_category_name_" << DefinedCategoryNames[i] << "=0\n"
4999 << "\t.globl .objc_category_name_" << DefinedCategoryNames[i] << "\n";
5002 CGM.getModule().setModuleInlineAsm(OS.str());
5006 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5007 : CGObjCCommonMac(cgm),
5009 ObjCEmptyCacheVar = ObjCEmptyVtableVar = nullptr;
5015 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5016 : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5018 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5019 ASTContext &Ctx = CGM.getContext();
5021 ShortTy = Types.ConvertType(Ctx.ShortTy);
5022 IntTy = Types.ConvertType(Ctx.IntTy);
5023 LongTy = Types.ConvertType(Ctx.LongTy);
5024 LongLongTy = Types.ConvertType(Ctx.LongLongTy);
5025 Int8PtrTy = CGM.Int8PtrTy;
5026 Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5028 // arm64 targets use "int" ivar offset variables. All others,
5029 // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5030 if (CGM.getTarget().getTriple().getArch() == llvm::Triple::arm64 ||
5031 CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5032 IvarOffsetVarTy = IntTy;
5034 IvarOffsetVarTy = LongTy;
5036 ObjectPtrTy = Types.ConvertType(Ctx.getObjCIdType());
5037 PtrObjectPtrTy = llvm::PointerType::getUnqual(ObjectPtrTy);
5038 SelectorPtrTy = Types.ConvertType(Ctx.getObjCSelType());
5040 // I'm not sure I like this. The implicit coordination is a bit
5041 // gross. We should solve this in a reasonable fashion because this
5042 // is a pretty common task (match some runtime data structure with
5043 // an LLVM data structure).
5045 // FIXME: This is leaked.
5046 // FIXME: Merge with rewriter code?
5048 // struct _objc_super {
5052 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5053 Ctx.getTranslationUnitDecl(),
5054 SourceLocation(), SourceLocation(),
5055 &Ctx.Idents.get("_objc_super"));
5056 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5057 nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5058 false, ICIS_NoInit));
5059 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5060 nullptr, Ctx.getObjCClassType(), nullptr,
5061 nullptr, false, ICIS_NoInit));
5062 RD->completeDefinition();
5064 SuperCTy = Ctx.getTagDeclType(RD);
5065 SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5067 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5068 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5072 // char *attributes;
5074 PropertyTy = llvm::StructType::create("struct._prop_t",
5075 Int8PtrTy, Int8PtrTy, NULL);
5077 // struct _prop_list_t {
5078 // uint32_t entsize; // sizeof(struct _prop_t)
5079 // uint32_t count_of_properties;
5080 // struct _prop_t prop_list[count_of_properties];
5083 llvm::StructType::create("struct._prop_list_t", IntTy, IntTy,
5084 llvm::ArrayType::get(PropertyTy, 0), NULL);
5085 // struct _prop_list_t *
5086 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5088 // struct _objc_method {
5090 // char *method_type;
5093 MethodTy = llvm::StructType::create("struct._objc_method",
5094 SelectorPtrTy, Int8PtrTy, Int8PtrTy,
5097 // struct _objc_cache *
5098 CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5099 CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5103 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5104 : ObjCCommonTypesHelper(cgm) {
5105 // struct _objc_method_description {
5109 MethodDescriptionTy =
5110 llvm::StructType::create("struct._objc_method_description",
5111 SelectorPtrTy, Int8PtrTy, NULL);
5113 // struct _objc_method_description_list {
5115 // struct _objc_method_description[1];
5117 MethodDescriptionListTy =
5118 llvm::StructType::create("struct._objc_method_description_list",
5120 llvm::ArrayType::get(MethodDescriptionTy, 0),NULL);
5122 // struct _objc_method_description_list *
5123 MethodDescriptionListPtrTy =
5124 llvm::PointerType::getUnqual(MethodDescriptionListTy);
5126 // Protocol description structures
5128 // struct _objc_protocol_extension {
5129 // uint32_t size; // sizeof(struct _objc_protocol_extension)
5130 // struct _objc_method_description_list *optional_instance_methods;
5131 // struct _objc_method_description_list *optional_class_methods;
5132 // struct _objc_property_list *instance_properties;
5133 // const char ** extendedMethodTypes;
5135 ProtocolExtensionTy =
5136 llvm::StructType::create("struct._objc_protocol_extension",
5137 IntTy, MethodDescriptionListPtrTy,
5138 MethodDescriptionListPtrTy, PropertyListPtrTy,
5139 Int8PtrPtrTy, NULL);
5141 // struct _objc_protocol_extension *
5142 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5144 // Handle recursive construction of Protocol and ProtocolList types
5147 llvm::StructType::create(VMContext, "struct._objc_protocol");
5150 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5151 ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy),
5153 llvm::ArrayType::get(ProtocolTy, 0),
5156 // struct _objc_protocol {
5157 // struct _objc_protocol_extension *isa;
5158 // char *protocol_name;
5159 // struct _objc_protocol **_objc_protocol_list;
5160 // struct _objc_method_description_list *instance_methods;
5161 // struct _objc_method_description_list *class_methods;
5163 ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5164 llvm::PointerType::getUnqual(ProtocolListTy),
5165 MethodDescriptionListPtrTy,
5166 MethodDescriptionListPtrTy,
5169 // struct _objc_protocol_list *
5170 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5172 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5174 // Class description structures
5176 // struct _objc_ivar {
5181 IvarTy = llvm::StructType::create("struct._objc_ivar",
5182 Int8PtrTy, Int8PtrTy, IntTy, NULL);
5184 // struct _objc_ivar_list *
5186 llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5187 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5189 // struct _objc_method_list *
5191 llvm::StructType::create(VMContext, "struct._objc_method_list");
5192 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5194 // struct _objc_class_extension *
5196 llvm::StructType::create("struct._objc_class_extension",
5197 IntTy, Int8PtrTy, PropertyListPtrTy, NULL);
5198 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5200 ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5202 // struct _objc_class {
5204 // Class super_class;
5208 // long instance_size;
5209 // struct _objc_ivar_list *ivars;
5210 // struct _objc_method_list *methods;
5211 // struct _objc_cache *cache;
5212 // struct _objc_protocol_list *protocols;
5213 // char *ivar_layout;
5214 // struct _objc_class_ext *ext;
5216 ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5217 llvm::PointerType::getUnqual(ClassTy),
5227 ClassExtensionPtrTy,
5230 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5232 // struct _objc_category {
5233 // char *category_name;
5234 // char *class_name;
5235 // struct _objc_method_list *instance_method;
5236 // struct _objc_method_list *class_method;
5237 // uint32_t size; // sizeof(struct _objc_category)
5238 // struct _objc_property_list *instance_properties;// category's @property
5241 llvm::StructType::create("struct._objc_category",
5242 Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5243 MethodListPtrTy, ProtocolListPtrTy,
5244 IntTy, PropertyListPtrTy, NULL);
5246 // Global metadata structures
5248 // struct _objc_symtab {
5249 // long sel_ref_cnt;
5251 // short cls_def_cnt;
5252 // short cat_def_cnt;
5253 // char *defs[cls_def_cnt + cat_def_cnt];
5256 llvm::StructType::create("struct._objc_symtab",
5257 LongTy, SelectorPtrTy, ShortTy, ShortTy,
5258 llvm::ArrayType::get(Int8PtrTy, 0), NULL);
5259 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
5261 // struct _objc_module {
5263 // long size; // sizeof(struct _objc_module)
5265 // struct _objc_symtab* symtab;
5268 llvm::StructType::create("struct._objc_module",
5269 LongTy, LongTy, Int8PtrTy, SymtabPtrTy, NULL);
5272 // FIXME: This is the size of the setjmp buffer and should be target
5273 // specific. 18 is what's used on 32-bit X86.
5274 uint64_t SetJmpBufferSize = 18;
5277 llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
5280 llvm::StructType::create("struct._objc_exception_data",
5281 llvm::ArrayType::get(CGM.Int32Ty,SetJmpBufferSize),
5286 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
5287 : ObjCCommonTypesHelper(cgm) {
5288 // struct _method_list_t {
5289 // uint32_t entsize; // sizeof(struct _objc_method)
5290 // uint32_t method_count;
5291 // struct _objc_method method_list[method_count];
5294 llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
5295 llvm::ArrayType::get(MethodTy, 0), NULL);
5296 // struct method_list_t *
5297 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
5299 // struct _protocol_t {
5301 // const char * const protocol_name;
5302 // const struct _protocol_list_t * protocol_list; // super protocols
5303 // const struct method_list_t * const instance_methods;
5304 // const struct method_list_t * const class_methods;
5305 // const struct method_list_t *optionalInstanceMethods;
5306 // const struct method_list_t *optionalClassMethods;
5307 // const struct _prop_list_t * properties;
5308 // const uint32_t size; // sizeof(struct _protocol_t)
5309 // const uint32_t flags; // = 0
5310 // const char ** extendedMethodTypes;
5313 // Holder for struct _protocol_list_t *
5314 ProtocolListnfABITy =
5315 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5318 llvm::StructType::create("struct._protocol_t", ObjectPtrTy, Int8PtrTy,
5319 llvm::PointerType::getUnqual(ProtocolListnfABITy),
5320 MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5321 MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5322 PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy,
5325 // struct _protocol_t*
5326 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
5328 // struct _protocol_list_t {
5329 // long protocol_count; // Note, this is 32/64 bit
5330 // struct _protocol_t *[protocol_count];
5332 ProtocolListnfABITy->setBody(LongTy,
5333 llvm::ArrayType::get(ProtocolnfABIPtrTy, 0),
5336 // struct _objc_protocol_list*
5337 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
5340 // unsigned [long] int *offset; // pointer to ivar offset location
5343 // uint32_t alignment;
5346 IvarnfABITy = llvm::StructType::create(
5347 "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
5348 Int8PtrTy, Int8PtrTy, IntTy, IntTy, NULL);
5350 // struct _ivar_list_t {
5351 // uint32 entsize; // sizeof(struct _ivar_t)
5353 // struct _iver_t list[count];
5356 llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
5357 llvm::ArrayType::get(IvarnfABITy, 0), NULL);
5359 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
5361 // struct _class_ro_t {
5362 // uint32_t const flags;
5363 // uint32_t const instanceStart;
5364 // uint32_t const instanceSize;
5365 // uint32_t const reserved; // only when building for 64bit targets
5366 // const uint8_t * const ivarLayout;
5367 // const char *const name;
5368 // const struct _method_list_t * const baseMethods;
5369 // const struct _objc_protocol_list *const baseProtocols;
5370 // const struct _ivar_list_t *const ivars;
5371 // const uint8_t * const weakIvarLayout;
5372 // const struct _prop_list_t * const properties;
5375 // FIXME. Add 'reserved' field in 64bit abi mode!
5376 ClassRonfABITy = llvm::StructType::create("struct._class_ro_t",
5377 IntTy, IntTy, IntTy, Int8PtrTy,
5378 Int8PtrTy, MethodListnfABIPtrTy,
5379 ProtocolListnfABIPtrTy,
5381 Int8PtrTy, PropertyListPtrTy, NULL);
5383 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
5384 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
5385 ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
5388 // struct _class_t {
5389 // struct _class_t *isa;
5390 // struct _class_t * const superclass;
5393 // struct class_ro_t *ro;
5396 ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
5397 ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
5398 llvm::PointerType::getUnqual(ClassnfABITy),
5400 llvm::PointerType::getUnqual(ImpnfABITy),
5401 llvm::PointerType::getUnqual(ClassRonfABITy),
5404 // LLVM for struct _class_t *
5405 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
5407 // struct _category_t {
5408 // const char * const name;
5409 // struct _class_t *const cls;
5410 // const struct _method_list_t * const instance_methods;
5411 // const struct _method_list_t * const class_methods;
5412 // const struct _protocol_list_t * const protocols;
5413 // const struct _prop_list_t * const properties;
5415 CategorynfABITy = llvm::StructType::create("struct._category_t",
5416 Int8PtrTy, ClassnfABIPtrTy,
5417 MethodListnfABIPtrTy,
5418 MethodListnfABIPtrTy,
5419 ProtocolListnfABIPtrTy,
5423 // New types for nonfragile abi messaging.
5424 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5425 ASTContext &Ctx = CGM.getContext();
5427 // MessageRefTy - LLVM for:
5428 // struct _message_ref_t {
5433 // First the clang type for struct _message_ref_t
5434 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5435 Ctx.getTranslationUnitDecl(),
5436 SourceLocation(), SourceLocation(),
5437 &Ctx.Idents.get("_message_ref_t"));
5438 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5439 nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
5441 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5442 nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
5443 false, ICIS_NoInit));
5444 RD->completeDefinition();
5446 MessageRefCTy = Ctx.getTagDeclType(RD);
5447 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
5448 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
5450 // MessageRefPtrTy - LLVM for struct _message_ref_t*
5451 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
5453 // SuperMessageRefTy - LLVM for:
5454 // struct _super_message_ref_t {
5455 // SUPER_IMP messenger;
5459 llvm::StructType::create("struct._super_message_ref_t",
5460 ImpnfABITy, SelectorPtrTy, NULL);
5462 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
5463 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
5466 // struct objc_typeinfo {
5467 // const void** vtable; // objc_ehtype_vtable + 2
5468 // const char* name; // c++ typeinfo string
5472 llvm::StructType::create("struct._objc_typeinfo",
5473 llvm::PointerType::getUnqual(Int8PtrTy),
5474 Int8PtrTy, ClassnfABIPtrTy, NULL);
5475 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
5478 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
5479 FinishNonFragileABIModule();
5484 void CGObjCNonFragileABIMac::
5485 AddModuleClassList(ArrayRef<llvm::GlobalValue*> Container,
5486 const char *SymbolName,
5487 const char *SectionName) {
5488 unsigned NumClasses = Container.size();
5493 SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
5494 for (unsigned i=0; i<NumClasses; i++)
5495 Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
5496 ObjCTypes.Int8PtrTy);
5497 llvm::Constant *Init =
5498 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
5502 llvm::GlobalVariable *GV =
5503 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
5504 llvm::GlobalValue::PrivateLinkage,
5507 assertPrivateName(GV);
5508 GV->setAlignment(CGM.getDataLayout().getABITypeAlignment(Init->getType()));
5509 GV->setSection(SectionName);
5510 CGM.addCompilerUsedGlobal(GV);
5513 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
5514 // nonfragile abi has no module definition.
5516 // Build list of all implemented class addresses in array
5517 // L_OBJC_LABEL_CLASS_$.
5519 for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
5520 const ObjCInterfaceDecl *ID = ImplementedClasses[i];
5522 if (ObjCImplementationDecl *IMP = ID->getImplementation())
5523 // We are implementing a weak imported interface. Give it external linkage
5524 if (ID->isWeakImported() && !IMP->isWeakImported()) {
5525 DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5526 DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5530 AddModuleClassList(DefinedClasses,
5531 "\01L_OBJC_LABEL_CLASS_$",
5532 "__DATA, __objc_classlist, regular, no_dead_strip");
5534 AddModuleClassList(DefinedNonLazyClasses,
5535 "\01L_OBJC_LABEL_NONLAZY_CLASS_$",
5536 "__DATA, __objc_nlclslist, regular, no_dead_strip");
5538 // Build list of all implemented category addresses in array
5539 // L_OBJC_LABEL_CATEGORY_$.
5540 AddModuleClassList(DefinedCategories,
5541 "\01L_OBJC_LABEL_CATEGORY_$",
5542 "__DATA, __objc_catlist, regular, no_dead_strip");
5543 AddModuleClassList(DefinedNonLazyCategories,
5544 "\01L_OBJC_LABEL_NONLAZY_CATEGORY_$",
5545 "__DATA, __objc_nlcatlist, regular, no_dead_strip");
5550 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of
5551 /// VTableDispatchMethods; false otherwise. What this means is that
5552 /// except for the 19 selectors in the list, we generate 32bit-style
5553 /// message dispatch call for all the rest.
5554 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
5555 // At various points we've experimented with using vtable-based
5556 // dispatch for all methods.
5557 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
5558 case CodeGenOptions::Legacy:
5560 case CodeGenOptions::NonLegacy:
5562 case CodeGenOptions::Mixed:
5566 // If so, see whether this selector is in the white-list of things which must
5567 // use the new dispatch convention. We lazily build a dense set for this.
5568 if (VTableDispatchMethods.empty()) {
5569 VTableDispatchMethods.insert(GetNullarySelector("alloc"));
5570 VTableDispatchMethods.insert(GetNullarySelector("class"));
5571 VTableDispatchMethods.insert(GetNullarySelector("self"));
5572 VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
5573 VTableDispatchMethods.insert(GetNullarySelector("length"));
5574 VTableDispatchMethods.insert(GetNullarySelector("count"));
5576 // These are vtable-based if GC is disabled.
5577 // Optimistically use vtable dispatch for hybrid compiles.
5578 if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
5579 VTableDispatchMethods.insert(GetNullarySelector("retain"));
5580 VTableDispatchMethods.insert(GetNullarySelector("release"));
5581 VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
5584 VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
5585 VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
5586 VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
5587 VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
5588 VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
5589 VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
5590 VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
5592 // These are vtable-based if GC is enabled.
5593 // Optimistically use vtable dispatch for hybrid compiles.
5594 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5595 VTableDispatchMethods.insert(GetNullarySelector("hash"));
5596 VTableDispatchMethods.insert(GetUnarySelector("addObject"));
5598 // "countByEnumeratingWithState:objects:count"
5599 IdentifierInfo *KeyIdents[] = {
5600 &CGM.getContext().Idents.get("countByEnumeratingWithState"),
5601 &CGM.getContext().Idents.get("objects"),
5602 &CGM.getContext().Idents.get("count")
5604 VTableDispatchMethods.insert(
5605 CGM.getContext().Selectors.getSelector(3, KeyIdents));
5609 return VTableDispatchMethods.count(Sel);
5612 /// BuildClassRoTInitializer - generate meta-data for:
5613 /// struct _class_ro_t {
5614 /// uint32_t const flags;
5615 /// uint32_t const instanceStart;
5616 /// uint32_t const instanceSize;
5617 /// uint32_t const reserved; // only when building for 64bit targets
5618 /// const uint8_t * const ivarLayout;
5619 /// const char *const name;
5620 /// const struct _method_list_t * const baseMethods;
5621 /// const struct _protocol_list_t *const baseProtocols;
5622 /// const struct _ivar_list_t *const ivars;
5623 /// const uint8_t * const weakIvarLayout;
5624 /// const struct _prop_list_t * const properties;
5627 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
5629 unsigned InstanceStart,
5630 unsigned InstanceSize,
5631 const ObjCImplementationDecl *ID) {
5632 std::string ClassName = ID->getObjCRuntimeNameAsString();
5633 llvm::Constant *Values[10]; // 11 for 64bit targets!
5635 if (CGM.getLangOpts().ObjCAutoRefCount)
5636 flags |= NonFragileABI_Class_CompiledByARC;
5638 Values[ 0] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags);
5639 Values[ 1] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceStart);
5640 Values[ 2] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceSize);
5641 // FIXME. For 64bit targets add 0 here.
5642 Values[ 3] = (flags & NonFragileABI_Class_Meta)
5643 ? GetIvarLayoutName(nullptr, ObjCTypes)
5644 : BuildIvarLayout(ID, true);
5645 Values[ 4] = GetClassName(ID->getObjCRuntimeNameAsString());
5646 // const struct _method_list_t * const baseMethods;
5647 std::vector<llvm::Constant*> Methods;
5648 std::string MethodListName("\01l_OBJC_$_");
5649 if (flags & NonFragileABI_Class_Meta) {
5650 MethodListName += "CLASS_METHODS_";
5651 MethodListName += ID->getObjCRuntimeNameAsString();
5652 for (const auto *I : ID->class_methods())
5653 // Class methods should always be defined.
5654 Methods.push_back(GetMethodConstant(I));
5656 MethodListName += "INSTANCE_METHODS_";
5657 MethodListName += ID->getObjCRuntimeNameAsString();
5658 for (const auto *I : ID->instance_methods())
5659 // Instance methods should always be defined.
5660 Methods.push_back(GetMethodConstant(I));
5662 for (const auto *PID : ID->property_impls()) {
5663 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
5664 ObjCPropertyDecl *PD = PID->getPropertyDecl();
5666 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
5667 if (llvm::Constant *C = GetMethodConstant(MD))
5668 Methods.push_back(C);
5669 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
5670 if (llvm::Constant *C = GetMethodConstant(MD))
5671 Methods.push_back(C);
5675 Values[ 5] = EmitMethodList(MethodListName,
5676 "__DATA, __objc_const", Methods);
5678 const ObjCInterfaceDecl *OID = ID->getClassInterface();
5679 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
5680 Values[ 6] = EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_"
5681 + OID->getObjCRuntimeNameAsString(),
5682 OID->all_referenced_protocol_begin(),
5683 OID->all_referenced_protocol_end());
5685 if (flags & NonFragileABI_Class_Meta) {
5686 Values[ 7] = llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
5687 Values[ 8] = GetIvarLayoutName(nullptr, ObjCTypes);
5688 Values[ 9] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
5690 Values[ 7] = EmitIvarList(ID);
5691 Values[ 8] = BuildIvarLayout(ID, false);
5692 Values[ 9] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
5693 ID, ID->getClassInterface(), ObjCTypes);
5695 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassRonfABITy,
5697 llvm::GlobalVariable *CLASS_RO_GV =
5698 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassRonfABITy, false,
5699 llvm::GlobalValue::PrivateLinkage,
5701 (flags & NonFragileABI_Class_Meta) ?
5702 std::string("\01l_OBJC_METACLASS_RO_$_")+ClassName :
5703 std::string("\01l_OBJC_CLASS_RO_$_")+ClassName);
5704 assertPrivateName(CLASS_RO_GV);
5705 CLASS_RO_GV->setAlignment(
5706 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassRonfABITy));
5707 CLASS_RO_GV->setSection("__DATA, __objc_const");
5712 /// BuildClassMetaData - This routine defines that to-level meta-data
5713 /// for the given ClassName for:
5714 /// struct _class_t {
5715 /// struct _class_t *isa;
5716 /// struct _class_t * const superclass;
5719 /// struct class_ro_t *ro;
5722 llvm::GlobalVariable *CGObjCNonFragileABIMac::BuildClassMetaData(
5723 const std::string &ClassName, llvm::Constant *IsAGV, llvm::Constant *SuperClassGV,
5724 llvm::Constant *ClassRoGV, bool HiddenVisibility, bool Weak) {
5725 llvm::Constant *Values[] = {
5728 ObjCEmptyCacheVar, // &ObjCEmptyCacheVar
5729 ObjCEmptyVtableVar, // &ObjCEmptyVtableVar
5730 ClassRoGV // &CLASS_RO_GV
5733 Values[1] = llvm::Constant::getNullValue(ObjCTypes.ClassnfABIPtrTy);
5735 Values[3] = llvm::Constant::getNullValue(
5736 llvm::PointerType::getUnqual(ObjCTypes.ImpnfABITy));
5737 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassnfABITy,
5739 llvm::GlobalVariable *GV = GetClassGlobal(ClassName, Weak);
5740 GV->setInitializer(Init);
5741 GV->setSection("__DATA, __objc_data");
5743 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy));
5744 if (HiddenVisibility)
5745 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
5750 CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
5751 return OD->getClassMethod(GetNullarySelector("load")) != nullptr;
5754 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
5755 uint32_t &InstanceStart,
5756 uint32_t &InstanceSize) {
5757 const ASTRecordLayout &RL =
5758 CGM.getContext().getASTObjCImplementationLayout(OID);
5760 // InstanceSize is really instance end.
5761 InstanceSize = RL.getDataSize().getQuantity();
5763 // If there are no fields, the start is the same as the end.
5764 if (!RL.getFieldCount())
5765 InstanceStart = InstanceSize;
5767 InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
5770 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
5771 std::string ClassName = ID->getObjCRuntimeNameAsString();
5772 if (!ObjCEmptyCacheVar) {
5773 ObjCEmptyCacheVar = new llvm::GlobalVariable(
5777 llvm::GlobalValue::ExternalLinkage,
5779 "_objc_empty_cache");
5781 // Make this entry NULL for any iOS device target, any iOS simulator target,
5782 // OS X with deployment target 10.9 or later.
5783 const llvm::Triple &Triple = CGM.getTarget().getTriple();
5784 if (Triple.isiOS() || (Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 9)))
5785 // This entry will be null.
5786 ObjCEmptyVtableVar = nullptr;
5788 ObjCEmptyVtableVar = new llvm::GlobalVariable(
5790 ObjCTypes.ImpnfABITy,
5792 llvm::GlobalValue::ExternalLinkage,
5794 "_objc_empty_vtable");
5796 assert(ID->getClassInterface() &&
5797 "CGObjCNonFragileABIMac::GenerateClass - class is 0");
5798 // FIXME: Is this correct (that meta class size is never computed)?
5799 uint32_t InstanceStart =
5800 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
5801 uint32_t InstanceSize = InstanceStart;
5802 uint32_t flags = NonFragileABI_Class_Meta;
5803 llvm::SmallString<64> ObjCMetaClassName(getMetaclassSymbolPrefix());
5804 llvm::SmallString<64> ObjCClassName(getClassSymbolPrefix());
5805 llvm::SmallString<64> TClassName;
5807 llvm::GlobalVariable *SuperClassGV, *IsAGV;
5809 // Build the flags for the metaclass.
5810 bool classIsHidden =
5811 ID->getClassInterface()->getVisibility() == HiddenVisibility;
5813 flags |= NonFragileABI_Class_Hidden;
5815 // FIXME: why is this flag set on the metaclass?
5816 // ObjC metaclasses have no fields and don't really get constructed.
5817 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
5818 flags |= NonFragileABI_Class_HasCXXStructors;
5819 if (!ID->hasNonZeroConstructors())
5820 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
5823 if (!ID->getClassInterface()->getSuperClass()) {
5825 flags |= NonFragileABI_Class_Root;
5826 TClassName = ObjCClassName;
5827 TClassName += ClassName;
5828 SuperClassGV = GetClassGlobal(TClassName.str(),
5829 ID->getClassInterface()->isWeakImported());
5830 TClassName = ObjCMetaClassName;
5831 TClassName += ClassName;
5832 IsAGV = GetClassGlobal(TClassName.str(),
5833 ID->getClassInterface()->isWeakImported());
5835 // Has a root. Current class is not a root.
5836 const ObjCInterfaceDecl *Root = ID->getClassInterface();
5837 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
5839 TClassName = ObjCMetaClassName ;
5840 TClassName += Root->getObjCRuntimeNameAsString();
5841 IsAGV = GetClassGlobal(TClassName.str(),
5842 Root->isWeakImported());
5844 // work on super class metadata symbol.
5845 TClassName = ObjCMetaClassName;
5846 TClassName += ID->getClassInterface()->getSuperClass()->getObjCRuntimeNameAsString();
5847 SuperClassGV = GetClassGlobal(
5849 ID->getClassInterface()->getSuperClass()->isWeakImported());
5851 llvm::GlobalVariable *CLASS_RO_GV = BuildClassRoTInitializer(flags,
5854 TClassName = ObjCMetaClassName;
5855 TClassName += ClassName;
5856 llvm::GlobalVariable *MetaTClass = BuildClassMetaData(
5857 TClassName.str(), IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden,
5858 ID->getClassInterface()->isWeakImported());
5859 DefinedMetaClasses.push_back(MetaTClass);
5861 // Metadata for the class
5864 flags |= NonFragileABI_Class_Hidden;
5866 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
5867 flags |= NonFragileABI_Class_HasCXXStructors;
5869 // Set a flag to enable a runtime optimization when a class has
5870 // fields that require destruction but which don't require
5871 // anything except zero-initialization during construction. This
5872 // is most notably true of __strong and __weak types, but you can
5873 // also imagine there being C++ types with non-trivial default
5874 // constructors that merely set all fields to null.
5875 if (!ID->hasNonZeroConstructors())
5876 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
5879 if (hasObjCExceptionAttribute(CGM.getContext(), ID->getClassInterface()))
5880 flags |= NonFragileABI_Class_Exception;
5882 if (!ID->getClassInterface()->getSuperClass()) {
5883 flags |= NonFragileABI_Class_Root;
5884 SuperClassGV = nullptr;
5886 // Has a root. Current class is not a root.
5887 TClassName = ObjCClassName;
5888 TClassName += ID->getClassInterface()->getSuperClass()->getObjCRuntimeNameAsString();
5889 SuperClassGV = GetClassGlobal(
5891 ID->getClassInterface()->getSuperClass()->isWeakImported());
5893 GetClassSizeInfo(ID, InstanceStart, InstanceSize);
5894 CLASS_RO_GV = BuildClassRoTInitializer(flags,
5899 TClassName = ObjCClassName;
5900 TClassName += ClassName;
5901 llvm::GlobalVariable *ClassMD =
5902 BuildClassMetaData(TClassName.str(), MetaTClass, SuperClassGV, CLASS_RO_GV,
5904 ID->getClassInterface()->isWeakImported());
5905 DefinedClasses.push_back(ClassMD);
5906 ImplementedClasses.push_back(ID->getClassInterface());
5908 // Determine if this class is also "non-lazy".
5909 if (ImplementationIsNonLazy(ID))
5910 DefinedNonLazyClasses.push_back(ClassMD);
5912 // Force the definition of the EHType if necessary.
5913 if (flags & NonFragileABI_Class_Exception)
5914 GetInterfaceEHType(ID->getClassInterface(), true);
5915 // Make sure method definition entries are all clear for next implementation.
5916 MethodDefinitions.clear();
5919 /// GenerateProtocolRef - This routine is called to generate code for
5920 /// a protocol reference expression; as in:
5922 /// @protocol(Proto1);
5924 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
5925 /// which will hold address of the protocol meta-data.
5927 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
5928 const ObjCProtocolDecl *PD) {
5930 // This routine is called for @protocol only. So, we must build definition
5931 // of protocol's meta-data (not a reference to it!)
5933 llvm::Constant *Init =
5934 llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
5935 ObjCTypes.getExternalProtocolPtrTy());
5937 std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_");
5938 ProtocolName += PD->getObjCRuntimeNameAsString();
5940 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
5942 return CGF.Builder.CreateLoad(PTGV);
5943 PTGV = new llvm::GlobalVariable(
5945 Init->getType(), false,
5946 llvm::GlobalValue::WeakAnyLinkage,
5949 PTGV->setSection("__DATA, __objc_protorefs, coalesced, no_dead_strip");
5950 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
5951 CGM.addCompilerUsedGlobal(PTGV);
5952 return CGF.Builder.CreateLoad(PTGV);
5955 /// GenerateCategory - Build metadata for a category implementation.
5956 /// struct _category_t {
5957 /// const char * const name;
5958 /// struct _class_t *const cls;
5959 /// const struct _method_list_t * const instance_methods;
5960 /// const struct _method_list_t * const class_methods;
5961 /// const struct _protocol_list_t * const protocols;
5962 /// const struct _prop_list_t * const properties;
5965 void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
5966 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
5967 const char *Prefix = "\01l_OBJC_$_CATEGORY_";
5969 llvm::SmallString<64> ExtCatName(Prefix);
5970 ExtCatName += Interface->getObjCRuntimeNameAsString();
5971 ExtCatName += "_$_";
5972 ExtCatName += OCD->getNameAsString();
5974 llvm::SmallString<64> ExtClassName(getClassSymbolPrefix());
5975 ExtClassName += Interface->getObjCRuntimeNameAsString();
5977 llvm::Constant *Values[6];
5978 Values[0] = GetClassName(OCD->getIdentifier()->getName());
5979 // meta-class entry symbol
5980 llvm::GlobalVariable *ClassGV =
5981 GetClassGlobal(ExtClassName.str(), Interface->isWeakImported());
5983 Values[1] = ClassGV;
5984 std::vector<llvm::Constant*> Methods;
5985 llvm::SmallString<64> MethodListName(Prefix);
5987 MethodListName += "INSTANCE_METHODS_";
5988 MethodListName += Interface->getObjCRuntimeNameAsString();
5989 MethodListName += "_$_";
5990 MethodListName += OCD->getName();
5992 for (const auto *I : OCD->instance_methods())
5993 // Instance methods should always be defined.
5994 Methods.push_back(GetMethodConstant(I));
5996 Values[2] = EmitMethodList(MethodListName.str(),
5997 "__DATA, __objc_const",
6000 MethodListName = Prefix;
6001 MethodListName += "CLASS_METHODS_";
6002 MethodListName += Interface->getObjCRuntimeNameAsString();
6003 MethodListName += "_$_";
6004 MethodListName += OCD->getNameAsString();
6007 for (const auto *I : OCD->class_methods())
6008 // Class methods should always be defined.
6009 Methods.push_back(GetMethodConstant(I));
6011 Values[3] = EmitMethodList(MethodListName.str(),
6012 "__DATA, __objc_const",
6014 const ObjCCategoryDecl *Category =
6015 Interface->FindCategoryDeclaration(OCD->getIdentifier());
6017 SmallString<256> ExtName;
6018 llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
6020 Values[4] = EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_"
6021 + Interface->getObjCRuntimeNameAsString() + "_$_"
6022 + Category->getName(),
6023 Category->protocol_begin(),
6024 Category->protocol_end());
6025 Values[5] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
6026 OCD, Category, ObjCTypes);
6028 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
6029 Values[5] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
6032 llvm::Constant *Init =
6033 llvm::ConstantStruct::get(ObjCTypes.CategorynfABITy,
6035 llvm::GlobalVariable *GCATV
6036 = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CategorynfABITy,
6038 llvm::GlobalValue::PrivateLinkage,
6041 assertPrivateName(GCATV);
6042 GCATV->setAlignment(
6043 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.CategorynfABITy));
6044 GCATV->setSection("__DATA, __objc_const");
6045 CGM.addCompilerUsedGlobal(GCATV);
6046 DefinedCategories.push_back(GCATV);
6048 // Determine if this category is also "non-lazy".
6049 if (ImplementationIsNonLazy(OCD))
6050 DefinedNonLazyCategories.push_back(GCATV);
6051 // method definition entries must be clear for next implementation.
6052 MethodDefinitions.clear();
6055 /// GetMethodConstant - Return a struct objc_method constant for the
6056 /// given method if it has been defined. The result is null if the
6057 /// method has not been defined. The return value has type MethodPtrTy.
6058 llvm::Constant *CGObjCNonFragileABIMac::GetMethodConstant(
6059 const ObjCMethodDecl *MD) {
6060 llvm::Function *Fn = GetMethodDefinition(MD);
6064 llvm::Constant *Method[] = {
6065 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
6066 ObjCTypes.SelectorPtrTy),
6067 GetMethodVarType(MD),
6068 llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy)
6070 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
6073 /// EmitMethodList - Build meta-data for method declarations
6074 /// struct _method_list_t {
6075 /// uint32_t entsize; // sizeof(struct _objc_method)
6076 /// uint32_t method_count;
6077 /// struct _objc_method method_list[method_count];
6081 CGObjCNonFragileABIMac::EmitMethodList(Twine Name,
6082 const char *Section,
6083 ArrayRef<llvm::Constant*> Methods) {
6084 // Return null for empty list.
6085 if (Methods.empty())
6086 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
6088 llvm::Constant *Values[3];
6089 // sizeof(struct _objc_method)
6090 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
6091 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
6093 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
6094 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
6096 Values[2] = llvm::ConstantArray::get(AT, Methods);
6097 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
6099 llvm::GlobalVariable *GV =
6100 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6101 llvm::GlobalValue::PrivateLinkage, Init, Name);
6102 assertPrivateName(GV);
6103 GV->setAlignment(CGM.getDataLayout().getABITypeAlignment(Init->getType()));
6104 GV->setSection(Section);
6105 CGM.addCompilerUsedGlobal(GV);
6106 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6109 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6111 llvm::GlobalVariable *
6112 CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
6113 const ObjCIvarDecl *Ivar) {
6115 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
6116 llvm::SmallString<64> Name("OBJC_IVAR_$_");
6117 Name += Container->getObjCRuntimeNameAsString();
6119 Name += Ivar->getName();
6120 llvm::GlobalVariable *IvarOffsetGV =
6121 CGM.getModule().getGlobalVariable(Name);
6123 IvarOffsetGV = new llvm::GlobalVariable(
6124 CGM.getModule(), ObjCTypes.IvarOffsetVarTy, false,
6125 llvm::GlobalValue::ExternalLinkage, nullptr, Name.str());
6126 return IvarOffsetGV;
6130 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
6131 const ObjCIvarDecl *Ivar,
6132 unsigned long int Offset) {
6133 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
6134 IvarOffsetGV->setInitializer(
6135 llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
6136 IvarOffsetGV->setAlignment(
6137 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy));
6139 // FIXME: This matches gcc, but shouldn't the visibility be set on the use as
6140 // well (i.e., in ObjCIvarOffsetVariable).
6141 if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6142 Ivar->getAccessControl() == ObjCIvarDecl::Package ||
6143 ID->getVisibility() == HiddenVisibility)
6144 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6146 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
6147 IvarOffsetGV->setSection("__DATA, __objc_ivar");
6148 return IvarOffsetGV;
6151 /// EmitIvarList - Emit the ivar list for the given
6152 /// implementation. The return value has type
6153 /// IvarListnfABIPtrTy.
6154 /// struct _ivar_t {
6155 /// unsigned [long] int *offset; // pointer to ivar offset location
6158 /// uint32_t alignment;
6161 /// struct _ivar_list_t {
6162 /// uint32 entsize; // sizeof(struct _ivar_t)
6164 /// struct _iver_t list[count];
6168 llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
6169 const ObjCImplementationDecl *ID) {
6171 std::vector<llvm::Constant*> Ivars;
6173 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6174 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
6176 // FIXME. Consolidate this with similar code in GenerateClass.
6178 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
6179 IVD; IVD = IVD->getNextIvar()) {
6180 // Ignore unnamed bit-fields.
6181 if (!IVD->getDeclName())
6183 llvm::Constant *Ivar[5];
6184 Ivar[0] = EmitIvarOffsetVar(ID->getClassInterface(), IVD,
6185 ComputeIvarBaseOffset(CGM, ID, IVD));
6186 Ivar[1] = GetMethodVarName(IVD->getIdentifier());
6187 Ivar[2] = GetMethodVarType(IVD);
6188 llvm::Type *FieldTy =
6189 CGM.getTypes().ConvertTypeForMem(IVD->getType());
6190 unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
6191 unsigned Align = CGM.getContext().getPreferredTypeAlign(
6192 IVD->getType().getTypePtr()) >> 3;
6193 Align = llvm::Log2_32(Align);
6194 Ivar[3] = llvm::ConstantInt::get(ObjCTypes.IntTy, Align);
6195 // NOTE. Size of a bitfield does not match gcc's, because of the
6196 // way bitfields are treated special in each. But I am told that
6197 // 'size' for bitfield ivars is ignored by the runtime so it does
6198 // not matter. If it matters, there is enough info to get the
6200 Ivar[4] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
6201 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarnfABITy, Ivar));
6203 // Return null for empty list.
6205 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
6207 llvm::Constant *Values[3];
6208 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy);
6209 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
6210 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
6211 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarnfABITy,
6213 Values[2] = llvm::ConstantArray::get(AT, Ivars);
6214 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
6215 const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_";
6216 llvm::GlobalVariable *GV =
6217 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6218 llvm::GlobalValue::PrivateLinkage,
6220 Prefix + OID->getObjCRuntimeNameAsString());
6221 assertPrivateName(GV);
6223 CGM.getDataLayout().getABITypeAlignment(Init->getType()));
6224 GV->setSection("__DATA, __objc_const");
6226 CGM.addCompilerUsedGlobal(GV);
6227 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
6230 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
6231 const ObjCProtocolDecl *PD) {
6232 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
6235 // We use the initializer as a marker of whether this is a forward
6236 // reference or not. At module finalization we add the empty
6237 // contents for protocols which were referenced but never defined.
6239 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
6240 false, llvm::GlobalValue::WeakAnyLinkage,
6242 "\01l_OBJC_PROTOCOL_$_" + PD->getObjCRuntimeNameAsString());
6243 Entry->setSection("__DATA,__datacoal_nt,coalesced");
6249 /// GetOrEmitProtocol - Generate the protocol meta-data:
6251 /// struct _protocol_t {
6253 /// const char * const protocol_name;
6254 /// const struct _protocol_list_t * protocol_list; // super protocols
6255 /// const struct method_list_t * const instance_methods;
6256 /// const struct method_list_t * const class_methods;
6257 /// const struct method_list_t *optionalInstanceMethods;
6258 /// const struct method_list_t *optionalClassMethods;
6259 /// const struct _prop_list_t * properties;
6260 /// const uint32_t size; // sizeof(struct _protocol_t)
6261 /// const uint32_t flags; // = 0
6262 /// const char ** extendedMethodTypes;
6267 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
6268 const ObjCProtocolDecl *PD) {
6269 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
6271 // Early exit if a defining object has already been generated.
6272 if (Entry && Entry->hasInitializer())
6275 // Use the protocol definition, if there is one.
6276 if (const ObjCProtocolDecl *Def = PD->getDefinition())
6279 // Construct method lists.
6280 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
6281 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
6282 std::vector<llvm::Constant*> MethodTypesExt, OptMethodTypesExt;
6283 for (const auto *MD : PD->instance_methods()) {
6284 llvm::Constant *C = GetMethodDescriptionConstant(MD);
6286 return GetOrEmitProtocolRef(PD);
6288 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
6289 OptInstanceMethods.push_back(C);
6290 OptMethodTypesExt.push_back(GetMethodVarType(MD, true));
6292 InstanceMethods.push_back(C);
6293 MethodTypesExt.push_back(GetMethodVarType(MD, true));
6297 for (const auto *MD : PD->class_methods()) {
6298 llvm::Constant *C = GetMethodDescriptionConstant(MD);
6300 return GetOrEmitProtocolRef(PD);
6302 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
6303 OptClassMethods.push_back(C);
6304 OptMethodTypesExt.push_back(GetMethodVarType(MD, true));
6306 ClassMethods.push_back(C);
6307 MethodTypesExt.push_back(GetMethodVarType(MD, true));
6311 MethodTypesExt.insert(MethodTypesExt.end(),
6312 OptMethodTypesExt.begin(), OptMethodTypesExt.end());
6314 llvm::Constant *Values[11];
6316 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ObjectPtrTy);
6317 Values[1] = GetClassName(PD->getObjCRuntimeNameAsString());
6318 Values[2] = EmitProtocolList("\01l_OBJC_$_PROTOCOL_REFS_" + PD->getObjCRuntimeNameAsString(),
6319 PD->protocol_begin(),
6320 PD->protocol_end());
6322 Values[3] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_"
6323 + PD->getObjCRuntimeNameAsString(),
6324 "__DATA, __objc_const",
6326 Values[4] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_"
6327 + PD->getObjCRuntimeNameAsString(),
6328 "__DATA, __objc_const",
6330 Values[5] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_"
6331 + PD->getObjCRuntimeNameAsString(),
6332 "__DATA, __objc_const",
6333 OptInstanceMethods);
6334 Values[6] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_"
6335 + PD->getObjCRuntimeNameAsString(),
6336 "__DATA, __objc_const",
6338 Values[7] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6339 nullptr, PD, ObjCTypes);
6341 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
6342 Values[8] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
6343 Values[9] = llvm::Constant::getNullValue(ObjCTypes.IntTy);
6344 Values[10] = EmitProtocolMethodTypes("\01l_OBJC_$_PROTOCOL_METHOD_TYPES_"
6345 + PD->getObjCRuntimeNameAsString(),
6346 MethodTypesExt, ObjCTypes);
6347 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolnfABITy,
6351 // Already created, update the initializer.
6352 assert(Entry->hasWeakAnyLinkage());
6353 Entry->setInitializer(Init);
6356 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
6357 false, llvm::GlobalValue::WeakAnyLinkage, Init,
6358 "\01l_OBJC_PROTOCOL_$_" + PD->getObjCRuntimeNameAsString());
6359 Entry->setAlignment(
6360 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABITy));
6361 Entry->setSection("__DATA,__datacoal_nt,coalesced");
6363 Protocols[PD->getIdentifier()] = Entry;
6365 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
6366 CGM.addCompilerUsedGlobal(Entry);
6368 // Use this protocol meta-data to build protocol list table in section
6369 // __DATA, __objc_protolist
6370 llvm::GlobalVariable *PTGV =
6371 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
6372 false, llvm::GlobalValue::WeakAnyLinkage, Entry,
6373 "\01l_OBJC_LABEL_PROTOCOL_$_" + PD->getObjCRuntimeNameAsString());
6375 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy));
6376 PTGV->setSection("__DATA, __objc_protolist, coalesced, no_dead_strip");
6377 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6378 CGM.addCompilerUsedGlobal(PTGV);
6382 /// EmitProtocolList - Generate protocol list meta-data:
6384 /// struct _protocol_list_t {
6385 /// long protocol_count; // Note, this is 32/64 bit
6386 /// struct _protocol_t[protocol_count];
6391 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
6392 ObjCProtocolDecl::protocol_iterator begin,
6393 ObjCProtocolDecl::protocol_iterator end) {
6394 SmallVector<llvm::Constant *, 16> ProtocolRefs;
6396 // Just return null for empty protocol lists
6398 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
6400 // FIXME: We shouldn't need to do this lookup here, should we?
6401 SmallString<256> TmpName;
6402 Name.toVector(TmpName);
6403 llvm::GlobalVariable *GV =
6404 CGM.getModule().getGlobalVariable(TmpName.str(), true);
6406 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
6408 for (; begin != end; ++begin)
6409 ProtocolRefs.push_back(GetProtocolRef(*begin)); // Implemented???
6411 // This list is null terminated.
6412 ProtocolRefs.push_back(llvm::Constant::getNullValue(
6413 ObjCTypes.ProtocolnfABIPtrTy));
6415 llvm::Constant *Values[2];
6417 llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1);
6419 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolnfABIPtrTy,
6420 ProtocolRefs.size()),
6423 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
6424 GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6425 llvm::GlobalValue::PrivateLinkage,
6427 assertPrivateName(GV);
6428 GV->setSection("__DATA, __objc_const");
6430 CGM.getDataLayout().getABITypeAlignment(Init->getType()));
6431 CGM.addCompilerUsedGlobal(GV);
6432 return llvm::ConstantExpr::getBitCast(GV,
6433 ObjCTypes.ProtocolListnfABIPtrTy);
6436 /// GetMethodDescriptionConstant - This routine build following meta-data:
6437 /// struct _objc_method {
6439 /// char *method_type;
6444 CGObjCNonFragileABIMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
6445 llvm::Constant *Desc[3];
6447 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
6448 ObjCTypes.SelectorPtrTy);
6449 Desc[1] = GetMethodVarType(MD);
6453 // Protocol methods have no implementation. So, this entry is always NULL.
6454 Desc[2] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
6455 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Desc);
6458 /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
6459 /// This code gen. amounts to generating code for:
6461 /// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
6464 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
6465 CodeGen::CodeGenFunction &CGF,
6467 llvm::Value *BaseValue,
6468 const ObjCIvarDecl *Ivar,
6469 unsigned CVRQualifiers) {
6470 ObjCInterfaceDecl *ID = ObjectTy->getAs<ObjCObjectType>()->getInterface();
6471 llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
6472 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
6476 llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset(
6477 CodeGen::CodeGenFunction &CGF,
6478 const ObjCInterfaceDecl *Interface,
6479 const ObjCIvarDecl *Ivar) {
6480 llvm::Value *IvarOffsetValue = ObjCIvarOffsetVariable(Interface, Ivar);
6481 IvarOffsetValue = CGF.Builder.CreateLoad(IvarOffsetValue, "ivar");
6482 if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
6483 cast<llvm::LoadInst>(IvarOffsetValue)
6484 ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
6485 llvm::MDNode::get(VMContext, ArrayRef<llvm::Value *>()));
6487 // This could be 32bit int or 64bit integer depending on the architecture.
6488 // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
6489 // as this is what caller always expectes.
6490 if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
6491 IvarOffsetValue = CGF.Builder.CreateIntCast(
6492 IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
6493 return IvarOffsetValue;
6496 static void appendSelectorForMessageRefTable(std::string &buffer,
6497 Selector selector) {
6498 if (selector.isUnarySelector()) {
6499 buffer += selector.getNameForSlot(0);
6503 for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
6504 buffer += selector.getNameForSlot(i);
6509 /// Emit a "v-table" message send. We emit a weak hidden-visibility
6510 /// struct, initially containing the selector pointer and a pointer to
6511 /// a "fixup" variant of the appropriate objc_msgSend. To call, we
6512 /// load and call the function pointer, passing the address of the
6513 /// struct as the second parameter. The runtime determines whether
6514 /// the selector is currently emitted using vtable dispatch; if so, it
6515 /// substitutes a stub function which simply tail-calls through the
6516 /// appropriate vtable slot, and if not, it substitues a stub function
6517 /// which tail-calls objc_msgSend. Both stubs adjust the selector
6518 /// argument to correctly point to the selector.
6520 CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
6521 ReturnValueSlot returnSlot,
6522 QualType resultType,
6527 const CallArgList &formalArgs,
6528 const ObjCMethodDecl *method) {
6529 // Compute the actual arguments.
6532 // First argument: the receiver / super-call structure.
6534 arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
6535 args.add(RValue::get(arg0), arg0Type);
6537 // Second argument: a pointer to the message ref structure. Leave
6538 // the actual argument value blank for now.
6539 args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);
6541 args.insert(args.end(), formalArgs.begin(), formalArgs.end());
6543 MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);
6545 NullReturnState nullReturn;
6547 // Find the function to call and the mangled name for the message
6548 // ref structure. Using a different mangled name wouldn't actually
6549 // be a problem; it would just be a waste.
6551 // The runtime currently never uses vtable dispatch for anything
6552 // except normal, non-super message-sends.
6553 // FIXME: don't use this for that.
6554 llvm::Constant *fn = nullptr;
6555 std::string messageRefName("\01l_");
6556 if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
6558 fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
6559 messageRefName += "objc_msgSendSuper2_stret_fixup";
6561 nullReturn.init(CGF, arg0);
6562 fn = ObjCTypes.getMessageSendStretFixupFn();
6563 messageRefName += "objc_msgSend_stret_fixup";
6565 } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
6566 fn = ObjCTypes.getMessageSendFpretFixupFn();
6567 messageRefName += "objc_msgSend_fpret_fixup";
6570 fn = ObjCTypes.getMessageSendSuper2FixupFn();
6571 messageRefName += "objc_msgSendSuper2_fixup";
6573 fn = ObjCTypes.getMessageSendFixupFn();
6574 messageRefName += "objc_msgSend_fixup";
6577 assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend");
6578 messageRefName += '_';
6580 // Append the selector name, except use underscores anywhere we
6581 // would have used colons.
6582 appendSelectorForMessageRefTable(messageRefName, selector);
6584 llvm::GlobalVariable *messageRef
6585 = CGM.getModule().getGlobalVariable(messageRefName);
6587 // Build the message ref structure.
6588 llvm::Constant *values[] = { fn, GetMethodVarName(selector) };
6589 llvm::Constant *init = llvm::ConstantStruct::getAnon(values);
6590 messageRef = new llvm::GlobalVariable(CGM.getModule(),
6593 llvm::GlobalValue::WeakAnyLinkage,
6596 messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
6597 messageRef->setAlignment(16);
6598 messageRef->setSection("__DATA, __objc_msgrefs, coalesced");
6601 bool requiresnullCheck = false;
6602 if (CGM.getLangOpts().ObjCAutoRefCount && method)
6603 for (const auto *ParamDecl : method->params()) {
6604 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
6605 if (!nullReturn.NullBB)
6606 nullReturn.init(CGF, arg0);
6607 requiresnullCheck = true;
6613 CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy);
6615 // Update the message ref argument.
6616 args[1].RV = RValue::get(mref);
6618 // Load the function to call from the message ref table.
6619 llvm::Value *callee = CGF.Builder.CreateStructGEP(mref, 0);
6620 callee = CGF.Builder.CreateLoad(callee, "msgSend_fn");
6622 callee = CGF.Builder.CreateBitCast(callee, MSI.MessengerType);
6624 RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
6625 return nullReturn.complete(CGF, result, resultType, formalArgs,
6626 requiresnullCheck ? method : nullptr);
6629 /// Generate code for a message send expression in the nonfragile abi.
6631 CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
6632 ReturnValueSlot Return,
6633 QualType ResultType,
6635 llvm::Value *Receiver,
6636 const CallArgList &CallArgs,
6637 const ObjCInterfaceDecl *Class,
6638 const ObjCMethodDecl *Method) {
6639 return isVTableDispatchedSelector(Sel)
6640 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
6641 Receiver, CGF.getContext().getObjCIdType(),
6642 false, CallArgs, Method)
6643 : EmitMessageSend(CGF, Return, ResultType,
6644 EmitSelector(CGF, Sel),
6645 Receiver, CGF.getContext().getObjCIdType(),
6646 false, CallArgs, Method, ObjCTypes);
6649 llvm::GlobalVariable *
6650 CGObjCNonFragileABIMac::GetClassGlobal(const std::string &Name, bool Weak) {
6651 llvm::GlobalValue::LinkageTypes L =
6652 Weak ? llvm::GlobalValue::ExternalWeakLinkage
6653 : llvm::GlobalValue::ExternalLinkage;
6655 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
6658 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
6659 false, L, nullptr, Name);
6661 assert(GV->getLinkage() == L);
6665 llvm::Value *CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
6668 const ObjCInterfaceDecl *ID) {
6669 llvm::GlobalVariable *&Entry = ClassReferences[II];
6672 std::string ClassName(
6673 getClassSymbolPrefix() +
6674 (ID ? ID->getObjCRuntimeNameAsString() : II->getName()).str());
6675 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName, Weak);
6677 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
6678 false, llvm::GlobalValue::PrivateLinkage,
6680 "\01L_OBJC_CLASSLIST_REFERENCES_$_");
6681 Entry->setAlignment(
6682 CGM.getDataLayout().getABITypeAlignment(
6683 ObjCTypes.ClassnfABIPtrTy));
6684 Entry->setSection("__DATA, __objc_classrefs, regular, no_dead_strip");
6685 CGM.addCompilerUsedGlobal(Entry);
6687 assertPrivateName(Entry);
6688 return CGF.Builder.CreateLoad(Entry);
6691 llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
6692 const ObjCInterfaceDecl *ID) {
6693 return EmitClassRefFromId(CGF, ID->getIdentifier(), ID->isWeakImported(), ID);
6696 llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
6697 CodeGenFunction &CGF) {
6698 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
6699 return EmitClassRefFromId(CGF, II, false, 0);
6703 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
6704 const ObjCInterfaceDecl *ID) {
6705 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
6708 llvm::SmallString<64> ClassName(getClassSymbolPrefix());
6709 ClassName += ID->getObjCRuntimeNameAsString();
6710 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName.str(),
6711 ID->isWeakImported());
6713 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
6714 false, llvm::GlobalValue::PrivateLinkage,
6716 "\01L_OBJC_CLASSLIST_SUP_REFS_$_");
6717 Entry->setAlignment(
6718 CGM.getDataLayout().getABITypeAlignment(
6719 ObjCTypes.ClassnfABIPtrTy));
6720 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
6721 CGM.addCompilerUsedGlobal(Entry);
6723 assertPrivateName(Entry);
6724 return CGF.Builder.CreateLoad(Entry);
6727 /// EmitMetaClassRef - Return a Value * of the address of _class_t
6730 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
6731 const ObjCInterfaceDecl *ID,
6733 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
6735 llvm::SmallString<64> MetaClassName(getMetaclassSymbolPrefix());
6736 MetaClassName += ID->getObjCRuntimeNameAsString();
6737 llvm::GlobalVariable *MetaClassGV =
6738 GetClassGlobal(MetaClassName.str(), Weak);
6740 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
6741 false, llvm::GlobalValue::PrivateLinkage,
6743 "\01L_OBJC_CLASSLIST_SUP_REFS_$_");
6744 Entry->setAlignment(
6745 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABIPtrTy));
6747 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
6748 CGM.addCompilerUsedGlobal(Entry);
6751 assertPrivateName(Entry);
6752 return CGF.Builder.CreateLoad(Entry);
6755 /// GetClass - Return a reference to the class for the given interface
6757 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
6758 const ObjCInterfaceDecl *ID) {
6759 if (ID->isWeakImported()) {
6760 llvm::SmallString<64> ClassName(getClassSymbolPrefix());
6761 ClassName += ID->getObjCRuntimeNameAsString();
6762 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName.str(), true);
6764 assert(ClassGV->hasExternalWeakLinkage());
6767 return EmitClassRef(CGF, ID);
6770 /// Generates a message send where the super is the receiver. This is
6771 /// a message send to self with special delivery semantics indicating
6772 /// which class's method should be called.
6774 CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
6775 ReturnValueSlot Return,
6776 QualType ResultType,
6778 const ObjCInterfaceDecl *Class,
6779 bool isCategoryImpl,
6780 llvm::Value *Receiver,
6781 bool IsClassMessage,
6782 const CodeGen::CallArgList &CallArgs,
6783 const ObjCMethodDecl *Method) {
6785 // Create and init a super structure; this is a (receiver, class)
6786 // pair we will pass to objc_msgSendSuper.
6787 llvm::Value *ObjCSuper =
6788 CGF.CreateTempAlloca(ObjCTypes.SuperTy, "objc_super");
6790 llvm::Value *ReceiverAsObject =
6791 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
6792 CGF.Builder.CreateStore(ReceiverAsObject,
6793 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
6795 // If this is a class message the metaclass is passed as the target.
6796 llvm::Value *Target;
6798 Target = EmitMetaClassRef(CGF, Class,
6799 (isCategoryImpl && Class->isWeakImported()));
6801 Target = EmitSuperClassRef(CGF, Class);
6803 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
6805 llvm::Type *ClassTy =
6806 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
6807 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
6808 CGF.Builder.CreateStore(Target,
6809 CGF.Builder.CreateStructGEP(ObjCSuper, 1));
6811 return (isVTableDispatchedSelector(Sel))
6812 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
6813 ObjCSuper, ObjCTypes.SuperPtrCTy,
6814 true, CallArgs, Method)
6815 : EmitMessageSend(CGF, Return, ResultType,
6816 EmitSelector(CGF, Sel),
6817 ObjCSuper, ObjCTypes.SuperPtrCTy,
6818 true, CallArgs, Method, ObjCTypes);
6821 llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
6822 Selector Sel, bool lval) {
6823 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
6826 llvm::Constant *Casted =
6827 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
6828 ObjCTypes.SelectorPtrTy);
6830 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.SelectorPtrTy, false,
6831 llvm::GlobalValue::PrivateLinkage,
6832 Casted, "\01L_OBJC_SELECTOR_REFERENCES_");
6833 Entry->setExternallyInitialized(true);
6834 Entry->setSection("__DATA, __objc_selrefs, literal_pointers, no_dead_strip");
6835 CGM.addCompilerUsedGlobal(Entry);
6837 assertPrivateName(Entry);
6841 llvm::LoadInst* LI = CGF.Builder.CreateLoad(Entry);
6843 LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
6844 llvm::MDNode::get(VMContext,
6845 ArrayRef<llvm::Value*>()));
6848 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
6849 /// objc_assign_ivar (id src, id *dst, ptrdiff_t)
6851 void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
6854 llvm::Value *ivarOffset) {
6855 llvm::Type * SrcTy = src->getType();
6856 if (!isa<llvm::PointerType>(SrcTy)) {
6857 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
6858 assert(Size <= 8 && "does not support size > 8");
6859 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
6860 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
6861 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
6863 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
6864 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
6865 llvm::Value *args[] = { src, dst, ivarOffset };
6866 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
6869 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
6870 /// objc_assign_strongCast (id src, id *dst)
6872 void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
6873 CodeGen::CodeGenFunction &CGF,
6874 llvm::Value *src, llvm::Value *dst) {
6875 llvm::Type * SrcTy = src->getType();
6876 if (!isa<llvm::PointerType>(SrcTy)) {
6877 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
6878 assert(Size <= 8 && "does not support size > 8");
6879 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
6880 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
6881 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
6883 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
6884 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
6885 llvm::Value *args[] = { src, dst };
6886 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
6887 args, "weakassign");
6890 void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
6891 CodeGen::CodeGenFunction &CGF,
6892 llvm::Value *DestPtr,
6893 llvm::Value *SrcPtr,
6894 llvm::Value *Size) {
6895 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
6896 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
6897 llvm::Value *args[] = { DestPtr, SrcPtr, Size };
6898 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
6901 /// EmitObjCWeakRead - Code gen for loading value of a __weak
6902 /// object: objc_read_weak (id *src)
6904 llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
6905 CodeGen::CodeGenFunction &CGF,
6906 llvm::Value *AddrWeakObj) {
6907 llvm::Type* DestTy =
6908 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType();
6909 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
6910 llvm::Value *read_weak =
6911 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
6912 AddrWeakObj, "weakread");
6913 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
6917 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
6918 /// objc_assign_weak (id src, id *dst)
6920 void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
6921 llvm::Value *src, llvm::Value *dst) {
6922 llvm::Type * SrcTy = src->getType();
6923 if (!isa<llvm::PointerType>(SrcTy)) {
6924 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
6925 assert(Size <= 8 && "does not support size > 8");
6926 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
6927 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
6928 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
6930 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
6931 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
6932 llvm::Value *args[] = { src, dst };
6933 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
6934 args, "weakassign");
6937 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
6938 /// objc_assign_global (id src, id *dst)
6940 void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
6941 llvm::Value *src, llvm::Value *dst,
6943 llvm::Type * SrcTy = src->getType();
6944 if (!isa<llvm::PointerType>(SrcTy)) {
6945 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
6946 assert(Size <= 8 && "does not support size > 8");
6947 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
6948 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
6949 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
6951 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
6952 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
6953 llvm::Value *args[] = { src, dst };
6955 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
6956 args, "globalassign");
6958 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
6959 args, "threadlocalassign");
6963 CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
6964 const ObjCAtSynchronizedStmt &S) {
6965 EmitAtSynchronizedStmt(CGF, S,
6966 cast<llvm::Function>(ObjCTypes.getSyncEnterFn()),
6967 cast<llvm::Function>(ObjCTypes.getSyncExitFn()));
6971 CGObjCNonFragileABIMac::GetEHType(QualType T) {
6972 // There's a particular fixed type info for 'id'.
6973 if (T->isObjCIdType() ||
6974 T->isObjCQualifiedIdType()) {
6975 llvm::Constant *IDEHType =
6976 CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
6979 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
6981 llvm::GlobalValue::ExternalLinkage,
6982 nullptr, "OBJC_EHTYPE_id");
6986 // All other types should be Objective-C interface pointer types.
6987 const ObjCObjectPointerType *PT =
6988 T->getAs<ObjCObjectPointerType>();
6989 assert(PT && "Invalid @catch type.");
6990 const ObjCInterfaceType *IT = PT->getInterfaceType();
6991 assert(IT && "Invalid @catch type.");
6992 return GetInterfaceEHType(IT->getDecl(), false);
6995 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
6996 const ObjCAtTryStmt &S) {
6997 EmitTryCatchStmt(CGF, S,
6998 cast<llvm::Function>(ObjCTypes.getObjCBeginCatchFn()),
6999 cast<llvm::Function>(ObjCTypes.getObjCEndCatchFn()),
7000 cast<llvm::Function>(ObjCTypes.getExceptionRethrowFn()));
7003 /// EmitThrowStmt - Generate code for a throw statement.
7004 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
7005 const ObjCAtThrowStmt &S,
7006 bool ClearInsertionPoint) {
7007 if (const Expr *ThrowExpr = S.getThrowExpr()) {
7008 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
7009 Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7010 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception)
7011 .setDoesNotReturn();
7013 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn())
7014 .setDoesNotReturn();
7017 CGF.Builder.CreateUnreachable();
7018 if (ClearInsertionPoint)
7019 CGF.Builder.ClearInsertionPoint();
7023 CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
7024 bool ForDefinition) {
7025 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
7027 // If we don't need a definition, return the entry if found or check
7028 // if we use an external reference.
7029 if (!ForDefinition) {
7033 // If this type (or a super class) has the __objc_exception__
7034 // attribute, emit an external reference.
7035 if (hasObjCExceptionAttribute(CGM.getContext(), ID))
7037 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7038 llvm::GlobalValue::ExternalLinkage,
7041 ID->getObjCRuntimeNameAsString()));
7044 // Otherwise we need to either make a new entry or fill in the
7046 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
7047 llvm::SmallString<64> ClassName(getClassSymbolPrefix());
7048 ClassName += ID->getObjCRuntimeNameAsString();
7049 std::string VTableName = "objc_ehtype_vtable";
7050 llvm::GlobalVariable *VTableGV =
7051 CGM.getModule().getGlobalVariable(VTableName);
7053 VTableGV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy,
7055 llvm::GlobalValue::ExternalLinkage,
7056 nullptr, VTableName);
7058 llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
7060 llvm::Constant *Values[] = {
7061 llvm::ConstantExpr::getGetElementPtr(VTableGV, VTableIdx),
7062 GetClassName(ID->getObjCRuntimeNameAsString()),
7063 GetClassGlobal(ClassName.str())
7065 llvm::Constant *Init =
7066 llvm::ConstantStruct::get(ObjCTypes.EHTypeTy, Values);
7068 llvm::GlobalValue::LinkageTypes L = ForDefinition
7069 ? llvm::GlobalValue::ExternalLinkage
7070 : llvm::GlobalValue::WeakAnyLinkage;
7072 Entry->setInitializer(Init);
7074 llvm::SmallString<64> EHTYPEName("OBJC_EHTYPE_$_");
7075 EHTYPEName += ID->getObjCRuntimeNameAsString();
7076 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7081 assert(Entry->getLinkage() == L);
7083 if (ID->getVisibility() == HiddenVisibility)
7084 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7085 Entry->setAlignment(CGM.getDataLayout().getABITypeAlignment(
7086 ObjCTypes.EHTypeTy));
7089 Entry->setSection("__DATA,__objc_const");
7091 Entry->setSection("__DATA,__datacoal_nt,coalesced");
7098 CodeGen::CGObjCRuntime *
7099 CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
7100 switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
7101 case ObjCRuntime::FragileMacOSX:
7102 return new CGObjCMac(CGM);
7104 case ObjCRuntime::MacOSX:
7105 case ObjCRuntime::iOS:
7106 return new CGObjCNonFragileABIMac(CGM);
7108 case ObjCRuntime::GNUstep:
7109 case ObjCRuntime::GCC:
7110 case ObjCRuntime::ObjFW:
7111 llvm_unreachable("these runtimes are not Mac runtimes");
7113 llvm_unreachable("bad runtime");