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/DataLayout.h"
33 #include "llvm/IR/InlineAsm.h"
34 #include "llvm/IR/IntrinsicInst.h"
35 #include "llvm/IR/LLVMContext.h"
36 #include "llvm/IR/Module.h"
37 #include "llvm/Support/CallSite.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;
178 /// ObjectPtrTy - LLVM type for object handles (typeof(id))
179 llvm::Type *ObjectPtrTy;
181 /// PtrObjectPtrTy - LLVM type for id *
182 llvm::Type *PtrObjectPtrTy;
184 /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
185 llvm::Type *SelectorPtrTy;
188 /// ProtocolPtrTy - LLVM type for external protocol handles
189 /// (typeof(Protocol))
190 llvm::Type *ExternalProtocolPtrTy;
193 llvm::Type *getExternalProtocolPtrTy() {
194 if (!ExternalProtocolPtrTy) {
195 // FIXME: It would be nice to unify this with the opaque type, so that the
196 // IR comes out a bit cleaner.
197 CodeGen::CodeGenTypes &Types = CGM.getTypes();
198 ASTContext &Ctx = CGM.getContext();
199 llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
200 ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
203 return ExternalProtocolPtrTy;
206 // SuperCTy - clang type for struct objc_super.
208 // SuperPtrCTy - clang type for struct objc_super *.
209 QualType SuperPtrCTy;
211 /// SuperTy - LLVM type for struct objc_super.
212 llvm::StructType *SuperTy;
213 /// SuperPtrTy - LLVM type for struct objc_super *.
214 llvm::Type *SuperPtrTy;
216 /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
217 /// in GCC parlance).
218 llvm::StructType *PropertyTy;
220 /// PropertyListTy - LLVM type for struct objc_property_list
221 /// (_prop_list_t in GCC parlance).
222 llvm::StructType *PropertyListTy;
223 /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
224 llvm::Type *PropertyListPtrTy;
226 // MethodTy - LLVM type for struct objc_method.
227 llvm::StructType *MethodTy;
229 /// CacheTy - LLVM type for struct objc_cache.
231 /// CachePtrTy - LLVM type for struct objc_cache *.
232 llvm::Type *CachePtrTy;
234 llvm::Constant *getGetPropertyFn() {
235 CodeGen::CodeGenTypes &Types = CGM.getTypes();
236 ASTContext &Ctx = CGM.getContext();
237 // id objc_getProperty (id, SEL, ptrdiff_t, bool)
238 SmallVector<CanQualType,4> Params;
239 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
240 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
241 Params.push_back(IdType);
242 Params.push_back(SelType);
243 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
244 Params.push_back(Ctx.BoolTy);
245 llvm::FunctionType *FTy =
246 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(IdType, Params,
247 FunctionType::ExtInfo(),
249 return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
252 llvm::Constant *getSetPropertyFn() {
253 CodeGen::CodeGenTypes &Types = CGM.getTypes();
254 ASTContext &Ctx = CGM.getContext();
255 // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
256 SmallVector<CanQualType,6> Params;
257 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
258 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
259 Params.push_back(IdType);
260 Params.push_back(SelType);
261 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
262 Params.push_back(IdType);
263 Params.push_back(Ctx.BoolTy);
264 Params.push_back(Ctx.BoolTy);
265 llvm::FunctionType *FTy =
266 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy, Params,
267 FunctionType::ExtInfo(),
269 return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
272 llvm::Constant *getOptimizedSetPropertyFn(bool atomic, bool copy) {
273 CodeGen::CodeGenTypes &Types = CGM.getTypes();
274 ASTContext &Ctx = CGM.getContext();
275 // void objc_setProperty_atomic(id self, SEL _cmd,
276 // id newValue, ptrdiff_t offset);
277 // void objc_setProperty_nonatomic(id self, SEL _cmd,
278 // id newValue, ptrdiff_t offset);
279 // void objc_setProperty_atomic_copy(id self, SEL _cmd,
280 // id newValue, ptrdiff_t offset);
281 // void objc_setProperty_nonatomic_copy(id self, SEL _cmd,
282 // id newValue, ptrdiff_t offset);
284 SmallVector<CanQualType,4> Params;
285 CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
286 CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
287 Params.push_back(IdType);
288 Params.push_back(SelType);
289 Params.push_back(IdType);
290 Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
291 llvm::FunctionType *FTy =
292 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy, Params,
293 FunctionType::ExtInfo(),
297 name = "objc_setProperty_atomic_copy";
298 else if (atomic && !copy)
299 name = "objc_setProperty_atomic";
300 else if (!atomic && copy)
301 name = "objc_setProperty_nonatomic_copy";
303 name = "objc_setProperty_nonatomic";
305 return CGM.CreateRuntimeFunction(FTy, name);
308 llvm::Constant *getCopyStructFn() {
309 CodeGen::CodeGenTypes &Types = CGM.getTypes();
310 ASTContext &Ctx = CGM.getContext();
311 // void objc_copyStruct (void *, const void *, size_t, bool, bool)
312 SmallVector<CanQualType,5> Params;
313 Params.push_back(Ctx.VoidPtrTy);
314 Params.push_back(Ctx.VoidPtrTy);
315 Params.push_back(Ctx.LongTy);
316 Params.push_back(Ctx.BoolTy);
317 Params.push_back(Ctx.BoolTy);
318 llvm::FunctionType *FTy =
319 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy, Params,
320 FunctionType::ExtInfo(),
322 return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
325 /// This routine declares and returns address of:
326 /// void objc_copyCppObjectAtomic(
327 /// void *dest, const void *src,
328 /// void (*copyHelper) (void *dest, const void *source));
329 llvm::Constant *getCppAtomicObjectFunction() {
330 CodeGen::CodeGenTypes &Types = CGM.getTypes();
331 ASTContext &Ctx = CGM.getContext();
332 /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
333 SmallVector<CanQualType,3> Params;
334 Params.push_back(Ctx.VoidPtrTy);
335 Params.push_back(Ctx.VoidPtrTy);
336 Params.push_back(Ctx.VoidPtrTy);
337 llvm::FunctionType *FTy =
338 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy, Params,
339 FunctionType::ExtInfo(),
341 return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
344 llvm::Constant *getEnumerationMutationFn() {
345 CodeGen::CodeGenTypes &Types = CGM.getTypes();
346 ASTContext &Ctx = CGM.getContext();
347 // void objc_enumerationMutation (id)
348 SmallVector<CanQualType,1> Params;
349 Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
350 llvm::FunctionType *FTy =
351 Types.GetFunctionType(Types.arrangeLLVMFunctionInfo(Ctx.VoidTy, Params,
352 FunctionType::ExtInfo(),
354 return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
357 /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
358 llvm::Constant *getGcReadWeakFn() {
359 // id objc_read_weak (id *)
360 llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
361 llvm::FunctionType *FTy =
362 llvm::FunctionType::get(ObjectPtrTy, args, false);
363 return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
366 /// GcAssignWeakFn -- LLVM objc_assign_weak function.
367 llvm::Constant *getGcAssignWeakFn() {
368 // id objc_assign_weak (id, id *)
369 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
370 llvm::FunctionType *FTy =
371 llvm::FunctionType::get(ObjectPtrTy, args, false);
372 return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
375 /// GcAssignGlobalFn -- LLVM objc_assign_global function.
376 llvm::Constant *getGcAssignGlobalFn() {
377 // id objc_assign_global(id, id *)
378 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
379 llvm::FunctionType *FTy =
380 llvm::FunctionType::get(ObjectPtrTy, args, false);
381 return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
384 /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
385 llvm::Constant *getGcAssignThreadLocalFn() {
386 // id objc_assign_threadlocal(id src, id * dest)
387 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
388 llvm::FunctionType *FTy =
389 llvm::FunctionType::get(ObjectPtrTy, args, false);
390 return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
393 /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
394 llvm::Constant *getGcAssignIvarFn() {
395 // id objc_assign_ivar(id, id *, ptrdiff_t)
396 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
398 llvm::FunctionType *FTy =
399 llvm::FunctionType::get(ObjectPtrTy, args, false);
400 return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
403 /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
404 llvm::Constant *GcMemmoveCollectableFn() {
405 // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
406 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
407 llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
408 return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
411 /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
412 llvm::Constant *getGcAssignStrongCastFn() {
413 // id objc_assign_strongCast(id, id *)
414 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
415 llvm::FunctionType *FTy =
416 llvm::FunctionType::get(ObjectPtrTy, args, false);
417 return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
420 /// ExceptionThrowFn - LLVM objc_exception_throw function.
421 llvm::Constant *getExceptionThrowFn() {
422 // void objc_exception_throw(id)
423 llvm::Type *args[] = { ObjectPtrTy };
424 llvm::FunctionType *FTy =
425 llvm::FunctionType::get(CGM.VoidTy, args, false);
426 return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
429 /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
430 llvm::Constant *getExceptionRethrowFn() {
431 // void objc_exception_rethrow(void)
432 llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
433 return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
436 /// SyncEnterFn - LLVM object_sync_enter function.
437 llvm::Constant *getSyncEnterFn() {
438 // int objc_sync_enter (id)
439 llvm::Type *args[] = { ObjectPtrTy };
440 llvm::FunctionType *FTy =
441 llvm::FunctionType::get(CGM.IntTy, args, false);
442 return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
445 /// SyncExitFn - LLVM object_sync_exit function.
446 llvm::Constant *getSyncExitFn() {
447 // int objc_sync_exit (id)
448 llvm::Type *args[] = { ObjectPtrTy };
449 llvm::FunctionType *FTy =
450 llvm::FunctionType::get(CGM.IntTy, args, false);
451 return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
454 llvm::Constant *getSendFn(bool IsSuper) const {
455 return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
458 llvm::Constant *getSendFn2(bool IsSuper) const {
459 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
462 llvm::Constant *getSendStretFn(bool IsSuper) const {
463 return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
466 llvm::Constant *getSendStretFn2(bool IsSuper) const {
467 return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
470 llvm::Constant *getSendFpretFn(bool IsSuper) const {
471 return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
474 llvm::Constant *getSendFpretFn2(bool IsSuper) const {
475 return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
478 llvm::Constant *getSendFp2retFn(bool IsSuper) const {
479 return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
482 llvm::Constant *getSendFp2RetFn2(bool IsSuper) const {
483 return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn();
486 ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
487 ~ObjCCommonTypesHelper(){}
490 /// ObjCTypesHelper - Helper class that encapsulates lazy
491 /// construction of varies types used during ObjC generation.
492 class ObjCTypesHelper : public ObjCCommonTypesHelper {
494 /// SymtabTy - LLVM type for struct objc_symtab.
495 llvm::StructType *SymtabTy;
496 /// SymtabPtrTy - LLVM type for struct objc_symtab *.
497 llvm::Type *SymtabPtrTy;
498 /// ModuleTy - LLVM type for struct objc_module.
499 llvm::StructType *ModuleTy;
501 /// ProtocolTy - LLVM type for struct objc_protocol.
502 llvm::StructType *ProtocolTy;
503 /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
504 llvm::Type *ProtocolPtrTy;
505 /// ProtocolExtensionTy - LLVM type for struct
506 /// objc_protocol_extension.
507 llvm::StructType *ProtocolExtensionTy;
508 /// ProtocolExtensionTy - LLVM type for struct
509 /// objc_protocol_extension *.
510 llvm::Type *ProtocolExtensionPtrTy;
511 /// MethodDescriptionTy - LLVM type for struct
512 /// objc_method_description.
513 llvm::StructType *MethodDescriptionTy;
514 /// MethodDescriptionListTy - LLVM type for struct
515 /// objc_method_description_list.
516 llvm::StructType *MethodDescriptionListTy;
517 /// MethodDescriptionListPtrTy - LLVM type for struct
518 /// objc_method_description_list *.
519 llvm::Type *MethodDescriptionListPtrTy;
520 /// ProtocolListTy - LLVM type for struct objc_property_list.
521 llvm::StructType *ProtocolListTy;
522 /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
523 llvm::Type *ProtocolListPtrTy;
524 /// CategoryTy - LLVM type for struct objc_category.
525 llvm::StructType *CategoryTy;
526 /// ClassTy - LLVM type for struct objc_class.
527 llvm::StructType *ClassTy;
528 /// ClassPtrTy - LLVM type for struct objc_class *.
529 llvm::Type *ClassPtrTy;
530 /// ClassExtensionTy - LLVM type for struct objc_class_ext.
531 llvm::StructType *ClassExtensionTy;
532 /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
533 llvm::Type *ClassExtensionPtrTy;
534 // IvarTy - LLVM type for struct objc_ivar.
535 llvm::StructType *IvarTy;
536 /// IvarListTy - LLVM type for struct objc_ivar_list.
537 llvm::Type *IvarListTy;
538 /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
539 llvm::Type *IvarListPtrTy;
540 /// MethodListTy - LLVM type for struct objc_method_list.
541 llvm::Type *MethodListTy;
542 /// MethodListPtrTy - LLVM type for struct objc_method_list *.
543 llvm::Type *MethodListPtrTy;
545 /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
546 llvm::Type *ExceptionDataTy;
548 /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
549 llvm::Constant *getExceptionTryEnterFn() {
550 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
551 return CGM.CreateRuntimeFunction(
552 llvm::FunctionType::get(CGM.VoidTy, params, false),
553 "objc_exception_try_enter");
556 /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
557 llvm::Constant *getExceptionTryExitFn() {
558 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
559 return CGM.CreateRuntimeFunction(
560 llvm::FunctionType::get(CGM.VoidTy, params, false),
561 "objc_exception_try_exit");
564 /// ExceptionExtractFn - LLVM objc_exception_extract function.
565 llvm::Constant *getExceptionExtractFn() {
566 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
567 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
569 "objc_exception_extract");
572 /// ExceptionMatchFn - LLVM objc_exception_match function.
573 llvm::Constant *getExceptionMatchFn() {
574 llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
575 return CGM.CreateRuntimeFunction(
576 llvm::FunctionType::get(CGM.Int32Ty, params, false),
577 "objc_exception_match");
581 /// SetJmpFn - LLVM _setjmp function.
582 llvm::Constant *getSetJmpFn() {
583 // This is specifically the prototype for x86.
584 llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
586 CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty,
589 llvm::AttributeSet::get(CGM.getLLVMContext(),
590 llvm::AttributeSet::FunctionIndex,
591 llvm::Attribute::NonLazyBind));
595 ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
596 ~ObjCTypesHelper() {}
599 /// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
601 class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
604 // MethodListnfABITy - LLVM for struct _method_list_t
605 llvm::StructType *MethodListnfABITy;
607 // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
608 llvm::Type *MethodListnfABIPtrTy;
610 // ProtocolnfABITy = LLVM for struct _protocol_t
611 llvm::StructType *ProtocolnfABITy;
613 // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
614 llvm::Type *ProtocolnfABIPtrTy;
616 // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
617 llvm::StructType *ProtocolListnfABITy;
619 // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
620 llvm::Type *ProtocolListnfABIPtrTy;
622 // ClassnfABITy - LLVM for struct _class_t
623 llvm::StructType *ClassnfABITy;
625 // ClassnfABIPtrTy - LLVM for struct _class_t*
626 llvm::Type *ClassnfABIPtrTy;
628 // IvarnfABITy - LLVM for struct _ivar_t
629 llvm::StructType *IvarnfABITy;
631 // IvarListnfABITy - LLVM for struct _ivar_list_t
632 llvm::StructType *IvarListnfABITy;
634 // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
635 llvm::Type *IvarListnfABIPtrTy;
637 // ClassRonfABITy - LLVM for struct _class_ro_t
638 llvm::StructType *ClassRonfABITy;
640 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
641 llvm::Type *ImpnfABITy;
643 // CategorynfABITy - LLVM for struct _category_t
644 llvm::StructType *CategorynfABITy;
646 // New types for nonfragile abi messaging.
648 // MessageRefTy - LLVM for:
649 // struct _message_ref_t {
653 llvm::StructType *MessageRefTy;
654 // MessageRefCTy - clang type for struct _message_ref_t
655 QualType MessageRefCTy;
657 // MessageRefPtrTy - LLVM for struct _message_ref_t*
658 llvm::Type *MessageRefPtrTy;
659 // MessageRefCPtrTy - clang type for struct _message_ref_t*
660 QualType MessageRefCPtrTy;
662 // MessengerTy - Type of the messenger (shown as IMP above)
663 llvm::FunctionType *MessengerTy;
665 // SuperMessageRefTy - LLVM for:
666 // struct _super_message_ref_t {
667 // SUPER_IMP messenger;
670 llvm::StructType *SuperMessageRefTy;
672 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
673 llvm::Type *SuperMessageRefPtrTy;
675 llvm::Constant *getMessageSendFixupFn() {
676 // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
677 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
678 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
680 "objc_msgSend_fixup");
683 llvm::Constant *getMessageSendFpretFixupFn() {
684 // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
685 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
686 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
688 "objc_msgSend_fpret_fixup");
691 llvm::Constant *getMessageSendStretFixupFn() {
692 // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
693 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
694 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
696 "objc_msgSend_stret_fixup");
699 llvm::Constant *getMessageSendSuper2FixupFn() {
700 // id objc_msgSendSuper2_fixup (struct objc_super *,
701 // struct _super_message_ref_t*, ...)
702 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
703 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
705 "objc_msgSendSuper2_fixup");
708 llvm::Constant *getMessageSendSuper2StretFixupFn() {
709 // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
710 // struct _super_message_ref_t*, ...)
711 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
712 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
714 "objc_msgSendSuper2_stret_fixup");
717 llvm::Constant *getObjCEndCatchFn() {
718 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
723 llvm::Constant *getObjCBeginCatchFn() {
724 llvm::Type *params[] = { Int8PtrTy };
725 return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
730 llvm::StructType *EHTypeTy;
731 llvm::Type *EHTypePtrTy;
733 ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
734 ~ObjCNonFragileABITypesHelper(){}
737 class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
739 // FIXME - accessibility
742 unsigned ivar_bytepos;
744 GC_IVAR(unsigned bytepos = 0, unsigned size = 0)
745 : ivar_bytepos(bytepos), ivar_size(size) {}
747 // Allow sorting based on byte pos.
748 bool operator<(const GC_IVAR &b) const {
749 return ivar_bytepos < b.ivar_bytepos;
757 SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
758 : skip(_skip), scan(_scan) {}
761 /// opcode for captured block variables layout 'instructions'.
762 /// In the following descriptions, 'I' is the value of the immediate field.
763 /// (field following the opcode).
765 enum BLOCK_LAYOUT_OPCODE {
766 /// An operator which affects how the following layout should be
768 /// I == 0: Halt interpretation and treat everything else as
769 /// a non-pointer. Note that this instruction is equal
771 /// I != 0: Currently unused.
772 BLOCK_LAYOUT_OPERATOR = 0,
774 /// The next I+1 bytes do not contain a value of object pointer type.
775 /// Note that this can leave the stream unaligned, meaning that
776 /// subsequent word-size instructions do not begin at a multiple of
777 /// the pointer size.
778 BLOCK_LAYOUT_NON_OBJECT_BYTES = 1,
780 /// The next I+1 words do not contain a value of object pointer type.
781 /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
782 /// when the required skip quantity is a multiple of the pointer size.
783 BLOCK_LAYOUT_NON_OBJECT_WORDS = 2,
785 /// The next I+1 words are __strong pointers to Objective-C
786 /// objects or blocks.
787 BLOCK_LAYOUT_STRONG = 3,
789 /// The next I+1 words are pointers to __block variables.
790 BLOCK_LAYOUT_BYREF = 4,
792 /// The next I+1 words are __weak pointers to Objective-C
793 /// objects or blocks.
794 BLOCK_LAYOUT_WEAK = 5,
796 /// The next I+1 words are __unsafe_unretained pointers to
797 /// Objective-C objects or blocks.
798 BLOCK_LAYOUT_UNRETAINED = 6
800 /// The next I+1 words are block or object pointers with some
801 /// as-yet-unspecified ownership semantics. If we add more
802 /// flavors of ownership semantics, values will be taken from
805 /// This is included so that older tools can at least continue
806 /// processing the layout past such things.
807 //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
809 /// All other opcodes are reserved. Halt interpretation and
810 /// treat everything else as opaque.
815 enum BLOCK_LAYOUT_OPCODE opcode;
816 CharUnits block_var_bytepos;
817 CharUnits block_var_size;
818 RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
819 CharUnits BytePos = CharUnits::Zero(),
820 CharUnits Size = CharUnits::Zero())
821 : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {}
823 // Allow sorting based on byte pos.
824 bool operator<(const RUN_SKIP &b) const {
825 return block_var_bytepos < b.block_var_bytepos;
830 llvm::LLVMContext &VMContext;
831 // FIXME! May not be needing this after all.
834 // gc ivar layout bitmap calculation helper caches.
835 SmallVector<GC_IVAR, 16> SkipIvars;
836 SmallVector<GC_IVAR, 16> IvarsInfo;
838 // arc/mrr layout of captured block literal variables.
839 SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
841 /// LazySymbols - Symbols to generate a lazy reference for. See
842 /// DefinedSymbols and FinishModule().
843 llvm::SetVector<IdentifierInfo*> LazySymbols;
845 /// DefinedSymbols - External symbols which are defined by this
846 /// module. The symbols in this list and LazySymbols are used to add
847 /// special linker symbols which ensure that Objective-C modules are
849 llvm::SetVector<IdentifierInfo*> DefinedSymbols;
851 /// ClassNames - uniqued class names.
852 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassNames;
854 /// MethodVarNames - uniqued method variable names.
855 llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
857 /// DefinedCategoryNames - list of category names in form Class_Category.
858 llvm::SetVector<std::string> DefinedCategoryNames;
860 /// MethodVarTypes - uniqued method type signatures. We have to use
861 /// a StringMap here because have no other unique reference.
862 llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
864 /// MethodDefinitions - map of methods which have been defined in
865 /// this translation unit.
866 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
868 /// PropertyNames - uniqued method variable names.
869 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
871 /// ClassReferences - uniqued class references.
872 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
874 /// SelectorReferences - uniqued selector references.
875 llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
877 /// Protocols - Protocols for which an objc_protocol structure has
878 /// been emitted. Forward declarations are handled by creating an
879 /// empty structure whose initializer is filled in when/if defined.
880 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
882 /// DefinedProtocols - Protocols which have actually been
883 /// defined. We should not need this, see FIXME in GenerateProtocol.
884 llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
886 /// DefinedClasses - List of defined classes.
887 SmallVector<llvm::GlobalValue*, 16> DefinedClasses;
889 /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
890 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
892 /// DefinedCategories - List of defined categories.
893 SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
895 /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
896 SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
898 /// GetNameForMethod - Return a name for the given method.
899 /// \param[out] NameOut - The return value.
900 void GetNameForMethod(const ObjCMethodDecl *OMD,
901 const ObjCContainerDecl *CD,
902 SmallVectorImpl<char> &NameOut);
904 /// GetMethodVarName - Return a unique constant for the given
905 /// selector's name. The return value has type char *.
906 llvm::Constant *GetMethodVarName(Selector Sel);
907 llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
909 /// GetMethodVarType - Return a unique constant for the given
910 /// method's type encoding string. The return value has type char *.
912 // FIXME: This is a horrible name.
913 llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
914 bool Extended = false);
915 llvm::Constant *GetMethodVarType(const FieldDecl *D);
917 /// GetPropertyName - Return a unique constant for the given
918 /// name. The return value has type char *.
919 llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
921 // FIXME: This can be dropped once string functions are unified.
922 llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
923 const Decl *Container);
925 /// GetClassName - Return a unique constant for the given selector's
926 /// name. The return value has type char *.
927 llvm::Constant *GetClassName(IdentifierInfo *Ident);
929 llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
931 /// BuildIvarLayout - Builds ivar layout bitmap for the class
932 /// implementation for the __strong or __weak case.
934 llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
935 bool ForStrongLayout);
937 llvm::Constant *BuildIvarLayoutBitmap(std::string &BitMap);
939 void BuildAggrIvarRecordLayout(const RecordType *RT,
940 unsigned int BytePos, bool ForStrongLayout,
942 void BuildAggrIvarLayout(const ObjCImplementationDecl *OI,
943 const llvm::StructLayout *Layout,
944 const RecordDecl *RD,
945 ArrayRef<const FieldDecl*> RecFields,
946 unsigned int BytePos, bool ForStrongLayout,
949 Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
951 void UpdateRunSkipBlockVars(bool IsByref,
952 Qualifiers::ObjCLifetime LifeTime,
953 CharUnits FieldOffset,
954 CharUnits FieldSize);
956 void BuildRCBlockVarRecordLayout(const RecordType *RT,
957 CharUnits BytePos, bool &HasUnion,
958 bool ByrefLayout=false);
960 void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
961 const RecordDecl *RD,
962 ArrayRef<const FieldDecl*> RecFields,
963 CharUnits BytePos, bool &HasUnion,
966 uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
968 llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
971 /// GetIvarLayoutName - Returns a unique constant for the given
972 /// ivar layout bitmap.
973 llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
974 const ObjCCommonTypesHelper &ObjCTypes);
976 /// EmitPropertyList - Emit the given property list. The return
977 /// value has type PropertyListPtrTy.
978 llvm::Constant *EmitPropertyList(Twine Name,
979 const Decl *Container,
980 const ObjCContainerDecl *OCD,
981 const ObjCCommonTypesHelper &ObjCTypes);
983 /// EmitProtocolMethodTypes - Generate the array of extended method type
984 /// strings. The return value has type Int8PtrPtrTy.
985 llvm::Constant *EmitProtocolMethodTypes(Twine Name,
986 ArrayRef<llvm::Constant*> MethodTypes,
987 const ObjCCommonTypesHelper &ObjCTypes);
989 /// PushProtocolProperties - Push protocol's property on the input stack.
990 void PushProtocolProperties(
991 llvm::SmallPtrSet<const IdentifierInfo*, 16> &PropertySet,
992 SmallVectorImpl<llvm::Constant*> &Properties,
993 const Decl *Container,
994 const ObjCProtocolDecl *PROTO,
995 const ObjCCommonTypesHelper &ObjCTypes);
997 /// GetProtocolRef - Return a reference to the internal protocol
998 /// description, creating an empty one if it has not been
999 /// defined. The return value has type ProtocolPtrTy.
1000 llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
1002 /// CreateMetadataVar - Create a global variable with internal
1003 /// linkage for use by the Objective-C runtime.
1005 /// This is a convenience wrapper which not only creates the
1006 /// variable, but also sets the section and alignment and adds the
1007 /// global to the "llvm.used" list.
1009 /// \param Name - The variable name.
1010 /// \param Init - The variable initializer; this is also used to
1011 /// define the type of the variable.
1012 /// \param Section - The section the variable should go into, or 0.
1013 /// \param Align - The alignment for the variable, or 0.
1014 /// \param AddToUsed - Whether the variable should be added to
1016 llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1017 llvm::Constant *Init,
1018 const char *Section,
1022 CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1023 ReturnValueSlot Return,
1024 QualType ResultType,
1029 const CallArgList &CallArgs,
1030 const ObjCMethodDecl *OMD,
1031 const ObjCCommonTypesHelper &ObjCTypes);
1033 /// EmitImageInfo - Emit the image info marker used to encode some module
1034 /// level information.
1035 void EmitImageInfo();
1038 CGObjCCommonMac(CodeGen::CodeGenModule &cgm) :
1039 CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) { }
1041 virtual llvm::Constant *GenerateConstantString(const StringLiteral *SL);
1043 virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1044 const ObjCContainerDecl *CD=0);
1046 virtual void GenerateProtocol(const ObjCProtocolDecl *PD);
1048 /// GetOrEmitProtocol - Get the protocol object for the given
1049 /// declaration, emitting it if necessary. The return value has type
1051 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
1053 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1054 /// object for the given declaration, emitting it if needed. These
1055 /// forward references will be filled in with empty bodies if no
1056 /// definition is seen. The return value has type ProtocolPtrTy.
1057 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1058 virtual llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1059 const CGBlockInfo &blockInfo);
1060 virtual llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1061 const CGBlockInfo &blockInfo);
1063 virtual llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1067 class CGObjCMac : public CGObjCCommonMac {
1069 ObjCTypesHelper ObjCTypes;
1071 /// EmitModuleInfo - Another marker encoding module level
1073 void EmitModuleInfo();
1075 /// EmitModuleSymols - Emit module symbols, the list of defined
1076 /// classes and categories. The result has type SymtabPtrTy.
1077 llvm::Constant *EmitModuleSymbols();
1079 /// FinishModule - Write out global data structures at the end of
1080 /// processing a translation unit.
1081 void FinishModule();
1083 /// EmitClassExtension - Generate the class extension structure used
1084 /// to store the weak ivar layout and properties. The return value
1085 /// has type ClassExtensionPtrTy.
1086 llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID);
1088 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1089 /// for the given class.
1090 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1091 const ObjCInterfaceDecl *ID);
1093 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1094 IdentifierInfo *II);
1096 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF);
1098 /// EmitSuperClassRef - Emits reference to class's main metadata class.
1099 llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1101 /// EmitIvarList - Emit the ivar list for the given
1102 /// implementation. If ForClass is true the list of class ivars
1103 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1104 /// interface ivars will be emitted. The return value has type
1106 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1109 /// EmitMetaClass - Emit a forward reference to the class structure
1110 /// for the metaclass of the given interface. The return value has
1111 /// type ClassPtrTy.
1112 llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1114 /// EmitMetaClass - Emit a class structure for the metaclass of the
1115 /// given implementation. The return value has type ClassPtrTy.
1116 llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1117 llvm::Constant *Protocols,
1118 ArrayRef<llvm::Constant*> Methods);
1120 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
1122 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
1124 /// EmitMethodList - Emit the method list for the given
1125 /// implementation. The return value has type MethodListPtrTy.
1126 llvm::Constant *EmitMethodList(Twine Name,
1127 const char *Section,
1128 ArrayRef<llvm::Constant*> Methods);
1130 /// EmitMethodDescList - Emit a method description list for a list of
1131 /// method declarations.
1132 /// - TypeName: The name for the type containing the methods.
1133 /// - IsProtocol: True iff these methods are for a protocol.
1134 /// - ClassMethds: True iff these are class methods.
1135 /// - Required: When true, only "required" methods are
1136 /// listed. Similarly, when false only "optional" methods are
1137 /// listed. For classes this should always be true.
1138 /// - begin, end: The method list to output.
1140 /// The return value has type MethodDescriptionListPtrTy.
1141 llvm::Constant *EmitMethodDescList(Twine Name,
1142 const char *Section,
1143 ArrayRef<llvm::Constant*> Methods);
1145 /// GetOrEmitProtocol - Get the protocol object for the given
1146 /// declaration, emitting it if necessary. The return value has type
1148 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD);
1150 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1151 /// object for the given declaration, emitting it if needed. These
1152 /// forward references will be filled in with empty bodies if no
1153 /// definition is seen. The return value has type ProtocolPtrTy.
1154 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD);
1156 /// EmitProtocolExtension - Generate the protocol extension
1157 /// structure used to store optional instance and class methods, and
1158 /// protocol properties. The return value has type
1159 /// ProtocolExtensionPtrTy.
1161 EmitProtocolExtension(const ObjCProtocolDecl *PD,
1162 ArrayRef<llvm::Constant*> OptInstanceMethods,
1163 ArrayRef<llvm::Constant*> OptClassMethods,
1164 ArrayRef<llvm::Constant*> MethodTypesExt);
1166 /// EmitProtocolList - Generate the list of referenced
1167 /// protocols. The return value has type ProtocolListPtrTy.
1168 llvm::Constant *EmitProtocolList(Twine Name,
1169 ObjCProtocolDecl::protocol_iterator begin,
1170 ObjCProtocolDecl::protocol_iterator end);
1172 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1173 /// for the given selector.
1174 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel,
1178 CGObjCMac(CodeGen::CodeGenModule &cgm);
1180 virtual llvm::Function *ModuleInitFunction();
1182 virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1183 ReturnValueSlot Return,
1184 QualType ResultType,
1186 llvm::Value *Receiver,
1187 const CallArgList &CallArgs,
1188 const ObjCInterfaceDecl *Class,
1189 const ObjCMethodDecl *Method);
1191 virtual CodeGen::RValue
1192 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1193 ReturnValueSlot Return,
1194 QualType ResultType,
1196 const ObjCInterfaceDecl *Class,
1197 bool isCategoryImpl,
1198 llvm::Value *Receiver,
1199 bool IsClassMessage,
1200 const CallArgList &CallArgs,
1201 const ObjCMethodDecl *Method);
1203 virtual llvm::Value *GetClass(CodeGenFunction &CGF,
1204 const ObjCInterfaceDecl *ID);
1206 virtual llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel,
1209 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1211 virtual llvm::Value *GetSelector(CodeGenFunction &CGF,
1212 const ObjCMethodDecl *Method);
1214 virtual llvm::Constant *GetEHType(QualType T);
1216 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
1218 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
1220 virtual void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) {}
1222 virtual llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1223 const ObjCProtocolDecl *PD);
1225 virtual llvm::Constant *GetPropertyGetFunction();
1226 virtual llvm::Constant *GetPropertySetFunction();
1227 virtual llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1229 virtual llvm::Constant *GetGetStructFunction();
1230 virtual llvm::Constant *GetSetStructFunction();
1231 virtual llvm::Constant *GetCppAtomicObjectGetFunction();
1232 virtual llvm::Constant *GetCppAtomicObjectSetFunction();
1233 virtual llvm::Constant *EnumerationMutationFunction();
1235 virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1236 const ObjCAtTryStmt &S);
1237 virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1238 const ObjCAtSynchronizedStmt &S);
1239 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1240 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
1241 const ObjCAtThrowStmt &S,
1242 bool ClearInsertionPoint=true);
1243 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1244 llvm::Value *AddrWeakObj);
1245 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1246 llvm::Value *src, llvm::Value *dst);
1247 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1248 llvm::Value *src, llvm::Value *dest,
1249 bool threadlocal = false);
1250 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1251 llvm::Value *src, llvm::Value *dest,
1252 llvm::Value *ivarOffset);
1253 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1254 llvm::Value *src, llvm::Value *dest);
1255 virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1256 llvm::Value *dest, llvm::Value *src,
1259 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
1261 llvm::Value *BaseValue,
1262 const ObjCIvarDecl *Ivar,
1263 unsigned CVRQualifiers);
1264 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1265 const ObjCInterfaceDecl *Interface,
1266 const ObjCIvarDecl *Ivar);
1268 /// GetClassGlobal - Return the global variable for the Objective-C
1269 /// class of the given name.
1270 virtual llvm::GlobalVariable *GetClassGlobal(const std::string &Name) {
1271 llvm_unreachable("CGObjCMac::GetClassGlobal");
1275 class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1277 ObjCNonFragileABITypesHelper ObjCTypes;
1278 llvm::GlobalVariable* ObjCEmptyCacheVar;
1279 llvm::GlobalVariable* ObjCEmptyVtableVar;
1281 /// SuperClassReferences - uniqued super class references.
1282 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1284 /// MetaClassReferences - uniqued meta class references.
1285 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1287 /// EHTypeReferences - uniqued class ehtype references.
1288 llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1290 /// VTableDispatchMethods - List of methods for which we generate
1291 /// vtable-based message dispatch.
1292 llvm::DenseSet<Selector> VTableDispatchMethods;
1294 /// DefinedMetaClasses - List of defined meta-classes.
1295 std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1297 /// isVTableDispatchedSelector - Returns true if SEL is a
1298 /// vtable-based selector.
1299 bool isVTableDispatchedSelector(Selector Sel);
1301 /// FinishNonFragileABIModule - Write out global data structures at the end of
1302 /// processing a translation unit.
1303 void FinishNonFragileABIModule();
1305 /// AddModuleClassList - Add the given list of class pointers to the
1306 /// module with the provided symbol and section names.
1307 void AddModuleClassList(ArrayRef<llvm::GlobalValue*> Container,
1308 const char *SymbolName,
1309 const char *SectionName);
1311 llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1312 unsigned InstanceStart,
1313 unsigned InstanceSize,
1314 const ObjCImplementationDecl *ID);
1315 llvm::GlobalVariable * BuildClassMetaData(std::string &ClassName,
1316 llvm::Constant *IsAGV,
1317 llvm::Constant *SuperClassGV,
1318 llvm::Constant *ClassRoGV,
1319 bool HiddenVisibility);
1321 llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
1323 llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
1325 /// EmitMethodList - Emit the method list for the given
1326 /// implementation. The return value has type MethodListnfABITy.
1327 llvm::Constant *EmitMethodList(Twine Name,
1328 const char *Section,
1329 ArrayRef<llvm::Constant*> Methods);
1330 /// EmitIvarList - Emit the ivar list for the given
1331 /// implementation. If ForClass is true the list of class ivars
1332 /// (i.e. metaclass ivars) is emitted, otherwise the list of
1333 /// interface ivars will be emitted. The return value has type
1334 /// IvarListnfABIPtrTy.
1335 llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
1337 llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1338 const ObjCIvarDecl *Ivar,
1339 unsigned long int offset);
1341 /// GetOrEmitProtocol - Get the protocol object for the given
1342 /// declaration, emitting it if necessary. The return value has type
1344 virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD);
1346 /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1347 /// object for the given declaration, emitting it if needed. These
1348 /// forward references will be filled in with empty bodies if no
1349 /// definition is seen. The return value has type ProtocolPtrTy.
1350 virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD);
1352 /// EmitProtocolList - Generate the list of referenced
1353 /// protocols. The return value has type ProtocolListPtrTy.
1354 llvm::Constant *EmitProtocolList(Twine Name,
1355 ObjCProtocolDecl::protocol_iterator begin,
1356 ObjCProtocolDecl::protocol_iterator end);
1358 CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1359 ReturnValueSlot Return,
1360 QualType ResultType,
1362 llvm::Value *Receiver,
1365 const CallArgList &CallArgs,
1366 const ObjCMethodDecl *Method);
1368 /// GetClassGlobal - Return the global variable for the Objective-C
1369 /// class of the given name.
1370 llvm::GlobalVariable *GetClassGlobal(const std::string &Name);
1372 /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1373 /// for the given class reference.
1374 llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1375 const ObjCInterfaceDecl *ID);
1377 llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1378 IdentifierInfo *II);
1380 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF);
1382 /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1383 /// for the given super class reference.
1384 llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1385 const ObjCInterfaceDecl *ID);
1387 /// EmitMetaClassRef - Return a Value * of the address of _class_t
1389 llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1390 const ObjCInterfaceDecl *ID);
1392 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1395 llvm::GlobalVariable * ObjCIvarOffsetVariable(
1396 const ObjCInterfaceDecl *ID,
1397 const ObjCIvarDecl *Ivar);
1399 /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1400 /// for the given selector.
1401 llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel,
1404 /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1405 /// interface. The return value has type EHTypePtrTy.
1406 llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1407 bool ForDefinition);
1409 const char *getMetaclassSymbolPrefix() const {
1410 return "OBJC_METACLASS_$_";
1413 const char *getClassSymbolPrefix() const {
1414 return "OBJC_CLASS_$_";
1417 void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1418 uint32_t &InstanceStart,
1419 uint32_t &InstanceSize);
1421 // Shamelessly stolen from Analysis/CFRefCount.cpp
1422 Selector GetNullarySelector(const char* name) const {
1423 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1424 return CGM.getContext().Selectors.getSelector(0, &II);
1427 Selector GetUnarySelector(const char* name) const {
1428 IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1429 return CGM.getContext().Selectors.getSelector(1, &II);
1432 /// ImplementationIsNonLazy - Check whether the given category or
1433 /// class implementation is "non-lazy".
1434 bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1436 bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1437 const ObjCInterfaceDecl *ID,
1438 const ObjCIvarDecl *IV) {
1439 // Annotate the load as an invariant load iff the object type is the type,
1440 // or a derived type, of the class containing the ivar within an ObjC
1441 // method. This check is needed because the ivar offset is a lazily
1442 // initialised value that may depend on objc_msgSend to perform a fixup on
1443 // the first message dispatch.
1445 // An additional opportunity to mark the load as invariant arises when the
1446 // base of the ivar access is a parameter to an Objective C method.
1447 // However, because the parameters are not available in the current
1448 // interface, we cannot perform this check.
1449 if (CGF.CurFuncDecl && isa<ObjCMethodDecl>(CGF.CurFuncDecl))
1450 if (IV->getContainingInterface()->isSuperClassOf(ID))
1456 CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1457 // FIXME. All stubs for now!
1458 virtual llvm::Function *ModuleInitFunction();
1460 virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1461 ReturnValueSlot Return,
1462 QualType ResultType,
1464 llvm::Value *Receiver,
1465 const CallArgList &CallArgs,
1466 const ObjCInterfaceDecl *Class,
1467 const ObjCMethodDecl *Method);
1469 virtual CodeGen::RValue
1470 GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1471 ReturnValueSlot Return,
1472 QualType ResultType,
1474 const ObjCInterfaceDecl *Class,
1475 bool isCategoryImpl,
1476 llvm::Value *Receiver,
1477 bool IsClassMessage,
1478 const CallArgList &CallArgs,
1479 const ObjCMethodDecl *Method);
1481 virtual llvm::Value *GetClass(CodeGenFunction &CGF,
1482 const ObjCInterfaceDecl *ID);
1484 virtual llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel,
1485 bool lvalue = false)
1486 { return EmitSelector(CGF, Sel, lvalue); }
1488 /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1490 virtual llvm::Value *GetSelector(CodeGenFunction &CGF,
1491 const ObjCMethodDecl *Method)
1492 { return EmitSelector(CGF, Method->getSelector()); }
1494 virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
1496 virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
1498 virtual void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) {}
1500 virtual llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1501 const ObjCProtocolDecl *PD);
1503 virtual llvm::Constant *GetEHType(QualType T);
1505 virtual llvm::Constant *GetPropertyGetFunction() {
1506 return ObjCTypes.getGetPropertyFn();
1508 virtual llvm::Constant *GetPropertySetFunction() {
1509 return ObjCTypes.getSetPropertyFn();
1512 virtual llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1514 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1517 virtual llvm::Constant *GetSetStructFunction() {
1518 return ObjCTypes.getCopyStructFn();
1520 virtual llvm::Constant *GetGetStructFunction() {
1521 return ObjCTypes.getCopyStructFn();
1523 virtual llvm::Constant *GetCppAtomicObjectSetFunction() {
1524 return ObjCTypes.getCppAtomicObjectFunction();
1526 virtual llvm::Constant *GetCppAtomicObjectGetFunction() {
1527 return ObjCTypes.getCppAtomicObjectFunction();
1530 virtual llvm::Constant *EnumerationMutationFunction() {
1531 return ObjCTypes.getEnumerationMutationFn();
1534 virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1535 const ObjCAtTryStmt &S);
1536 virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1537 const ObjCAtSynchronizedStmt &S);
1538 virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
1539 const ObjCAtThrowStmt &S,
1540 bool ClearInsertionPoint=true);
1541 virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1542 llvm::Value *AddrWeakObj);
1543 virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1544 llvm::Value *src, llvm::Value *dst);
1545 virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1546 llvm::Value *src, llvm::Value *dest,
1547 bool threadlocal = false);
1548 virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1549 llvm::Value *src, llvm::Value *dest,
1550 llvm::Value *ivarOffset);
1551 virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1552 llvm::Value *src, llvm::Value *dest);
1553 virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1554 llvm::Value *dest, llvm::Value *src,
1556 virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
1558 llvm::Value *BaseValue,
1559 const ObjCIvarDecl *Ivar,
1560 unsigned CVRQualifiers);
1561 virtual llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1562 const ObjCInterfaceDecl *Interface,
1563 const ObjCIvarDecl *Ivar);
1566 /// A helper class for performing the null-initialization of a return
1568 struct NullReturnState {
1569 llvm::BasicBlock *NullBB;
1570 NullReturnState() : NullBB(0) {}
1572 /// Perform a null-check of the given receiver.
1573 void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1574 // Make blocks for the null-receiver and call edges.
1575 NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1576 llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1578 // Check for a null receiver and, if there is one, jump to the
1579 // null-receiver block. There's no point in trying to avoid it:
1580 // we're always going to put *something* there, because otherwise
1581 // we shouldn't have done this null-check in the first place.
1582 llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1583 CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1585 // Otherwise, start performing the call.
1586 CGF.EmitBlock(callBB);
1589 /// Complete the null-return operation. It is valid to call this
1590 /// regardless of whether 'init' has been called.
1591 RValue complete(CodeGenFunction &CGF, RValue result, QualType resultType,
1592 const CallArgList &CallArgs,
1593 const ObjCMethodDecl *Method) {
1594 // If we never had to do a null-check, just use the raw result.
1595 if (!NullBB) return result;
1597 // The continuation block. This will be left null if we don't have an
1598 // IP, which can happen if the method we're calling is marked noreturn.
1599 llvm::BasicBlock *contBB = 0;
1601 // Finish the call path.
1602 llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1604 contBB = CGF.createBasicBlock("msgSend.cont");
1605 CGF.Builder.CreateBr(contBB);
1608 // Okay, start emitting the null-receiver block.
1609 CGF.EmitBlock(NullBB);
1611 // Release any consumed arguments we've got.
1613 CallArgList::const_iterator I = CallArgs.begin();
1614 for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
1615 e = Method->param_end(); i != e; ++i, ++I) {
1616 const ParmVarDecl *ParamDecl = (*i);
1617 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1619 assert(RV.isScalar() &&
1620 "NullReturnState::complete - arg not on object");
1621 CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime);
1626 // The phi code below assumes that we haven't needed any control flow yet.
1627 assert(CGF.Builder.GetInsertBlock() == NullBB);
1629 // If we've got a void return, just jump to the continuation block.
1630 if (result.isScalar() && resultType->isVoidType()) {
1631 // No jumps required if the message-send was noreturn.
1632 if (contBB) CGF.EmitBlock(contBB);
1636 // If we've got a scalar return, build a phi.
1637 if (result.isScalar()) {
1638 // Derive the null-initialization value.
1639 llvm::Constant *null = CGF.CGM.EmitNullConstant(resultType);
1641 // If no join is necessary, just flow out.
1642 if (!contBB) return RValue::get(null);
1644 // Otherwise, build a phi.
1645 CGF.EmitBlock(contBB);
1646 llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1647 phi->addIncoming(result.getScalarVal(), callBB);
1648 phi->addIncoming(null, NullBB);
1649 return RValue::get(phi);
1652 // If we've got an aggregate return, null the buffer out.
1653 // FIXME: maybe we should be doing things differently for all the
1654 // cases where the ABI has us returning (1) non-agg values in
1655 // memory or (2) agg values in registers.
1656 if (result.isAggregate()) {
1657 assert(result.isAggregate() && "null init of non-aggregate result?");
1658 CGF.EmitNullInitialization(result.getAggregateAddr(), resultType);
1659 if (contBB) CGF.EmitBlock(contBB);
1664 CGF.EmitBlock(contBB);
1665 CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1667 // Find the scalar type and its zero value.
1668 llvm::Type *scalarTy = callResult.first->getType();
1669 llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1671 // Build phis for both coordinates.
1672 llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1673 real->addIncoming(callResult.first, callBB);
1674 real->addIncoming(scalarZero, NullBB);
1675 llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1676 imag->addIncoming(callResult.second, callBB);
1677 imag->addIncoming(scalarZero, NullBB);
1678 return RValue::getComplex(real, imag);
1682 } // end anonymous namespace
1684 /* *** Helper Functions *** */
1686 /// getConstantGEP() - Help routine to construct simple GEPs.
1687 static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1691 llvm::Value *Idxs[] = {
1692 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1693 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1695 return llvm::ConstantExpr::getGetElementPtr(C, Idxs);
1698 /// hasObjCExceptionAttribute - Return true if this class or any super
1699 /// class has the __objc_exception__ attribute.
1700 static bool hasObjCExceptionAttribute(ASTContext &Context,
1701 const ObjCInterfaceDecl *OID) {
1702 if (OID->hasAttr<ObjCExceptionAttr>())
1704 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1705 return hasObjCExceptionAttribute(Context, Super);
1709 /* *** CGObjCMac Public Interface *** */
1711 CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1717 /// GetClass - Return a reference to the class for the given interface
1719 llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1720 const ObjCInterfaceDecl *ID) {
1721 return EmitClassRef(CGF, ID);
1724 /// GetSelector - Return the pointer to the unique'd string for this selector.
1725 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel,
1727 return EmitSelector(CGF, Sel, lval);
1729 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1731 return EmitSelector(CGF, Method->getSelector());
1734 llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1735 if (T->isObjCIdType() ||
1736 T->isObjCQualifiedIdType()) {
1737 return CGM.GetAddrOfRTTIDescriptor(
1738 CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1740 if (T->isObjCClassType() ||
1741 T->isObjCQualifiedClassType()) {
1742 return CGM.GetAddrOfRTTIDescriptor(
1743 CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1745 if (T->isObjCObjectPointerType())
1746 return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true);
1748 llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1751 /// Generate a constant CFString object.
1753 struct __builtin_CFString {
1754 const int *isa; // point to __CFConstantStringClassReference
1761 /// or Generate a constant NSString object.
1763 struct __builtin_NSString {
1764 const int *isa; // point to __NSConstantStringClassReference
1766 unsigned int length;
1770 llvm::Constant *CGObjCCommonMac::GenerateConstantString(
1771 const StringLiteral *SL) {
1772 return (CGM.getLangOpts().NoConstantCFStrings == 0 ?
1773 CGM.GetAddrOfConstantCFString(SL) :
1774 CGM.GetAddrOfConstantString(SL));
1778 kCFTaggedObjectID_Integer = (1 << 1) + 1
1781 /// Generates a message send where the super is the receiver. This is
1782 /// a message send to self with special delivery semantics indicating
1783 /// which class's method should be called.
1785 CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1786 ReturnValueSlot Return,
1787 QualType ResultType,
1789 const ObjCInterfaceDecl *Class,
1790 bool isCategoryImpl,
1791 llvm::Value *Receiver,
1792 bool IsClassMessage,
1793 const CodeGen::CallArgList &CallArgs,
1794 const ObjCMethodDecl *Method) {
1795 // Create and init a super structure; this is a (receiver, class)
1796 // pair we will pass to objc_msgSendSuper.
1797 llvm::Value *ObjCSuper =
1798 CGF.CreateTempAlloca(ObjCTypes.SuperTy, "objc_super");
1799 llvm::Value *ReceiverAsObject =
1800 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
1801 CGF.Builder.CreateStore(ReceiverAsObject,
1802 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
1804 // If this is a class message the metaclass is passed as the target.
1805 llvm::Value *Target;
1806 if (IsClassMessage) {
1807 if (isCategoryImpl) {
1808 // Message sent to 'super' in a class method defined in a category
1809 // implementation requires an odd treatment.
1810 // If we are in a class method, we must retrieve the
1811 // _metaclass_ for the current class, pointed at by
1812 // the class's "isa" pointer. The following assumes that
1813 // isa" is the first ivar in a class (which it must be).
1814 Target = EmitClassRef(CGF, Class->getSuperClass());
1815 Target = CGF.Builder.CreateStructGEP(Target, 0);
1816 Target = CGF.Builder.CreateLoad(Target);
1818 llvm::Value *MetaClassPtr = EmitMetaClassRef(Class);
1819 llvm::Value *SuperPtr = CGF.Builder.CreateStructGEP(MetaClassPtr, 1);
1820 llvm::Value *Super = CGF.Builder.CreateLoad(SuperPtr);
1824 else if (isCategoryImpl)
1825 Target = EmitClassRef(CGF, Class->getSuperClass());
1827 llvm::Value *ClassPtr = EmitSuperClassRef(Class);
1828 ClassPtr = CGF.Builder.CreateStructGEP(ClassPtr, 1);
1829 Target = CGF.Builder.CreateLoad(ClassPtr);
1831 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
1833 llvm::Type *ClassTy =
1834 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
1835 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
1836 CGF.Builder.CreateStore(Target,
1837 CGF.Builder.CreateStructGEP(ObjCSuper, 1));
1838 return EmitMessageSend(CGF, Return, ResultType,
1839 EmitSelector(CGF, Sel),
1840 ObjCSuper, ObjCTypes.SuperPtrCTy,
1841 true, CallArgs, Method, ObjCTypes);
1844 /// Generate code for a message send expression.
1845 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1846 ReturnValueSlot Return,
1847 QualType ResultType,
1849 llvm::Value *Receiver,
1850 const CallArgList &CallArgs,
1851 const ObjCInterfaceDecl *Class,
1852 const ObjCMethodDecl *Method) {
1853 return EmitMessageSend(CGF, Return, ResultType,
1854 EmitSelector(CGF, Sel),
1855 Receiver, CGF.getContext().getObjCIdType(),
1856 false, CallArgs, Method, ObjCTypes);
1860 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1861 ReturnValueSlot Return,
1862 QualType ResultType,
1867 const CallArgList &CallArgs,
1868 const ObjCMethodDecl *Method,
1869 const ObjCCommonTypesHelper &ObjCTypes) {
1870 CallArgList ActualArgs;
1872 Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
1873 ActualArgs.add(RValue::get(Arg0), Arg0Ty);
1874 ActualArgs.add(RValue::get(Sel), CGF.getContext().getObjCSelType());
1875 ActualArgs.addFrom(CallArgs);
1877 // If we're calling a method, use the formal signature.
1878 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
1881 assert(CGM.getContext().getCanonicalType(Method->getResultType()) ==
1882 CGM.getContext().getCanonicalType(ResultType) &&
1883 "Result type mismatch!");
1885 NullReturnState nullReturn;
1887 llvm::Constant *Fn = NULL;
1888 if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) {
1889 if (!IsSuper) nullReturn.init(CGF, Arg0);
1890 Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
1891 : ObjCTypes.getSendStretFn(IsSuper);
1892 } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
1893 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
1894 : ObjCTypes.getSendFpretFn(IsSuper);
1895 } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
1896 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
1897 : ObjCTypes.getSendFp2retFn(IsSuper);
1899 Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
1900 : ObjCTypes.getSendFn(IsSuper);
1903 bool requiresnullCheck = false;
1904 if (CGM.getLangOpts().ObjCAutoRefCount && Method)
1905 for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
1906 e = Method->param_end(); i != e; ++i) {
1907 const ParmVarDecl *ParamDecl = (*i);
1908 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1909 if (!nullReturn.NullBB)
1910 nullReturn.init(CGF, Arg0);
1911 requiresnullCheck = true;
1916 Fn = llvm::ConstantExpr::getBitCast(Fn, MSI.MessengerType);
1917 RValue rvalue = CGF.EmitCall(MSI.CallInfo, Fn, Return, ActualArgs);
1918 return nullReturn.complete(CGF, rvalue, ResultType, CallArgs,
1919 requiresnullCheck ? Method : 0);
1922 static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT) {
1923 if (FQT.isObjCGCStrong())
1924 return Qualifiers::Strong;
1926 if (FQT.isObjCGCWeak() || FQT.getObjCLifetime() == Qualifiers::OCL_Weak)
1927 return Qualifiers::Weak;
1929 // check for __unsafe_unretained
1930 if (FQT.getObjCLifetime() == Qualifiers::OCL_ExplicitNone)
1931 return Qualifiers::GCNone;
1933 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
1934 return Qualifiers::Strong;
1936 if (const PointerType *PT = FQT->getAs<PointerType>())
1937 return GetGCAttrTypeForType(Ctx, PT->getPointeeType());
1939 return Qualifiers::GCNone;
1942 llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
1943 const CGBlockInfo &blockInfo) {
1945 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
1946 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
1947 !CGM.getLangOpts().ObjCAutoRefCount)
1950 bool hasUnion = false;
1953 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
1954 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
1956 // __isa is the first field in block descriptor and must assume by runtime's
1957 // convention that it is GC'able.
1958 IvarsInfo.push_back(GC_IVAR(0, 1));
1960 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
1962 // Calculate the basic layout of the block structure.
1963 const llvm::StructLayout *layout =
1964 CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
1966 // Ignore the optional 'this' capture: C++ objects are not assumed
1969 // Walk the captured variables.
1970 for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(),
1971 ce = blockDecl->capture_end(); ci != ce; ++ci) {
1972 const VarDecl *variable = ci->getVariable();
1973 QualType type = variable->getType();
1975 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
1977 // Ignore constant captures.
1978 if (capture.isConstant()) continue;
1980 uint64_t fieldOffset = layout->getElementOffset(capture.getIndex());
1982 // __block variables are passed by their descriptor address.
1983 if (ci->isByRef()) {
1984 IvarsInfo.push_back(GC_IVAR(fieldOffset, /*size in words*/ 1));
1988 assert(!type->isArrayType() && "array variable should not be caught");
1989 if (const RecordType *record = type->getAs<RecordType>()) {
1990 BuildAggrIvarRecordLayout(record, fieldOffset, true, hasUnion);
1994 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);
1995 unsigned fieldSize = CGM.getContext().getTypeSize(type);
1997 if (GCAttr == Qualifiers::Strong)
1998 IvarsInfo.push_back(GC_IVAR(fieldOffset,
1999 fieldSize / WordSizeInBits));
2000 else if (GCAttr == Qualifiers::GCNone || GCAttr == Qualifiers::Weak)
2001 SkipIvars.push_back(GC_IVAR(fieldOffset,
2002 fieldSize / ByteSizeInBits));
2005 if (IvarsInfo.empty())
2008 // Sort on byte position; captures might not be allocated in order,
2009 // and unions can do funny things.
2010 llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
2011 llvm::array_pod_sort(SkipIvars.begin(), SkipIvars.end());
2014 llvm::Constant *C = BuildIvarLayoutBitmap(BitMap);
2015 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2016 printf("\n block variable layout for block: ");
2017 const unsigned char *s = (const unsigned char*)BitMap.c_str();
2018 for (unsigned i = 0, e = BitMap.size(); i < e; i++)
2020 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2022 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
2029 /// getBlockCaptureLifetime - This routine returns life time of the captured
2030 /// block variable for the purpose of block layout meta-data generation. FQT is
2031 /// the type of the variable captured in the block.
2032 Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2034 if (CGM.getLangOpts().ObjCAutoRefCount)
2035 return FQT.getObjCLifetime();
2038 if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2039 return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong;
2041 return Qualifiers::OCL_None;
2044 void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2045 Qualifiers::ObjCLifetime LifeTime,
2046 CharUnits FieldOffset,
2047 CharUnits FieldSize) {
2048 // __block variables are passed by their descriptor address.
2050 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2052 else if (LifeTime == Qualifiers::OCL_Strong)
2053 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2055 else if (LifeTime == Qualifiers::OCL_Weak)
2056 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2058 else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2059 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2062 RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2067 void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2068 const RecordDecl *RD,
2069 ArrayRef<const FieldDecl*> RecFields,
2070 CharUnits BytePos, bool &HasUnion,
2072 bool IsUnion = (RD && RD->isUnion());
2073 CharUnits MaxUnionSize = CharUnits::Zero();
2074 const FieldDecl *MaxField = 0;
2075 const FieldDecl *LastFieldBitfieldOrUnnamed = 0;
2076 CharUnits MaxFieldOffset = CharUnits::Zero();
2077 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2079 if (RecFields.empty())
2081 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2083 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
2084 const FieldDecl *Field = RecFields[i];
2085 // Note that 'i' here is actually the field index inside RD of Field,
2086 // although this dependency is hidden.
2087 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2088 CharUnits FieldOffset =
2089 CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i));
2091 // Skip over unnamed or bitfields
2092 if (!Field->getIdentifier() || Field->isBitField()) {
2093 LastFieldBitfieldOrUnnamed = Field;
2094 LastBitfieldOrUnnamedOffset = FieldOffset;
2098 LastFieldBitfieldOrUnnamed = 0;
2099 QualType FQT = Field->getType();
2100 if (FQT->isRecordType() || FQT->isUnionType()) {
2101 if (FQT->isUnionType())
2104 BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
2105 BytePos + FieldOffset, HasUnion);
2109 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2110 const ConstantArrayType *CArray =
2111 dyn_cast_or_null<ConstantArrayType>(Array);
2112 uint64_t ElCount = CArray->getSize().getZExtValue();
2113 assert(CArray && "only array with known element size is supported");
2114 FQT = CArray->getElementType();
2115 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2116 const ConstantArrayType *CArray =
2117 dyn_cast_or_null<ConstantArrayType>(Array);
2118 ElCount *= CArray->getSize().getZExtValue();
2119 FQT = CArray->getElementType();
2122 assert(!FQT->isUnionType() &&
2123 "layout for array of unions not supported");
2124 if (FQT->isRecordType() && ElCount) {
2125 int OldIndex = RunSkipBlockVars.size() - 1;
2126 const RecordType *RT = FQT->getAs<RecordType>();
2127 BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset,
2130 // Replicate layout information for each array element. Note that
2131 // one element is already done.
2133 for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2134 CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2135 for (int i = OldIndex+1; i <= FirstIndex; ++i)
2136 RunSkipBlockVars.push_back(
2137 RUN_SKIP(RunSkipBlockVars[i].opcode,
2138 RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2139 RunSkipBlockVars[i].block_var_size));
2144 CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2146 CharUnits UnionIvarSize = FieldSize;
2147 if (UnionIvarSize > MaxUnionSize) {
2148 MaxUnionSize = UnionIvarSize;
2150 MaxFieldOffset = FieldOffset;
2153 UpdateRunSkipBlockVars(false,
2154 getBlockCaptureLifetime(FQT, ByrefLayout),
2155 BytePos + FieldOffset,
2160 if (LastFieldBitfieldOrUnnamed) {
2161 if (LastFieldBitfieldOrUnnamed->isBitField()) {
2162 // Last field was a bitfield. Must update the info.
2163 uint64_t BitFieldSize
2164 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2165 unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2166 ((BitFieldSize % ByteSizeInBits) != 0);
2167 CharUnits Size = CharUnits::fromQuantity(UnsSize);
2168 Size += LastBitfieldOrUnnamedOffset;
2169 UpdateRunSkipBlockVars(false,
2170 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2172 BytePos + LastBitfieldOrUnnamedOffset,
2175 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2176 // Last field was unnamed. Must update skip info.
2178 = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2179 UpdateRunSkipBlockVars(false,
2180 getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2182 BytePos + LastBitfieldOrUnnamedOffset,
2188 UpdateRunSkipBlockVars(false,
2189 getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2190 BytePos + MaxFieldOffset,
2194 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2198 const RecordDecl *RD = RT->getDecl();
2199 SmallVector<const FieldDecl*, 16> Fields;
2200 for (RecordDecl::field_iterator i = RD->field_begin(),
2201 e = RD->field_end(); i != e; ++i)
2202 Fields.push_back(*i);
2203 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2204 const llvm::StructLayout *RecLayout =
2205 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2207 BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2210 /// InlineLayoutInstruction - This routine produce an inline instruction for the
2211 /// block variable layout if it can. If not, it returns 0. Rules are as follow:
2212 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2213 /// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2214 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2215 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2216 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2217 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2218 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2219 uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2220 SmallVectorImpl<unsigned char> &Layout) {
2221 uint64_t Result = 0;
2222 if (Layout.size() <= 3) {
2223 unsigned size = Layout.size();
2224 unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2226 enum BLOCK_LAYOUT_OPCODE opcode ;
2230 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2231 if (opcode == BLOCK_LAYOUT_STRONG)
2232 strong_word_count = (inst & 0xF)+1;
2236 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2237 if (opcode == BLOCK_LAYOUT_BYREF)
2238 byref_word_count = (inst & 0xF)+1;
2242 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2243 if (opcode == BLOCK_LAYOUT_WEAK)
2244 weak_word_count = (inst & 0xF)+1;
2251 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2252 if (opcode == BLOCK_LAYOUT_STRONG) {
2253 strong_word_count = (inst & 0xF)+1;
2255 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2256 if (opcode == BLOCK_LAYOUT_BYREF)
2257 byref_word_count = (inst & 0xF)+1;
2258 else if (opcode == BLOCK_LAYOUT_WEAK)
2259 weak_word_count = (inst & 0xF)+1;
2263 else if (opcode == BLOCK_LAYOUT_BYREF) {
2264 byref_word_count = (inst & 0xF)+1;
2266 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2267 if (opcode == BLOCK_LAYOUT_WEAK)
2268 weak_word_count = (inst & 0xF)+1;
2278 opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2279 if (opcode == BLOCK_LAYOUT_STRONG)
2280 strong_word_count = (inst & 0xF)+1;
2281 else if (opcode == BLOCK_LAYOUT_BYREF)
2282 byref_word_count = (inst & 0xF)+1;
2283 else if (opcode == BLOCK_LAYOUT_WEAK)
2284 weak_word_count = (inst & 0xF)+1;
2293 // Cannot inline when any of the word counts is 15. Because this is one less
2294 // than the actual work count (so 15 means 16 actual word counts),
2295 // and we can only display 0 thru 15 word counts.
2296 if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2300 (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2302 if (size == count) {
2303 if (strong_word_count)
2304 Result = strong_word_count;
2306 if (byref_word_count)
2307 Result += byref_word_count;
2309 if (weak_word_count)
2310 Result += weak_word_count;
2316 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2317 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2318 if (RunSkipBlockVars.empty())
2320 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2321 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2322 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2324 // Sort on byte position; captures might not be allocated in order,
2325 // and unions can do funny things.
2326 llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2327 SmallVector<unsigned char, 16> Layout;
2329 unsigned size = RunSkipBlockVars.size();
2330 for (unsigned i = 0; i < size; i++) {
2331 enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2332 CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2333 CharUnits end_byte_pos = start_byte_pos;
2336 if (opcode == RunSkipBlockVars[j].opcode) {
2337 end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2343 CharUnits size_in_bytes =
2344 end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2347 RunSkipBlockVars[j].block_var_bytepos -
2348 RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2349 size_in_bytes += gap;
2351 CharUnits residue_in_bytes = CharUnits::Zero();
2352 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2353 residue_in_bytes = size_in_bytes % WordSizeInBytes;
2354 size_in_bytes -= residue_in_bytes;
2355 opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2358 unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2359 while (size_in_words >= 16) {
2360 // Note that value in imm. is one less that the actual
2361 // value. So, 0xf means 16 words follow!
2362 unsigned char inst = (opcode << 4) | 0xf;
2363 Layout.push_back(inst);
2364 size_in_words -= 16;
2366 if (size_in_words > 0) {
2367 // Note that value in imm. is one less that the actual
2368 // value. So, we subtract 1 away!
2369 unsigned char inst = (opcode << 4) | (size_in_words-1);
2370 Layout.push_back(inst);
2372 if (residue_in_bytes > CharUnits::Zero()) {
2373 unsigned char inst =
2374 (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2375 Layout.push_back(inst);
2379 int e = Layout.size()-1;
2381 unsigned char inst = Layout[e--];
2382 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2383 if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2389 uint64_t Result = InlineLayoutInstruction(Layout);
2391 // Block variable layout instruction has been inlined.
2392 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2393 if (ComputeByrefLayout)
2394 printf("\n Inline instruction for BYREF variable layout: ");
2396 printf("\n Inline instruction for block variable layout: ");
2397 printf("0x0%" PRIx64 "\n", Result);
2399 if (WordSizeInBytes == 8) {
2400 const llvm::APInt Instruction(64, Result);
2401 return llvm::Constant::getIntegerValue(CGM.Int64Ty, Instruction);
2404 const llvm::APInt Instruction(32, Result);
2405 return llvm::Constant::getIntegerValue(CGM.Int32Ty, Instruction);
2409 unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2410 Layout.push_back(inst);
2412 for (unsigned i = 0, e = Layout.size(); i != e; i++)
2413 BitMap += Layout[i];
2415 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2416 if (ComputeByrefLayout)
2417 printf("\n BYREF variable layout: ");
2419 printf("\n block variable layout: ");
2420 for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2421 unsigned char inst = BitMap[i];
2422 enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2425 case BLOCK_LAYOUT_OPERATOR:
2426 printf("BL_OPERATOR:");
2429 case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2430 printf("BL_NON_OBJECT_BYTES:");
2432 case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2433 printf("BL_NON_OBJECT_WORD:");
2435 case BLOCK_LAYOUT_STRONG:
2436 printf("BL_STRONG:");
2438 case BLOCK_LAYOUT_BYREF:
2439 printf("BL_BYREF:");
2441 case BLOCK_LAYOUT_WEAK:
2444 case BLOCK_LAYOUT_UNRETAINED:
2445 printf("BL_UNRETAINED:");
2448 // Actual value of word count is one more that what is in the imm.
2449 // field of the instruction
2450 printf("%d", (inst & 0xf) + delta);
2458 llvm::GlobalVariable * Entry =
2459 CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
2460 llvm::ConstantDataArray::getString(VMContext, BitMap,false),
2461 "__TEXT,__objc_classname,cstring_literals", 1, true);
2462 return getConstantGEP(VMContext, Entry, 0, 0);
2465 llvm::Constant *CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2466 const CGBlockInfo &blockInfo) {
2467 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2469 RunSkipBlockVars.clear();
2470 bool hasUnion = false;
2472 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2473 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2474 unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2476 const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2478 // Calculate the basic layout of the block structure.
2479 const llvm::StructLayout *layout =
2480 CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2482 // Ignore the optional 'this' capture: C++ objects are not assumed
2484 if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2485 UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2486 blockInfo.BlockHeaderForcedGapOffset,
2487 blockInfo.BlockHeaderForcedGapSize);
2488 // Walk the captured variables.
2489 for (BlockDecl::capture_const_iterator ci = blockDecl->capture_begin(),
2490 ce = blockDecl->capture_end(); ci != ce; ++ci) {
2491 const VarDecl *variable = ci->getVariable();
2492 QualType type = variable->getType();
2494 const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2496 // Ignore constant captures.
2497 if (capture.isConstant()) continue;
2499 CharUnits fieldOffset =
2500 CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2502 assert(!type->isArrayType() && "array variable should not be caught");
2504 if (const RecordType *record = type->getAs<RecordType>()) {
2505 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2508 CharUnits fieldSize;
2510 fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2512 fieldSize = CGM.getContext().getTypeSizeInChars(type);
2513 UpdateRunSkipBlockVars(ci->isByRef(), getBlockCaptureLifetime(type, false),
2514 fieldOffset, fieldSize);
2516 return getBitmapBlockLayout(false);
2520 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
2522 assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2523 assert(!T->isArrayType() && "__block array variable should not be caught");
2524 CharUnits fieldOffset;
2525 RunSkipBlockVars.clear();
2526 bool hasUnion = false;
2527 if (const RecordType *record = T->getAs<RecordType>()) {
2528 BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
2529 llvm::Constant *Result = getBitmapBlockLayout(true);
2532 llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2536 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
2537 const ObjCProtocolDecl *PD) {
2538 // FIXME: I don't understand why gcc generates this, or where it is
2539 // resolved. Investigate. Its also wasteful to look this up over and over.
2540 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2542 return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
2543 ObjCTypes.getExternalProtocolPtrTy());
2546 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
2547 // FIXME: We shouldn't need this, the protocol decl should contain enough
2548 // information to tell us whether this was a declaration or a definition.
2549 DefinedProtocols.insert(PD->getIdentifier());
2551 // If we have generated a forward reference to this protocol, emit
2552 // it now. Otherwise do nothing, the protocol objects are lazily
2554 if (Protocols.count(PD->getIdentifier()))
2555 GetOrEmitProtocol(PD);
2558 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
2559 if (DefinedProtocols.count(PD->getIdentifier()))
2560 return GetOrEmitProtocol(PD);
2562 return GetOrEmitProtocolRef(PD);
2566 // APPLE LOCAL radar 4585769 - Objective-C 1.0 extensions
2567 struct _objc_protocol {
2568 struct _objc_protocol_extension *isa;
2569 char *protocol_name;
2570 struct _objc_protocol_list *protocol_list;
2571 struct _objc__method_prototype_list *instance_methods;
2572 struct _objc__method_prototype_list *class_methods
2575 See EmitProtocolExtension().
2577 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
2578 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
2580 // Early exit if a defining object has already been generated.
2581 if (Entry && Entry->hasInitializer())
2584 // Use the protocol definition, if there is one.
2585 if (const ObjCProtocolDecl *Def = PD->getDefinition())
2588 // FIXME: I don't understand why gcc generates this, or where it is
2589 // resolved. Investigate. Its also wasteful to look this up over and over.
2590 LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2592 // Construct method lists.
2593 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
2594 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
2595 std::vector<llvm::Constant*> MethodTypesExt, OptMethodTypesExt;
2596 for (ObjCProtocolDecl::instmeth_iterator
2597 i = PD->instmeth_begin(), e = PD->instmeth_end(); i != e; ++i) {
2598 ObjCMethodDecl *MD = *i;
2599 llvm::Constant *C = GetMethodDescriptionConstant(MD);
2601 return GetOrEmitProtocolRef(PD);
2603 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
2604 OptInstanceMethods.push_back(C);
2605 OptMethodTypesExt.push_back(GetMethodVarType(MD, true));
2607 InstanceMethods.push_back(C);
2608 MethodTypesExt.push_back(GetMethodVarType(MD, true));
2612 for (ObjCProtocolDecl::classmeth_iterator
2613 i = PD->classmeth_begin(), e = PD->classmeth_end(); i != e; ++i) {
2614 ObjCMethodDecl *MD = *i;
2615 llvm::Constant *C = GetMethodDescriptionConstant(MD);
2617 return GetOrEmitProtocolRef(PD);
2619 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
2620 OptClassMethods.push_back(C);
2621 OptMethodTypesExt.push_back(GetMethodVarType(MD, true));
2623 ClassMethods.push_back(C);
2624 MethodTypesExt.push_back(GetMethodVarType(MD, true));
2628 MethodTypesExt.insert(MethodTypesExt.end(),
2629 OptMethodTypesExt.begin(), OptMethodTypesExt.end());
2631 llvm::Constant *Values[] = {
2632 EmitProtocolExtension(PD, OptInstanceMethods, OptClassMethods,
2634 GetClassName(PD->getIdentifier()),
2635 EmitProtocolList("\01L_OBJC_PROTOCOL_REFS_" + PD->getName(),
2636 PD->protocol_begin(),
2637 PD->protocol_end()),
2638 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_" + PD->getName(),
2639 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
2641 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_" + PD->getName(),
2642 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2645 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
2649 // Already created, fix the linkage and update the initializer.
2650 Entry->setLinkage(llvm::GlobalValue::InternalLinkage);
2651 Entry->setInitializer(Init);
2654 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, false,
2655 llvm::GlobalValue::InternalLinkage,
2657 "\01L_OBJC_PROTOCOL_" + PD->getName());
2658 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
2659 // FIXME: Is this necessary? Why only for protocol?
2660 Entry->setAlignment(4);
2662 Protocols[PD->getIdentifier()] = Entry;
2664 CGM.AddUsedGlobal(Entry);
2669 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
2670 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
2673 // We use the initializer as a marker of whether this is a forward
2674 // reference or not. At module finalization we add the empty
2675 // contents for protocols which were referenced but never defined.
2677 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy, false,
2678 llvm::GlobalValue::ExternalLinkage,
2680 "\01L_OBJC_PROTOCOL_" + PD->getName());
2681 Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
2682 // FIXME: Is this necessary? Why only for protocol?
2683 Entry->setAlignment(4);
2690 struct _objc_protocol_extension {
2692 struct objc_method_description_list *optional_instance_methods;
2693 struct objc_method_description_list *optional_class_methods;
2694 struct objc_property_list *instance_properties;
2695 const char ** extendedMethodTypes;
2699 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
2700 ArrayRef<llvm::Constant*> OptInstanceMethods,
2701 ArrayRef<llvm::Constant*> OptClassMethods,
2702 ArrayRef<llvm::Constant*> MethodTypesExt) {
2704 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
2705 llvm::Constant *Values[] = {
2706 llvm::ConstantInt::get(ObjCTypes.IntTy, Size),
2707 EmitMethodDescList("\01L_OBJC_PROTOCOL_INSTANCE_METHODS_OPT_"
2709 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
2710 OptInstanceMethods),
2711 EmitMethodDescList("\01L_OBJC_PROTOCOL_CLASS_METHODS_OPT_" + PD->getName(),
2712 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2714 EmitPropertyList("\01L_OBJC_$_PROP_PROTO_LIST_" + PD->getName(), 0, PD,
2716 EmitProtocolMethodTypes("\01L_OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
2717 MethodTypesExt, ObjCTypes)
2720 // Return null if no extension bits are used.
2721 if (Values[1]->isNullValue() && Values[2]->isNullValue() &&
2722 Values[3]->isNullValue() && Values[4]->isNullValue())
2723 return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
2725 llvm::Constant *Init =
2726 llvm::ConstantStruct::get(ObjCTypes.ProtocolExtensionTy, Values);
2728 // No special section, but goes in llvm.used
2729 return CreateMetadataVar("\01L_OBJC_PROTOCOLEXT_" + PD->getName(),
2735 struct objc_protocol_list {
2736 struct objc_protocol_list *next;
2742 CGObjCMac::EmitProtocolList(Twine Name,
2743 ObjCProtocolDecl::protocol_iterator begin,
2744 ObjCProtocolDecl::protocol_iterator end) {
2745 SmallVector<llvm::Constant *, 16> ProtocolRefs;
2747 for (; begin != end; ++begin)
2748 ProtocolRefs.push_back(GetProtocolRef(*begin));
2750 // Just return null for empty protocol lists
2751 if (ProtocolRefs.empty())
2752 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
2754 // This list is null terminated.
2755 ProtocolRefs.push_back(llvm::Constant::getNullValue(ObjCTypes.ProtocolPtrTy));
2757 llvm::Constant *Values[3];
2758 // This field is only used by the runtime.
2759 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
2760 Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy,
2761 ProtocolRefs.size() - 1);
2763 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolPtrTy,
2764 ProtocolRefs.size()),
2767 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
2768 llvm::GlobalVariable *GV =
2769 CreateMetadataVar(Name, Init, "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2771 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
2774 void CGObjCCommonMac::
2775 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
2776 SmallVectorImpl<llvm::Constant *> &Properties,
2777 const Decl *Container,
2778 const ObjCProtocolDecl *PROTO,
2779 const ObjCCommonTypesHelper &ObjCTypes) {
2780 for (ObjCProtocolDecl::protocol_iterator P = PROTO->protocol_begin(),
2781 E = PROTO->protocol_end(); P != E; ++P)
2782 PushProtocolProperties(PropertySet, Properties, Container, (*P), ObjCTypes);
2783 for (ObjCContainerDecl::prop_iterator I = PROTO->prop_begin(),
2784 E = PROTO->prop_end(); I != E; ++I) {
2785 const ObjCPropertyDecl *PD = *I;
2786 if (!PropertySet.insert(PD->getIdentifier()))
2788 llvm::Constant *Prop[] = {
2789 GetPropertyName(PD->getIdentifier()),
2790 GetPropertyTypeString(PD, Container)
2792 Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy, Prop));
2797 struct _objc_property {
2798 const char * const name;
2799 const char * const attributes;
2802 struct _objc_property_list {
2803 uint32_t entsize; // sizeof (struct _objc_property)
2804 uint32_t prop_count;
2805 struct _objc_property[prop_count];
2808 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
2809 const Decl *Container,
2810 const ObjCContainerDecl *OCD,
2811 const ObjCCommonTypesHelper &ObjCTypes) {
2812 SmallVector<llvm::Constant *, 16> Properties;
2813 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
2814 for (ObjCContainerDecl::prop_iterator I = OCD->prop_begin(),
2815 E = OCD->prop_end(); I != E; ++I) {
2816 const ObjCPropertyDecl *PD = *I;
2817 PropertySet.insert(PD->getIdentifier());
2818 llvm::Constant *Prop[] = {
2819 GetPropertyName(PD->getIdentifier()),
2820 GetPropertyTypeString(PD, Container)
2822 Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy,
2825 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
2826 for (ObjCInterfaceDecl::all_protocol_iterator
2827 P = OID->all_referenced_protocol_begin(),
2828 E = OID->all_referenced_protocol_end(); P != E; ++P)
2829 PushProtocolProperties(PropertySet, Properties, Container, (*P),
2832 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
2833 for (ObjCCategoryDecl::protocol_iterator P = CD->protocol_begin(),
2834 E = CD->protocol_end(); P != E; ++P)
2835 PushProtocolProperties(PropertySet, Properties, Container, (*P),
2839 // Return null for empty list.
2840 if (Properties.empty())
2841 return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
2843 unsigned PropertySize =
2844 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
2845 llvm::Constant *Values[3];
2846 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, PropertySize);
2847 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Properties.size());
2848 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.PropertyTy,
2850 Values[2] = llvm::ConstantArray::get(AT, Properties);
2851 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
2853 llvm::GlobalVariable *GV =
2854 CreateMetadataVar(Name, Init,
2855 (ObjCABI == 2) ? "__DATA, __objc_const" :
2856 "__OBJC,__property,regular,no_dead_strip",
2857 (ObjCABI == 2) ? 8 : 4,
2859 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
2863 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
2864 ArrayRef<llvm::Constant*> MethodTypes,
2865 const ObjCCommonTypesHelper &ObjCTypes) {
2866 // Return null for empty list.
2867 if (MethodTypes.empty())
2868 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
2870 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
2871 MethodTypes.size());
2872 llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
2874 llvm::GlobalVariable *GV =
2875 CreateMetadataVar(Name, Init,
2876 (ObjCABI == 2) ? "__DATA, __objc_const" : 0,
2877 (ObjCABI == 2) ? 8 : 4,
2879 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
2883 struct objc_method_description_list {
2885 struct objc_method_description list[];
2889 CGObjCMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
2890 llvm::Constant *Desc[] = {
2891 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
2892 ObjCTypes.SelectorPtrTy),
2893 GetMethodVarType(MD)
2898 return llvm::ConstantStruct::get(ObjCTypes.MethodDescriptionTy,
2903 CGObjCMac::EmitMethodDescList(Twine Name, const char *Section,
2904 ArrayRef<llvm::Constant*> Methods) {
2905 // Return null for empty list.
2906 if (Methods.empty())
2907 return llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
2909 llvm::Constant *Values[2];
2910 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
2911 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodDescriptionTy,
2913 Values[1] = llvm::ConstantArray::get(AT, Methods);
2914 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
2916 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 4, true);
2917 return llvm::ConstantExpr::getBitCast(GV,
2918 ObjCTypes.MethodDescriptionListPtrTy);
2922 struct _objc_category {
2923 char *category_name;
2925 struct _objc_method_list *instance_methods;
2926 struct _objc_method_list *class_methods;
2927 struct _objc_protocol_list *protocols;
2928 uint32_t size; // <rdar://4585769>
2929 struct _objc_property_list *instance_properties;
2932 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
2933 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
2935 // FIXME: This is poor design, the OCD should have a pointer to the category
2936 // decl. Additionally, note that Category can be null for the @implementation
2937 // w/o an @interface case. Sema should just create one for us as it does for
2938 // @implementation so everyone else can live life under a clear blue sky.
2939 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
2940 const ObjCCategoryDecl *Category =
2941 Interface->FindCategoryDeclaration(OCD->getIdentifier());
2943 SmallString<256> ExtName;
2944 llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
2947 SmallVector<llvm::Constant *, 16> InstanceMethods, ClassMethods;
2948 for (ObjCCategoryImplDecl::instmeth_iterator
2949 i = OCD->instmeth_begin(), e = OCD->instmeth_end(); i != e; ++i) {
2950 // Instance methods should always be defined.
2951 InstanceMethods.push_back(GetMethodConstant(*i));
2953 for (ObjCCategoryImplDecl::classmeth_iterator
2954 i = OCD->classmeth_begin(), e = OCD->classmeth_end(); i != e; ++i) {
2955 // Class methods should always be defined.
2956 ClassMethods.push_back(GetMethodConstant(*i));
2959 llvm::Constant *Values[7];
2960 Values[0] = GetClassName(OCD->getIdentifier());
2961 Values[1] = GetClassName(Interface->getIdentifier());
2962 LazySymbols.insert(Interface->getIdentifier());
2964 EmitMethodList("\01L_OBJC_CATEGORY_INSTANCE_METHODS_" + ExtName.str(),
2965 "__OBJC,__cat_inst_meth,regular,no_dead_strip",
2968 EmitMethodList("\01L_OBJC_CATEGORY_CLASS_METHODS_" + ExtName.str(),
2969 "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2973 EmitProtocolList("\01L_OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
2974 Category->protocol_begin(),
2975 Category->protocol_end());
2977 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
2979 Values[5] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
2981 // If there is no category @interface then there can be no properties.
2983 Values[6] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
2984 OCD, Category, ObjCTypes);
2986 Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
2989 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.CategoryTy,
2992 llvm::GlobalVariable *GV =
2993 CreateMetadataVar("\01L_OBJC_CATEGORY_" + ExtName.str(), Init,
2994 "__OBJC,__category,regular,no_dead_strip",
2996 DefinedCategories.push_back(GV);
2997 DefinedCategoryNames.insert(ExtName.str());
2998 // method definition entries must be clear for next implementation.
2999 MethodDefinitions.clear();
3002 enum FragileClassFlags {
3003 FragileABI_Class_Factory = 0x00001,
3004 FragileABI_Class_Meta = 0x00002,
3005 FragileABI_Class_HasCXXStructors = 0x02000,
3006 FragileABI_Class_Hidden = 0x20000
3009 enum NonFragileClassFlags {
3010 /// Is a meta-class.
3011 NonFragileABI_Class_Meta = 0x00001,
3013 /// Is a root class.
3014 NonFragileABI_Class_Root = 0x00002,
3016 /// Has a C++ constructor and destructor.
3017 NonFragileABI_Class_HasCXXStructors = 0x00004,
3019 /// Has hidden visibility.
3020 NonFragileABI_Class_Hidden = 0x00010,
3022 /// Has the exception attribute.
3023 NonFragileABI_Class_Exception = 0x00020,
3025 /// (Obsolete) ARC-specific: this class has a .release_ivars method
3026 NonFragileABI_Class_HasIvarReleaser = 0x00040,
3028 /// Class implementation was compiled under ARC.
3029 NonFragileABI_Class_CompiledByARC = 0x00080,
3031 /// Class has non-trivial destructors, but zero-initialization is okay.
3032 NonFragileABI_Class_HasCXXDestructorOnly = 0x00100
3036 struct _objc_class {
3043 struct _objc_ivar_list *ivars;
3044 struct _objc_method_list *methods;
3045 struct _objc_cache *cache;
3046 struct _objc_protocol_list *protocols;
3047 // Objective-C 1.0 extensions (<rdr://4585769>)
3048 const char *ivar_layout;
3049 struct _objc_class_ext *ext;
3052 See EmitClassExtension();
3054 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3055 DefinedSymbols.insert(ID->getIdentifier());
3057 std::string ClassName = ID->getNameAsString();
3059 ObjCInterfaceDecl *Interface =
3060 const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3061 llvm::Constant *Protocols =
3062 EmitProtocolList("\01L_OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3063 Interface->all_referenced_protocol_begin(),
3064 Interface->all_referenced_protocol_end());
3065 unsigned Flags = FragileABI_Class_Factory;
3066 if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3067 Flags |= FragileABI_Class_HasCXXStructors;
3069 CGM.getContext().getASTObjCImplementationLayout(ID).getSize().getQuantity();
3071 // FIXME: Set CXX-structors flag.
3072 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3073 Flags |= FragileABI_Class_Hidden;
3075 SmallVector<llvm::Constant *, 16> InstanceMethods, ClassMethods;
3076 for (ObjCImplementationDecl::instmeth_iterator
3077 i = ID->instmeth_begin(), e = ID->instmeth_end(); i != e; ++i) {
3078 // Instance methods should always be defined.
3079 InstanceMethods.push_back(GetMethodConstant(*i));
3081 for (ObjCImplementationDecl::classmeth_iterator
3082 i = ID->classmeth_begin(), e = ID->classmeth_end(); i != e; ++i) {
3083 // Class methods should always be defined.
3084 ClassMethods.push_back(GetMethodConstant(*i));
3087 for (ObjCImplementationDecl::propimpl_iterator
3088 i = ID->propimpl_begin(), e = ID->propimpl_end(); i != e; ++i) {
3089 ObjCPropertyImplDecl *PID = *i;
3091 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3092 ObjCPropertyDecl *PD = PID->getPropertyDecl();
3094 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
3095 if (llvm::Constant *C = GetMethodConstant(MD))
3096 InstanceMethods.push_back(C);
3097 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
3098 if (llvm::Constant *C = GetMethodConstant(MD))
3099 InstanceMethods.push_back(C);
3103 llvm::Constant *Values[12];
3104 Values[ 0] = EmitMetaClass(ID, Protocols, ClassMethods);
3105 if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3106 // Record a reference to the super class.
3107 LazySymbols.insert(Super->getIdentifier());
3110 llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
3111 ObjCTypes.ClassPtrTy);
3113 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
3115 Values[ 2] = GetClassName(ID->getIdentifier());
3116 // Version is always 0.
3117 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
3118 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
3119 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
3120 Values[ 6] = EmitIvarList(ID, false);
3122 EmitMethodList("\01L_OBJC_INSTANCE_METHODS_" + ID->getName(),
3123 "__OBJC,__inst_meth,regular,no_dead_strip",
3125 // cache is always NULL.
3126 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
3127 Values[ 9] = Protocols;
3128 Values[10] = BuildIvarLayout(ID, true);
3129 Values[11] = EmitClassExtension(ID);
3130 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
3132 std::string Name("\01L_OBJC_CLASS_");
3134 const char *Section = "__OBJC,__class,regular,no_dead_strip";
3135 // Check for a forward reference.
3136 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
3138 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3139 "Forward metaclass reference has incorrect type.");
3140 GV->setLinkage(llvm::GlobalValue::InternalLinkage);
3141 GV->setInitializer(Init);
3142 GV->setSection(Section);
3143 GV->setAlignment(4);
3144 CGM.AddUsedGlobal(GV);
3147 GV = CreateMetadataVar(Name, Init, Section, 4, true);
3148 DefinedClasses.push_back(GV);
3149 // method definition entries must be clear for next implementation.
3150 MethodDefinitions.clear();
3153 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3154 llvm::Constant *Protocols,
3155 ArrayRef<llvm::Constant*> Methods) {
3156 unsigned Flags = FragileABI_Class_Meta;
3157 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3159 if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3160 Flags |= FragileABI_Class_Hidden;
3162 llvm::Constant *Values[12];
3163 // The isa for the metaclass is the root of the hierarchy.
3164 const ObjCInterfaceDecl *Root = ID->getClassInterface();
3165 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3168 llvm::ConstantExpr::getBitCast(GetClassName(Root->getIdentifier()),
3169 ObjCTypes.ClassPtrTy);
3170 // The super class for the metaclass is emitted as the name of the
3171 // super class. The runtime fixes this up to point to the
3172 // *metaclass* for the super class.
3173 if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3175 llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
3176 ObjCTypes.ClassPtrTy);
3178 Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
3180 Values[ 2] = GetClassName(ID->getIdentifier());
3181 // Version is always 0.
3182 Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
3183 Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
3184 Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
3185 Values[ 6] = EmitIvarList(ID, true);
3187 EmitMethodList("\01L_OBJC_CLASS_METHODS_" + ID->getNameAsString(),
3188 "__OBJC,__cls_meth,regular,no_dead_strip",
3190 // cache is always NULL.
3191 Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
3192 Values[ 9] = Protocols;
3193 // ivar_layout for metaclass is always NULL.
3194 Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
3195 // The class extension is always unused for metaclasses.
3196 Values[11] = llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3197 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
3200 std::string Name("\01L_OBJC_METACLASS_");
3201 Name += ID->getName();
3203 // Check for a forward reference.
3204 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
3206 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3207 "Forward metaclass reference has incorrect type.");
3208 GV->setLinkage(llvm::GlobalValue::InternalLinkage);
3209 GV->setInitializer(Init);
3211 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3212 llvm::GlobalValue::InternalLinkage,
3215 GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3216 GV->setAlignment(4);
3217 CGM.AddUsedGlobal(GV);
3222 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3223 std::string Name = "\01L_OBJC_METACLASS_" + ID->getNameAsString();
3225 // FIXME: Should we look these up somewhere other than the module. Its a bit
3226 // silly since we only generate these while processing an implementation, so
3227 // exactly one pointer would work if know when we entered/exitted an
3228 // implementation block.
3230 // Check for an existing forward reference.
3231 // Previously, metaclass with internal linkage may have been defined.
3232 // pass 'true' as 2nd argument so it is returned.
3233 if (llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name,
3235 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3236 "Forward metaclass reference has incorrect type.");
3239 // Generate as an external reference to keep a consistent
3240 // module. This will be patched up when we emit the metaclass.
3241 return new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3242 llvm::GlobalValue::ExternalLinkage,
3248 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3249 std::string Name = "\01L_OBJC_CLASS_" + ID->getNameAsString();
3251 if (llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name,
3253 assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3254 "Forward class metadata reference has incorrect type.");
3257 return new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3258 llvm::GlobalValue::ExternalLinkage,
3265 struct objc_class_ext {
3267 const char *weak_ivar_layout;
3268 struct _objc_property_list *properties;
3272 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID) {
3274 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3276 llvm::Constant *Values[3];
3277 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
3278 Values[1] = BuildIvarLayout(ID, false);
3279 Values[2] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getName(),
3280 ID, ID->getClassInterface(), ObjCTypes);
3282 // Return null if no extension bits are used.
3283 if (Values[1]->isNullValue() && Values[2]->isNullValue())
3284 return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3286 llvm::Constant *Init =
3287 llvm::ConstantStruct::get(ObjCTypes.ClassExtensionTy, Values);
3288 return CreateMetadataVar("\01L_OBJC_CLASSEXT_" + ID->getName(),
3289 Init, "__OBJC,__class_ext,regular,no_dead_strip",
3300 struct objc_ivar_list {
3302 struct objc_ivar list[count];
3305 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3307 std::vector<llvm::Constant*> Ivars;
3309 // When emitting the root class GCC emits ivar entries for the
3310 // actual class structure. It is not clear if we need to follow this
3311 // behavior; for now lets try and get away with not doing it. If so,
3312 // the cleanest solution would be to make up an ObjCInterfaceDecl
3315 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3317 const ObjCInterfaceDecl *OID = ID->getClassInterface();
3319 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3320 IVD; IVD = IVD->getNextIvar()) {
3321 // Ignore unnamed bit-fields.
3322 if (!IVD->getDeclName())
3324 llvm::Constant *Ivar[] = {
3325 GetMethodVarName(IVD->getIdentifier()),
3326 GetMethodVarType(IVD),
3327 llvm::ConstantInt::get(ObjCTypes.IntTy,
3328 ComputeIvarBaseOffset(CGM, OID, IVD))
3330 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarTy, Ivar));
3333 // Return null for empty list.
3335 return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3337 llvm::Constant *Values[2];
3338 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
3339 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarTy,
3341 Values[1] = llvm::ConstantArray::get(AT, Ivars);
3342 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
3344 llvm::GlobalVariable *GV;
3346 GV = CreateMetadataVar("\01L_OBJC_CLASS_VARIABLES_" + ID->getName(),
3347 Init, "__OBJC,__class_vars,regular,no_dead_strip",
3350 GV = CreateMetadataVar("\01L_OBJC_INSTANCE_VARIABLES_" + ID->getName(),
3351 Init, "__OBJC,__instance_vars,regular,no_dead_strip",
3353 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3357 struct objc_method {
3363 struct objc_method_list {
3364 struct objc_method_list *obsolete;
3366 struct objc_method methods_list[count];
3370 /// GetMethodConstant - Return a struct objc_method constant for the
3371 /// given method if it has been defined. The result is null if the
3372 /// method has not been defined. The return value has type MethodPtrTy.
3373 llvm::Constant *CGObjCMac::GetMethodConstant(const ObjCMethodDecl *MD) {
3374 llvm::Function *Fn = GetMethodDefinition(MD);
3378 llvm::Constant *Method[] = {
3379 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
3380 ObjCTypes.SelectorPtrTy),
3381 GetMethodVarType(MD),
3382 llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy)
3384 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
3387 llvm::Constant *CGObjCMac::EmitMethodList(Twine Name,
3388 const char *Section,
3389 ArrayRef<llvm::Constant*> Methods) {
3390 // Return null for empty list.
3391 if (Methods.empty())
3392 return llvm::Constant::getNullValue(ObjCTypes.MethodListPtrTy);
3394 llvm::Constant *Values[3];
3395 Values[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
3396 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
3397 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
3399 Values[2] = llvm::ConstantArray::get(AT, Methods);
3400 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
3402 llvm::GlobalVariable *GV = CreateMetadataVar(Name, Init, Section, 4, true);
3403 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
3406 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
3407 const ObjCContainerDecl *CD) {
3408 SmallString<256> Name;
3409 GetNameForMethod(OMD, CD, Name);
3411 CodeGenTypes &Types = CGM.getTypes();
3412 llvm::FunctionType *MethodTy =
3413 Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
3414 llvm::Function *Method =
3415 llvm::Function::Create(MethodTy,
3416 llvm::GlobalValue::InternalLinkage,
3419 MethodDefinitions.insert(std::make_pair(OMD, Method));
3424 llvm::GlobalVariable *
3425 CGObjCCommonMac::CreateMetadataVar(Twine Name,
3426 llvm::Constant *Init,
3427 const char *Section,
3430 llvm::Type *Ty = Init->getType();
3431 llvm::GlobalVariable *GV =
3432 new llvm::GlobalVariable(CGM.getModule(), Ty, false,
3433 llvm::GlobalValue::InternalLinkage, Init, Name);
3435 GV->setSection(Section);
3437 GV->setAlignment(Align);
3439 CGM.AddUsedGlobal(GV);
3443 llvm::Function *CGObjCMac::ModuleInitFunction() {
3444 // Abuse this interface function as a place to finalize.
3449 llvm::Constant *CGObjCMac::GetPropertyGetFunction() {
3450 return ObjCTypes.getGetPropertyFn();
3453 llvm::Constant *CGObjCMac::GetPropertySetFunction() {
3454 return ObjCTypes.getSetPropertyFn();
3457 llvm::Constant *CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
3459 return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
3462 llvm::Constant *CGObjCMac::GetGetStructFunction() {
3463 return ObjCTypes.getCopyStructFn();
3465 llvm::Constant *CGObjCMac::GetSetStructFunction() {
3466 return ObjCTypes.getCopyStructFn();
3469 llvm::Constant *CGObjCMac::GetCppAtomicObjectGetFunction() {
3470 return ObjCTypes.getCppAtomicObjectFunction();
3472 llvm::Constant *CGObjCMac::GetCppAtomicObjectSetFunction() {
3473 return ObjCTypes.getCppAtomicObjectFunction();
3476 llvm::Constant *CGObjCMac::EnumerationMutationFunction() {
3477 return ObjCTypes.getEnumerationMutationFn();
3480 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
3481 return EmitTryOrSynchronizedStmt(CGF, S);
3484 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
3485 const ObjCAtSynchronizedStmt &S) {
3486 return EmitTryOrSynchronizedStmt(CGF, S);
3490 struct PerformFragileFinally : EHScopeStack::Cleanup {
3492 llvm::Value *SyncArgSlot;
3493 llvm::Value *CallTryExitVar;
3494 llvm::Value *ExceptionData;
3495 ObjCTypesHelper &ObjCTypes;
3496 PerformFragileFinally(const Stmt *S,
3497 llvm::Value *SyncArgSlot,
3498 llvm::Value *CallTryExitVar,
3499 llvm::Value *ExceptionData,
3500 ObjCTypesHelper *ObjCTypes)
3501 : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
3502 ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
3504 void Emit(CodeGenFunction &CGF, Flags flags) {
3505 // Check whether we need to call objc_exception_try_exit.
3506 // In optimized code, this branch will always be folded.
3507 llvm::BasicBlock *FinallyCallExit =
3508 CGF.createBasicBlock("finally.call_exit");
3509 llvm::BasicBlock *FinallyNoCallExit =
3510 CGF.createBasicBlock("finally.no_call_exit");
3511 CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
3512 FinallyCallExit, FinallyNoCallExit);
3514 CGF.EmitBlock(FinallyCallExit);
3515 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
3518 CGF.EmitBlock(FinallyNoCallExit);
3520 if (isa<ObjCAtTryStmt>(S)) {
3521 if (const ObjCAtFinallyStmt* FinallyStmt =
3522 cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
3523 // Don't try to do the @finally if this is an EH cleanup.
3524 if (flags.isForEHCleanup()) return;
3526 // Save the current cleanup destination in case there's
3527 // control flow inside the finally statement.
3528 llvm::Value *CurCleanupDest =
3529 CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
3531 CGF.EmitStmt(FinallyStmt->getFinallyBody());
3533 if (CGF.HaveInsertPoint()) {
3534 CGF.Builder.CreateStore(CurCleanupDest,
3535 CGF.getNormalCleanupDestSlot());
3537 // Currently, the end of the cleanup must always exist.
3538 CGF.EnsureInsertPoint();
3542 // Emit objc_sync_exit(expr); as finally's sole statement for
3544 llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
3545 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
3550 class FragileHazards {
3551 CodeGenFunction &CGF;
3552 SmallVector<llvm::Value*, 20> Locals;
3553 llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
3555 llvm::InlineAsm *ReadHazard;
3556 llvm::InlineAsm *WriteHazard;
3558 llvm::FunctionType *GetAsmFnType();
3560 void collectLocals();
3561 void emitReadHazard(CGBuilderTy &Builder);
3564 FragileHazards(CodeGenFunction &CGF);
3566 void emitWriteHazard();
3567 void emitHazardsInNewBlocks();
3571 /// Create the fragile-ABI read and write hazards based on the current
3572 /// state of the function, which is presumed to be immediately prior
3573 /// to a @try block. These hazards are used to maintain correct
3574 /// semantics in the face of optimization and the fragile ABI's
3575 /// cavalier use of setjmp/longjmp.
3576 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
3579 if (Locals.empty()) return;
3581 // Collect all the blocks in the function.
3582 for (llvm::Function::iterator
3583 I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
3584 BlocksBeforeTry.insert(&*I);
3586 llvm::FunctionType *AsmFnTy = GetAsmFnType();
3588 // Create a read hazard for the allocas. This inhibits dead-store
3589 // optimizations and forces the values to memory. This hazard is
3590 // inserted before any 'throwing' calls in the protected scope to
3591 // reflect the possibility that the variables might be read from the
3592 // catch block if the call throws.
3594 std::string Constraint;
3595 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
3596 if (I) Constraint += ',';
3600 ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
3603 // Create a write hazard for the allocas. This inhibits folding
3604 // loads across the hazard. This hazard is inserted at the
3605 // beginning of the catch path to reflect the possibility that the
3606 // variables might have been written within the protected scope.
3608 std::string Constraint;
3609 for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
3610 if (I) Constraint += ',';
3611 Constraint += "=*m";
3614 WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
3618 /// Emit a write hazard at the current location.
3619 void FragileHazards::emitWriteHazard() {
3620 if (Locals.empty()) return;
3622 CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
3625 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
3626 assert(!Locals.empty());
3627 llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
3628 call->setDoesNotThrow();
3629 call->setCallingConv(CGF.getRuntimeCC());
3632 /// Emit read hazards in all the protected blocks, i.e. all the blocks
3633 /// which have been inserted since the beginning of the try.
3634 void FragileHazards::emitHazardsInNewBlocks() {
3635 if (Locals.empty()) return;
3637 CGBuilderTy Builder(CGF.getLLVMContext());
3639 // Iterate through all blocks, skipping those prior to the try.
3640 for (llvm::Function::iterator
3641 FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
3642 llvm::BasicBlock &BB = *FI;
3643 if (BlocksBeforeTry.count(&BB)) continue;
3645 // Walk through all the calls in the block.
3646 for (llvm::BasicBlock::iterator
3647 BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
3648 llvm::Instruction &I = *BI;
3650 // Ignore instructions that aren't non-intrinsic calls.
3651 // These are the only calls that can possibly call longjmp.
3652 if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) continue;
3653 if (isa<llvm::IntrinsicInst>(I))
3656 // Ignore call sites marked nounwind. This may be questionable,
3657 // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
3658 llvm::CallSite CS(&I);
3659 if (CS.doesNotThrow()) continue;
3661 // Insert a read hazard before the call. This will ensure that
3662 // any writes to the locals are performed before making the
3663 // call. If the call throws, then this is sufficient to
3664 // guarantee correctness as long as it doesn't also write to any
3666 Builder.SetInsertPoint(&BB, BI);
3667 emitReadHazard(Builder);
3672 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, llvm::Value *V) {
3676 void FragileHazards::collectLocals() {
3677 // Compute a set of allocas to ignore.
3678 llvm::DenseSet<llvm::Value*> AllocasToIgnore;
3679 addIfPresent(AllocasToIgnore, CGF.ReturnValue);
3680 addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
3682 // Collect all the allocas currently in the function. This is
3683 // probably way too aggressive.
3684 llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
3685 for (llvm::BasicBlock::iterator
3686 I = Entry.begin(), E = Entry.end(); I != E; ++I)
3687 if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
3688 Locals.push_back(&*I);
3691 llvm::FunctionType *FragileHazards::GetAsmFnType() {
3692 SmallVector<llvm::Type *, 16> tys(Locals.size());
3693 for (unsigned i = 0, e = Locals.size(); i != e; ++i)
3694 tys[i] = Locals[i]->getType();
3695 return llvm::FunctionType::get(CGF.VoidTy, tys, false);
3700 Objective-C setjmp-longjmp (sjlj) Exception Handling
3703 A catch buffer is a setjmp buffer plus:
3704 - a pointer to the exception that was caught
3705 - a pointer to the previous exception data buffer
3706 - two pointers of reserved storage
3707 Therefore catch buffers form a stack, with a pointer to the top
3708 of the stack kept in thread-local storage.
3710 objc_exception_try_enter pushes a catch buffer onto the EH stack.
3711 objc_exception_try_exit pops the given catch buffer, which is
3712 required to be the top of the EH stack.
3713 objc_exception_throw pops the top of the EH stack, writes the
3714 thrown exception into the appropriate field, and longjmps
3715 to the setjmp buffer. It crashes the process (with a printf
3716 and an abort()) if there are no catch buffers on the stack.
3717 objc_exception_extract just reads the exception pointer out of the
3720 There's no reason an implementation couldn't use a light-weight
3721 setjmp here --- something like __builtin_setjmp, but API-compatible
3722 with the heavyweight setjmp. This will be more important if we ever
3723 want to implement correct ObjC/C++ exception interactions for the
3726 Note that for this use of setjmp/longjmp to be correct, we may need
3727 to mark some local variables volatile: if a non-volatile local
3728 variable is modified between the setjmp and the longjmp, it has
3729 indeterminate value. For the purposes of LLVM IR, it may be
3730 sufficient to make loads and stores within the @try (to variables
3731 declared outside the @try) volatile. This is necessary for
3732 optimized correctness, but is not currently being done; this is
3733 being tracked as rdar://problem/8160285
3735 The basic framework for a @try-catch-finally is as follows:
3737 objc_exception_data d;
3739 bool _call_try_exit = true;
3741 objc_exception_try_enter(&d);
3742 if (!setjmp(d.jmp_buf)) {
3746 id _caught = objc_exception_extract(&d);
3748 // enter new try scope for handlers
3749 if (!setjmp(d.jmp_buf)) {
3750 ... match exception and execute catch blocks ...
3752 // fell off end, rethrow.
3754 ... jump-through-finally to finally_rethrow ...
3756 // exception in catch block
3757 _rethrow = objc_exception_extract(&d);
3758 _call_try_exit = false;
3759 ... jump-through-finally to finally_rethrow ...
3762 ... jump-through-finally to finally_end ...
3766 objc_exception_try_exit(&d);
3768 ... finally block ....
3769 ... dispatch to finally destination ...
3772 objc_exception_throw(_rethrow);
3777 This framework differs slightly from the one gcc uses, in that gcc
3778 uses _rethrow to determine if objc_exception_try_exit should be called
3779 and if the object should be rethrown. This breaks in the face of
3780 throwing nil and introduces unnecessary branches.
3782 We specialize this framework for a few particular circumstances:
3784 - If there are no catch blocks, then we avoid emitting the second
3785 exception handling context.
3787 - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
3788 e)) we avoid emitting the code to rethrow an uncaught exception.
3790 - FIXME: If there is no @finally block we can do a few more
3793 Rethrows and Jumps-Through-Finally
3796 '@throw;' is supported by pushing the currently-caught exception
3797 onto ObjCEHStack while the @catch blocks are emitted.
3799 Branches through the @finally block are handled with an ordinary
3800 normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
3801 exceptions are not compatible with C++ exceptions, and this is
3802 hardly the only place where this will go wrong.
3804 @synchronized(expr) { stmt; } is emitted as if it were:
3805 id synch_value = expr;
3806 objc_sync_enter(synch_value);
3807 @try { stmt; } @finally { objc_sync_exit(synch_value); }
3810 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
3812 bool isTry = isa<ObjCAtTryStmt>(S);
3814 // A destination for the fall-through edges of the catch handlers to
3816 CodeGenFunction::JumpDest FinallyEnd =
3817 CGF.getJumpDestInCurrentScope("finally.end");
3819 // A destination for the rethrow edge of the catch handlers to jump
3821 CodeGenFunction::JumpDest FinallyRethrow =
3822 CGF.getJumpDestInCurrentScope("finally.rethrow");
3824 // For @synchronized, call objc_sync_enter(sync.expr). The
3825 // evaluation of the expression must occur before we enter the
3826 // @synchronized. We can't avoid a temp here because we need the
3827 // value to be preserved. If the backend ever does liveness
3828 // correctly after setjmp, this will be unnecessary.
3829 llvm::Value *SyncArgSlot = 0;
3831 llvm::Value *SyncArg =
3832 CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
3833 SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
3834 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
3836 SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(), "sync.arg");
3837 CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
3840 // Allocate memory for the setjmp buffer. This needs to be kept
3841 // live throughout the try and catch blocks.
3842 llvm::Value *ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
3843 "exceptiondata.ptr");
3845 // Create the fragile hazards. Note that this will not capture any
3846 // of the allocas required for exception processing, but will
3847 // capture the current basic block (which extends all the way to the
3848 // setjmp call) as "before the @try".
3849 FragileHazards Hazards(CGF);
3851 // Create a flag indicating whether the cleanup needs to call
3852 // objc_exception_try_exit. This is true except when
3853 // - no catches match and we're branching through the cleanup
3854 // just to rethrow the exception, or
3855 // - a catch matched and we're falling out of the catch handler.
3856 // The setjmp-safety rule here is that we should always store to this
3857 // variable in a place that dominates the branch through the cleanup
3858 // without passing through any setjmps.
3859 llvm::Value *CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
3862 // A slot containing the exception to rethrow. Only needed when we
3863 // have both a @catch and a @finally.
3864 llvm::Value *PropagatingExnVar = 0;
3866 // Push a normal cleanup to leave the try scope.
3867 CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
3873 // Enter a try block:
3874 // - Call objc_exception_try_enter to push ExceptionData on top of
3876 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(), ExceptionData);
3878 // - Call setjmp on the exception data buffer.
3879 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
3880 llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
3881 llvm::Value *SetJmpBuffer =
3882 CGF.Builder.CreateGEP(ExceptionData, GEPIndexes, "setjmp_buffer");
3883 llvm::CallInst *SetJmpResult =
3884 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
3885 SetJmpResult->setCanReturnTwice();
3887 // If setjmp returned 0, enter the protected block; otherwise,
3888 // branch to the handler.
3889 llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
3890 llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
3891 llvm::Value *DidCatch =
3892 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
3893 CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
3895 // Emit the protected block.
3896 CGF.EmitBlock(TryBlock);
3897 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
3898 CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
3899 : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
3901 CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
3903 // Emit the exception handler block.
3904 CGF.EmitBlock(TryHandler);
3906 // Don't optimize loads of the in-scope locals across this point.
3907 Hazards.emitWriteHazard();
3909 // For a @synchronized (or a @try with no catches), just branch
3910 // through the cleanup to the rethrow block.
3911 if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
3912 // Tell the cleanup not to re-pop the exit.
3913 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
3914 CGF.EmitBranchThroughCleanup(FinallyRethrow);
3916 // Otherwise, we have to match against the caught exceptions.
3918 // Retrieve the exception object. We may emit multiple blocks but
3919 // nothing can cross this so the value is already in SSA form.
3920 llvm::CallInst *Caught =
3921 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
3922 ExceptionData, "caught");
3924 // Push the exception to rethrow onto the EH value stack for the
3925 // benefit of any @throws in the handlers.
3926 CGF.ObjCEHValueStack.push_back(Caught);
3928 const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
3930 bool HasFinally = (AtTryStmt->getFinallyStmt() != 0);
3932 llvm::BasicBlock *CatchBlock = 0;
3933 llvm::BasicBlock *CatchHandler = 0;
3935 // Save the currently-propagating exception before
3936 // objc_exception_try_enter clears the exception slot.
3937 PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
3938 "propagating_exception");
3939 CGF.Builder.CreateStore(Caught, PropagatingExnVar);
3941 // Enter a new exception try block (in case a @catch block
3942 // throws an exception).
3943 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
3946 llvm::CallInst *SetJmpResult =
3947 CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
3948 SetJmpBuffer, "setjmp.result");
3949 SetJmpResult->setCanReturnTwice();
3951 llvm::Value *Threw =
3952 CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
3954 CatchBlock = CGF.createBasicBlock("catch");
3955 CatchHandler = CGF.createBasicBlock("catch_for_catch");
3956 CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
3958 CGF.EmitBlock(CatchBlock);
3961 CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
3963 // Handle catch list. As a special case we check if everything is
3964 // matched and avoid generating code for falling off the end if
3966 bool AllMatched = false;
3967 for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
3968 const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
3970 const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
3971 const ObjCObjectPointerType *OPT = 0;
3973 // catch(...) always matches.
3977 OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
3979 // catch(id e) always matches under this ABI, since only
3980 // ObjC exceptions end up here in the first place.
3981 // FIXME: For the time being we also match id<X>; this should
3982 // be rejected by Sema instead.
3983 if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
3987 // If this is a catch-all, we don't need to test anything.
3989 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
3992 CGF.EmitAutoVarDecl(*CatchParam);
3993 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
3995 // These types work out because ConvertType(id) == i8*.
3996 CGF.Builder.CreateStore(Caught, CGF.GetAddrOfLocalVar(CatchParam));
3999 CGF.EmitStmt(CatchStmt->getCatchBody());
4001 // The scope of the catch variable ends right here.
4002 CatchVarCleanups.ForceCleanup();
4004 CGF.EmitBranchThroughCleanup(FinallyEnd);
4008 assert(OPT && "Unexpected non-object pointer type in @catch");
4009 const ObjCObjectType *ObjTy = OPT->getObjectType();
4011 // FIXME: @catch (Class c) ?
4012 ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4013 assert(IDecl && "Catch parameter must have Objective-C type!");
4015 // Check if the @catch block matches the exception object.
4016 llvm::Value *Class = EmitClassRef(CGF, IDecl);
4018 llvm::Value *matchArgs[] = { Class, Caught };
4019 llvm::CallInst *Match =
4020 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4021 matchArgs, "match");
4023 llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4024 llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4026 CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4027 MatchedBlock, NextCatchBlock);
4029 // Emit the @catch block.
4030 CGF.EmitBlock(MatchedBlock);
4032 // Collect any cleanups for the catch variable. The scope lasts until
4033 // the end of the catch body.
4034 CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4036 CGF.EmitAutoVarDecl(*CatchParam);
4037 assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4039 // Initialize the catch variable.
4041 CGF.Builder.CreateBitCast(Caught,
4042 CGF.ConvertType(CatchParam->getType()));
4043 CGF.Builder.CreateStore(Tmp, CGF.GetAddrOfLocalVar(CatchParam));
4045 CGF.EmitStmt(CatchStmt->getCatchBody());
4047 // We're done with the catch variable.
4048 CatchVarCleanups.ForceCleanup();
4050 CGF.EmitBranchThroughCleanup(FinallyEnd);
4052 CGF.EmitBlock(NextCatchBlock);
4055 CGF.ObjCEHValueStack.pop_back();
4057 // If nothing wanted anything to do with the caught exception,
4058 // kill the extract call.
4059 if (Caught->use_empty())
4060 Caught->eraseFromParent();
4063 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4066 // Emit the exception handler for the @catch blocks.
4067 CGF.EmitBlock(CatchHandler);
4069 // In theory we might now need a write hazard, but actually it's
4070 // unnecessary because there's no local-accessing code between
4071 // the try's write hazard and here.
4072 //Hazards.emitWriteHazard();
4074 // Extract the new exception and save it to the
4075 // propagating-exception slot.
4076 assert(PropagatingExnVar);
4077 llvm::CallInst *NewCaught =
4078 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4079 ExceptionData, "caught");
4080 CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4082 // Don't pop the catch handler; the throw already did.
4083 CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4084 CGF.EmitBranchThroughCleanup(FinallyRethrow);
4088 // Insert read hazards as required in the new blocks.
4089 Hazards.emitHazardsInNewBlocks();
4092 CGF.Builder.restoreIP(TryFallthroughIP);
4093 if (CGF.HaveInsertPoint())
4094 CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4095 CGF.PopCleanupBlock();
4096 CGF.EmitBlock(FinallyEnd.getBlock(), true);
4098 // Emit the rethrow block.
4099 CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4100 CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4101 if (CGF.HaveInsertPoint()) {
4102 // If we have a propagating-exception variable, check it.
4103 llvm::Value *PropagatingExn;
4104 if (PropagatingExnVar) {
4105 PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4107 // Otherwise, just look in the buffer for the exception to throw.
4109 llvm::CallInst *Caught =
4110 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4112 PropagatingExn = Caught;
4115 CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4117 CGF.Builder.CreateUnreachable();
4120 CGF.Builder.restoreIP(SavedIP);
4123 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4124 const ObjCAtThrowStmt &S,
4125 bool ClearInsertionPoint) {
4126 llvm::Value *ExceptionAsObject;
4128 if (const Expr *ThrowExpr = S.getThrowExpr()) {
4129 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4131 CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4133 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4134 "Unexpected rethrow outside @catch block.");
4135 ExceptionAsObject = CGF.ObjCEHValueStack.back();
4138 CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4139 ->setDoesNotReturn();
4140 CGF.Builder.CreateUnreachable();
4142 // Clear the insertion point to indicate we are in unreachable code.
4143 if (ClearInsertionPoint)
4144 CGF.Builder.ClearInsertionPoint();
4147 /// EmitObjCWeakRead - Code gen for loading value of a __weak
4148 /// object: objc_read_weak (id *src)
4150 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4151 llvm::Value *AddrWeakObj) {
4152 llvm::Type* DestTy =
4153 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType();
4154 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4155 ObjCTypes.PtrObjectPtrTy);
4156 llvm::Value *read_weak =
4157 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4158 AddrWeakObj, "weakread");
4159 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4163 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4164 /// objc_assign_weak (id src, id *dst)
4166 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4167 llvm::Value *src, llvm::Value *dst) {
4168 llvm::Type * SrcTy = src->getType();
4169 if (!isa<llvm::PointerType>(SrcTy)) {
4170 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4171 assert(Size <= 8 && "does not support size > 8");
4172 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4173 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4174 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4176 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4177 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4178 llvm::Value *args[] = { src, dst };
4179 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4180 args, "weakassign");
4184 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4185 /// objc_assign_global (id src, id *dst)
4187 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4188 llvm::Value *src, llvm::Value *dst,
4190 llvm::Type * SrcTy = src->getType();
4191 if (!isa<llvm::PointerType>(SrcTy)) {
4192 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4193 assert(Size <= 8 && "does not support size > 8");
4194 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4195 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4196 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4198 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4199 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4200 llvm::Value *args[] = { src, dst };
4202 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4203 args, "globalassign");
4205 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4206 args, "threadlocalassign");
4210 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4211 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4213 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4214 llvm::Value *src, llvm::Value *dst,
4215 llvm::Value *ivarOffset) {
4216 assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
4217 llvm::Type * SrcTy = src->getType();
4218 if (!isa<llvm::PointerType>(SrcTy)) {
4219 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4220 assert(Size <= 8 && "does not support size > 8");
4221 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4222 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4223 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4225 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4226 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4227 llvm::Value *args[] = { src, dst, ivarOffset };
4228 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
4232 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
4233 /// objc_assign_strongCast (id src, id *dst)
4235 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
4236 llvm::Value *src, llvm::Value *dst) {
4237 llvm::Type * SrcTy = src->getType();
4238 if (!isa<llvm::PointerType>(SrcTy)) {
4239 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4240 assert(Size <= 8 && "does not support size > 8");
4241 src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4242 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4243 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4245 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4246 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4247 llvm::Value *args[] = { src, dst };
4248 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
4249 args, "weakassign");
4253 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
4254 llvm::Value *DestPtr,
4255 llvm::Value *SrcPtr,
4256 llvm::Value *size) {
4257 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
4258 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
4259 llvm::Value *args[] = { DestPtr, SrcPtr, size };
4260 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
4263 /// EmitObjCValueForIvar - Code Gen for ivar reference.
4265 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
4267 llvm::Value *BaseValue,
4268 const ObjCIvarDecl *Ivar,
4269 unsigned CVRQualifiers) {
4270 const ObjCInterfaceDecl *ID =
4271 ObjectTy->getAs<ObjCObjectType>()->getInterface();
4272 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
4273 EmitIvarOffset(CGF, ID, Ivar));
4276 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
4277 const ObjCInterfaceDecl *Interface,
4278 const ObjCIvarDecl *Ivar) {
4279 uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
4280 return llvm::ConstantInt::get(
4281 CGM.getTypes().ConvertType(CGM.getContext().LongTy),
4285 /* *** Private Interface *** */
4287 /// EmitImageInfo - Emit the image info marker used to encode some module
4288 /// level information.
4290 /// See: <rdr://4810609&4810587&4810587>
4291 /// struct IMAGE_INFO {
4292 /// unsigned version;
4295 enum ImageInfoFlags {
4296 eImageInfo_FixAndContinue = (1 << 0),
4297 eImageInfo_GarbageCollected = (1 << 1),
4298 eImageInfo_GCOnly = (1 << 2),
4299 eImageInfo_OptimizedByDyld = (1 << 3), // FIXME: When is this set.
4301 // A flag indicating that the module has no instances of a @synthesize of a
4302 // superclass variable. <rdar://problem/6803242>
4303 eImageInfo_CorrectedSynthesize = (1 << 4),
4304 eImageInfo_ImageIsSimulated = (1 << 5)
4307 void CGObjCCommonMac::EmitImageInfo() {
4308 unsigned version = 0; // Version is unused?
4309 const char *Section = (ObjCABI == 1) ?
4310 "__OBJC, __image_info,regular" :
4311 "__DATA, __objc_imageinfo, regular, no_dead_strip";
4313 // Generate module-level named metadata to convey this information to the
4314 // linker and code-gen.
4315 llvm::Module &Mod = CGM.getModule();
4317 // Add the ObjC ABI version to the module flags.
4318 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
4319 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
4321 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
4322 llvm::MDString::get(VMContext,Section));
4324 if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
4325 // Non-GC overrides those files which specify GC.
4326 Mod.addModuleFlag(llvm::Module::Override,
4327 "Objective-C Garbage Collection", (uint32_t)0);
4329 // Add the ObjC garbage collection value.
4330 Mod.addModuleFlag(llvm::Module::Error,
4331 "Objective-C Garbage Collection",
4332 eImageInfo_GarbageCollected);
4334 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
4335 // Add the ObjC GC Only value.
4336 Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
4339 // Require that GC be specified and set to eImageInfo_GarbageCollected.
4340 llvm::Value *Ops[2] = {
4341 llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
4342 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
4343 eImageInfo_GarbageCollected)
4345 Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
4346 llvm::MDNode::get(VMContext, Ops));
4350 // Indicate whether we're compiling this to run on a simulator.
4351 const llvm::Triple &Triple = CGM.getTarget().getTriple();
4352 if (Triple.isiOS() &&
4353 (Triple.getArch() == llvm::Triple::x86 ||
4354 Triple.getArch() == llvm::Triple::x86_64))
4355 Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
4356 eImageInfo_ImageIsSimulated);
4359 // struct objc_module {
4360 // unsigned long version;
4361 // unsigned long size;
4362 // const char *name;
4366 // FIXME: Get from somewhere
4367 static const int ModuleVersion = 7;
4369 void CGObjCMac::EmitModuleInfo() {
4370 uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
4372 llvm::Constant *Values[] = {
4373 llvm::ConstantInt::get(ObjCTypes.LongTy, ModuleVersion),
4374 llvm::ConstantInt::get(ObjCTypes.LongTy, Size),
4375 // This used to be the filename, now it is unused. <rdr://4327263>
4376 GetClassName(&CGM.getContext().Idents.get("")),
4379 CreateMetadataVar("\01L_OBJC_MODULES",
4380 llvm::ConstantStruct::get(ObjCTypes.ModuleTy, Values),
4381 "__OBJC,__module_info,regular,no_dead_strip",
4385 llvm::Constant *CGObjCMac::EmitModuleSymbols() {
4386 unsigned NumClasses = DefinedClasses.size();
4387 unsigned NumCategories = DefinedCategories.size();
4389 // Return null if no symbols were defined.
4390 if (!NumClasses && !NumCategories)
4391 return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
4393 llvm::Constant *Values[5];
4394 Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
4395 Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy);
4396 Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses);
4397 Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories);
4399 // The runtime expects exactly the list of defined classes followed
4400 // by the list of defined categories, in a single array.
4401 SmallVector<llvm::Constant*, 8> Symbols(NumClasses + NumCategories);
4402 for (unsigned i=0; i<NumClasses; i++)
4403 Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i],
4404 ObjCTypes.Int8PtrTy);
4405 for (unsigned i=0; i<NumCategories; i++)
4406 Symbols[NumClasses + i] =
4407 llvm::ConstantExpr::getBitCast(DefinedCategories[i],
4408 ObjCTypes.Int8PtrTy);
4411 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
4415 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
4417 llvm::GlobalVariable *GV =
4418 CreateMetadataVar("\01L_OBJC_SYMBOLS", Init,
4419 "__OBJC,__symbols,regular,no_dead_strip",
4421 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
4424 llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
4425 IdentifierInfo *II) {
4426 LazySymbols.insert(II);
4428 llvm::GlobalVariable *&Entry = ClassReferences[II];
4431 llvm::Constant *Casted =
4432 llvm::ConstantExpr::getBitCast(GetClassName(II),
4433 ObjCTypes.ClassPtrTy);
4435 CreateMetadataVar("\01L_OBJC_CLASS_REFERENCES_", Casted,
4436 "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
4440 return CGF.Builder.CreateLoad(Entry);
4443 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
4444 const ObjCInterfaceDecl *ID) {
4445 return EmitClassRefFromId(CGF, ID->getIdentifier());
4448 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
4449 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
4450 return EmitClassRefFromId(CGF, II);
4453 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel,
4455 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
4458 llvm::Constant *Casted =
4459 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
4460 ObjCTypes.SelectorPtrTy);
4462 CreateMetadataVar("\01L_OBJC_SELECTOR_REFERENCES_", Casted,
4463 "__OBJC,__message_refs,literal_pointers,no_dead_strip",
4465 Entry->setExternallyInitialized(true);
4470 return CGF.Builder.CreateLoad(Entry);
4473 llvm::Constant *CGObjCCommonMac::GetClassName(IdentifierInfo *Ident) {
4474 llvm::GlobalVariable *&Entry = ClassNames[Ident];
4477 Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
4478 llvm::ConstantDataArray::getString(VMContext,
4479 Ident->getNameStart()),
4481 "__TEXT,__objc_classname,cstring_literals" :
4482 "__TEXT,__cstring,cstring_literals"),
4485 return getConstantGEP(VMContext, Entry, 0, 0);
4488 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
4489 llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
4490 I = MethodDefinitions.find(MD);
4491 if (I != MethodDefinitions.end())
4497 /// GetIvarLayoutName - Returns a unique constant for the given
4498 /// ivar layout bitmap.
4499 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
4500 const ObjCCommonTypesHelper &ObjCTypes) {
4501 return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
4504 void CGObjCCommonMac::BuildAggrIvarRecordLayout(const RecordType *RT,
4505 unsigned int BytePos,
4506 bool ForStrongLayout,
4508 const RecordDecl *RD = RT->getDecl();
4509 // FIXME - Use iterator.
4510 SmallVector<const FieldDecl*, 16> Fields;
4511 for (RecordDecl::field_iterator i = RD->field_begin(),
4512 e = RD->field_end(); i != e; ++i)
4513 Fields.push_back(*i);
4514 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
4515 const llvm::StructLayout *RecLayout =
4516 CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
4518 BuildAggrIvarLayout(0, RecLayout, RD, Fields, BytePos,
4519 ForStrongLayout, HasUnion);
4522 void CGObjCCommonMac::BuildAggrIvarLayout(const ObjCImplementationDecl *OI,
4523 const llvm::StructLayout *Layout,
4524 const RecordDecl *RD,
4525 ArrayRef<const FieldDecl*> RecFields,
4526 unsigned int BytePos, bool ForStrongLayout,
4528 bool IsUnion = (RD && RD->isUnion());
4529 uint64_t MaxUnionIvarSize = 0;
4530 uint64_t MaxSkippedUnionIvarSize = 0;
4531 const FieldDecl *MaxField = 0;
4532 const FieldDecl *MaxSkippedField = 0;
4533 const FieldDecl *LastFieldBitfieldOrUnnamed = 0;
4534 uint64_t MaxFieldOffset = 0;
4535 uint64_t MaxSkippedFieldOffset = 0;
4536 uint64_t LastBitfieldOrUnnamedOffset = 0;
4537 uint64_t FirstFieldDelta = 0;
4539 if (RecFields.empty())
4541 unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
4542 unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
4543 if (!RD && CGM.getLangOpts().ObjCAutoRefCount) {
4544 const FieldDecl *FirstField = RecFields[0];
4546 ComputeIvarBaseOffset(CGM, OI, cast<ObjCIvarDecl>(FirstField));
4549 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
4550 const FieldDecl *Field = RecFields[i];
4551 uint64_t FieldOffset;
4553 // Note that 'i' here is actually the field index inside RD of Field,
4554 // although this dependency is hidden.
4555 const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
4556 FieldOffset = (RL.getFieldOffset(i) / ByteSizeInBits) - FirstFieldDelta;
4559 ComputeIvarBaseOffset(CGM, OI, cast<ObjCIvarDecl>(Field)) - FirstFieldDelta;
4561 // Skip over unnamed or bitfields
4562 if (!Field->getIdentifier() || Field->isBitField()) {
4563 LastFieldBitfieldOrUnnamed = Field;
4564 LastBitfieldOrUnnamedOffset = FieldOffset;
4568 LastFieldBitfieldOrUnnamed = 0;
4569 QualType FQT = Field->getType();
4570 if (FQT->isRecordType() || FQT->isUnionType()) {
4571 if (FQT->isUnionType())
4574 BuildAggrIvarRecordLayout(FQT->getAs<RecordType>(),
4575 BytePos + FieldOffset,
4576 ForStrongLayout, HasUnion);
4580 if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
4581 const ConstantArrayType *CArray =
4582 dyn_cast_or_null<ConstantArrayType>(Array);
4583 uint64_t ElCount = CArray->getSize().getZExtValue();
4584 assert(CArray && "only array with known element size is supported");
4585 FQT = CArray->getElementType();
4586 while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
4587 const ConstantArrayType *CArray =
4588 dyn_cast_or_null<ConstantArrayType>(Array);
4589 ElCount *= CArray->getSize().getZExtValue();
4590 FQT = CArray->getElementType();
4593 assert(!FQT->isUnionType() &&
4594 "layout for array of unions not supported");
4595 if (FQT->isRecordType() && ElCount) {
4596 int OldIndex = IvarsInfo.size() - 1;
4597 int OldSkIndex = SkipIvars.size() -1;
4599 const RecordType *RT = FQT->getAs<RecordType>();
4600 BuildAggrIvarRecordLayout(RT, BytePos + FieldOffset,
4601 ForStrongLayout, HasUnion);
4603 // Replicate layout information for each array element. Note that
4604 // one element is already done.
4606 for (int FirstIndex = IvarsInfo.size() - 1,
4607 FirstSkIndex = SkipIvars.size() - 1 ;ElIx < ElCount; ElIx++) {
4608 uint64_t Size = CGM.getContext().getTypeSize(RT)/ByteSizeInBits;
4609 for (int i = OldIndex+1; i <= FirstIndex; ++i)
4610 IvarsInfo.push_back(GC_IVAR(IvarsInfo[i].ivar_bytepos + Size*ElIx,
4611 IvarsInfo[i].ivar_size));
4612 for (int i = OldSkIndex+1; i <= FirstSkIndex; ++i)
4613 SkipIvars.push_back(GC_IVAR(SkipIvars[i].ivar_bytepos + Size*ElIx,
4614 SkipIvars[i].ivar_size));
4619 // At this point, we are done with Record/Union and array there of.
4620 // For other arrays we are down to its element type.
4621 Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), FQT);
4623 unsigned FieldSize = CGM.getContext().getTypeSize(Field->getType());
4624 if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
4625 || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
4627 uint64_t UnionIvarSize = FieldSize / WordSizeInBits;
4628 if (UnionIvarSize > MaxUnionIvarSize) {
4629 MaxUnionIvarSize = UnionIvarSize;
4631 MaxFieldOffset = FieldOffset;
4634 IvarsInfo.push_back(GC_IVAR(BytePos + FieldOffset,
4635 FieldSize / WordSizeInBits));
4637 } else if ((ForStrongLayout &&
4638 (GCAttr == Qualifiers::GCNone || GCAttr == Qualifiers::Weak))
4639 || (!ForStrongLayout && GCAttr != Qualifiers::Weak)) {
4641 // FIXME: Why the asymmetry? We divide by word size in bits on other
4643 uint64_t UnionIvarSize = FieldSize / ByteSizeInBits;
4644 if (UnionIvarSize > MaxSkippedUnionIvarSize) {
4645 MaxSkippedUnionIvarSize = UnionIvarSize;
4646 MaxSkippedField = Field;
4647 MaxSkippedFieldOffset = FieldOffset;
4650 // FIXME: Why the asymmetry, we divide by byte size in bits here?
4651 SkipIvars.push_back(GC_IVAR(BytePos + FieldOffset,
4652 FieldSize / ByteSizeInBits));
4657 if (LastFieldBitfieldOrUnnamed) {
4658 if (LastFieldBitfieldOrUnnamed->isBitField()) {
4659 // Last field was a bitfield. Must update skip info.
4660 uint64_t BitFieldSize
4661 = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
4663 skivar.ivar_bytepos = BytePos + LastBitfieldOrUnnamedOffset;
4664 skivar.ivar_size = (BitFieldSize / ByteSizeInBits)
4665 + ((BitFieldSize % ByteSizeInBits) != 0);
4666 SkipIvars.push_back(skivar);
4668 assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
4669 // Last field was unnamed. Must update skip info.
4671 = CGM.getContext().getTypeSize(LastFieldBitfieldOrUnnamed->getType());
4672 SkipIvars.push_back(GC_IVAR(BytePos + LastBitfieldOrUnnamedOffset,
4673 FieldSize / ByteSizeInBits));
4678 IvarsInfo.push_back(GC_IVAR(BytePos + MaxFieldOffset,
4680 if (MaxSkippedField)
4681 SkipIvars.push_back(GC_IVAR(BytePos + MaxSkippedFieldOffset,
4682 MaxSkippedUnionIvarSize));
4685 /// BuildIvarLayoutBitmap - This routine is the horsework for doing all
4686 /// the computations and returning the layout bitmap (for ivar or blocks) in
4687 /// the given argument BitMap string container. Routine reads
4688 /// two containers, IvarsInfo and SkipIvars which are assumed to be
4689 /// filled already by the caller.
4690 llvm::Constant *CGObjCCommonMac::BuildIvarLayoutBitmap(std::string &BitMap) {
4691 unsigned int WordsToScan, WordsToSkip;
4692 llvm::Type *PtrTy = CGM.Int8PtrTy;
4694 // Build the string of skip/scan nibbles
4695 SmallVector<SKIP_SCAN, 32> SkipScanIvars;
4696 unsigned int WordSize =
4697 CGM.getTypes().getDataLayout().getTypeAllocSize(PtrTy);
4698 if (IvarsInfo[0].ivar_bytepos == 0) {
4700 WordsToScan = IvarsInfo[0].ivar_size;
4702 WordsToSkip = IvarsInfo[0].ivar_bytepos/WordSize;
4703 WordsToScan = IvarsInfo[0].ivar_size;
4705 for (unsigned int i=1, Last=IvarsInfo.size(); i != Last; i++) {
4706 unsigned int TailPrevGCObjC =
4707 IvarsInfo[i-1].ivar_bytepos + IvarsInfo[i-1].ivar_size * WordSize;
4708 if (IvarsInfo[i].ivar_bytepos == TailPrevGCObjC) {
4709 // consecutive 'scanned' object pointers.
4710 WordsToScan += IvarsInfo[i].ivar_size;
4712 // Skip over 'gc'able object pointer which lay over each other.
4713 if (TailPrevGCObjC > IvarsInfo[i].ivar_bytepos)
4715 // Must skip over 1 or more words. We save current skip/scan values
4716 // and start a new pair.
4718 SkScan.skip = WordsToSkip;
4719 SkScan.scan = WordsToScan;
4720 SkipScanIvars.push_back(SkScan);
4723 SkScan.skip = (IvarsInfo[i].ivar_bytepos - TailPrevGCObjC) / WordSize;
4725 SkipScanIvars.push_back(SkScan);
4727 WordsToScan = IvarsInfo[i].ivar_size;
4730 if (WordsToScan > 0) {
4732 SkScan.skip = WordsToSkip;
4733 SkScan.scan = WordsToScan;
4734 SkipScanIvars.push_back(SkScan);
4737 if (!SkipIvars.empty()) {
4738 unsigned int LastIndex = SkipIvars.size()-1;
4739 int LastByteSkipped =
4740 SkipIvars[LastIndex].ivar_bytepos + SkipIvars[LastIndex].ivar_size;
4741 LastIndex = IvarsInfo.size()-1;
4742 int LastByteScanned =
4743 IvarsInfo[LastIndex].ivar_bytepos +
4744 IvarsInfo[LastIndex].ivar_size * WordSize;
4745 // Compute number of bytes to skip at the tail end of the last ivar scanned.
4746 if (LastByteSkipped > LastByteScanned) {
4747 unsigned int TotalWords = (LastByteSkipped + (WordSize -1)) / WordSize;
4749 SkScan.skip = TotalWords - (LastByteScanned/WordSize);
4751 SkipScanIvars.push_back(SkScan);
4754 // Mini optimization of nibbles such that an 0xM0 followed by 0x0N is produced
4756 int SkipScan = SkipScanIvars.size()-1;
4757 for (int i = 0; i <= SkipScan; i++) {
4758 if ((i < SkipScan) && SkipScanIvars[i].skip && SkipScanIvars[i].scan == 0
4759 && SkipScanIvars[i+1].skip == 0 && SkipScanIvars[i+1].scan) {
4760 // 0xM0 followed by 0x0N detected.
4761 SkipScanIvars[i].scan = SkipScanIvars[i+1].scan;
4762 for (int j = i+1; j < SkipScan; j++)
4763 SkipScanIvars[j] = SkipScanIvars[j+1];
4768 // Generate the string.
4769 for (int i = 0; i <= SkipScan; i++) {
4771 unsigned int skip_small = SkipScanIvars[i].skip % 0xf;
4772 unsigned int scan_small = SkipScanIvars[i].scan % 0xf;
4773 unsigned int skip_big = SkipScanIvars[i].skip / 0xf;
4774 unsigned int scan_big = SkipScanIvars[i].scan / 0xf;
4777 for (unsigned int ix = 0; ix < skip_big; ix++)
4778 BitMap += (unsigned char)(0xf0);
4780 // next (skip small, scan)
4782 byte = skip_small << 4;
4786 } else if (scan_small) {
4793 for (unsigned int ix = 0; ix < scan_big; ix++)
4794 BitMap += (unsigned char)(0x0f);
4801 // null terminate string.
4802 unsigned char zero = 0;
4805 llvm::GlobalVariable * Entry =
4806 CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
4807 llvm::ConstantDataArray::getString(VMContext, BitMap,false),
4809 "__TEXT,__objc_classname,cstring_literals" :
4810 "__TEXT,__cstring,cstring_literals"),
4812 return getConstantGEP(VMContext, Entry, 0, 0);
4815 /// BuildIvarLayout - Builds ivar layout bitmap for the class
4816 /// implementation for the __strong or __weak case.
4817 /// The layout map displays which words in ivar list must be skipped
4818 /// and which must be scanned by GC (see below). String is built of bytes.
4819 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
4820 /// of words to skip and right nibble is count of words to scan. So, each
4821 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is
4822 /// represented by a 0x00 byte which also ends the string.
4823 /// 1. when ForStrongLayout is true, following ivars are scanned:
4826 /// - __strong anything
4828 /// 2. When ForStrongLayout is false, following ivars are scanned:
4829 /// - __weak anything
4831 llvm::Constant *CGObjCCommonMac::BuildIvarLayout(
4832 const ObjCImplementationDecl *OMD,
4833 bool ForStrongLayout) {
4834 bool hasUnion = false;
4836 llvm::Type *PtrTy = CGM.Int8PtrTy;
4837 if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
4838 !CGM.getLangOpts().ObjCAutoRefCount)
4839 return llvm::Constant::getNullValue(PtrTy);
4841 const ObjCInterfaceDecl *OI = OMD->getClassInterface();
4842 SmallVector<const FieldDecl*, 32> RecFields;
4843 if (CGM.getLangOpts().ObjCAutoRefCount) {
4844 for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
4845 IVD; IVD = IVD->getNextIvar())
4846 RecFields.push_back(cast<FieldDecl>(IVD));
4849 SmallVector<const ObjCIvarDecl*, 32> Ivars;
4850 CGM.getContext().DeepCollectObjCIvars(OI, true, Ivars);
4852 // FIXME: This is not ideal; we shouldn't have to do this copy.
4853 RecFields.append(Ivars.begin(), Ivars.end());
4856 if (RecFields.empty())
4857 return llvm::Constant::getNullValue(PtrTy);
4862 BuildAggrIvarLayout(OMD, 0, 0, RecFields, 0, ForStrongLayout, hasUnion);
4863 if (IvarsInfo.empty())
4864 return llvm::Constant::getNullValue(PtrTy);
4865 // Sort on byte position in case we encounterred a union nested in
4867 if (hasUnion && !IvarsInfo.empty())
4868 std::sort(IvarsInfo.begin(), IvarsInfo.end());
4869 if (hasUnion && !SkipIvars.empty())
4870 std::sort(SkipIvars.begin(), SkipIvars.end());
4873 llvm::Constant *C = BuildIvarLayoutBitmap(BitMap);
4875 if (CGM.getLangOpts().ObjCGCBitmapPrint) {
4876 printf("\n%s ivar layout for class '%s': ",
4877 ForStrongLayout ? "strong" : "weak",
4878 OMD->getClassInterface()->getName().data());
4879 const unsigned char *s = (const unsigned char*)BitMap.c_str();
4880 for (unsigned i = 0, e = BitMap.size(); i < e; i++)
4882 printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
4884 printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
4890 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
4891 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
4893 // FIXME: Avoid std::string in "Sel.getAsString()"
4895 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_NAME_",
4896 llvm::ConstantDataArray::getString(VMContext, Sel.getAsString()),
4898 "__TEXT,__objc_methname,cstring_literals" :
4899 "__TEXT,__cstring,cstring_literals"),
4902 return getConstantGEP(VMContext, Entry, 0, 0);
4905 // FIXME: Merge into a single cstring creation function.
4906 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
4907 return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
4910 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
4911 std::string TypeStr;
4912 CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
4914 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
4917 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_",
4918 llvm::ConstantDataArray::getString(VMContext, TypeStr),
4920 "__TEXT,__objc_methtype,cstring_literals" :
4921 "__TEXT,__cstring,cstring_literals"),
4924 return getConstantGEP(VMContext, Entry, 0, 0);
4927 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
4929 std::string TypeStr;
4930 if (CGM.getContext().getObjCEncodingForMethodDecl(D, TypeStr, Extended))
4933 llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
4936 Entry = CreateMetadataVar("\01L_OBJC_METH_VAR_TYPE_",
4937 llvm::ConstantDataArray::getString(VMContext, TypeStr),
4939 "__TEXT,__objc_methtype,cstring_literals" :
4940 "__TEXT,__cstring,cstring_literals"),
4943 return getConstantGEP(VMContext, Entry, 0, 0);
4946 // FIXME: Merge into a single cstring creation function.
4947 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
4948 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
4951 Entry = CreateMetadataVar("\01L_OBJC_PROP_NAME_ATTR_",
4952 llvm::ConstantDataArray::getString(VMContext,
4953 Ident->getNameStart()),
4954 "__TEXT,__cstring,cstring_literals",
4957 return getConstantGEP(VMContext, Entry, 0, 0);
4960 // FIXME: Merge into a single cstring creation function.
4961 // FIXME: This Decl should be more precise.
4963 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
4964 const Decl *Container) {
4965 std::string TypeStr;
4966 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr);
4967 return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
4970 void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
4971 const ObjCContainerDecl *CD,
4972 SmallVectorImpl<char> &Name) {
4973 llvm::raw_svector_ostream OS(Name);
4974 assert (CD && "Missing container decl in GetNameForMethod");
4975 OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
4976 << '[' << CD->getName();
4977 if (const ObjCCategoryImplDecl *CID =
4978 dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
4979 OS << '(' << *CID << ')';
4980 OS << ' ' << D->getSelector().getAsString() << ']';
4983 void CGObjCMac::FinishModule() {
4986 // Emit the dummy bodies for any protocols which were referenced but
4988 for (llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*>::iterator
4989 I = Protocols.begin(), e = Protocols.end(); I != e; ++I) {
4990 if (I->second->hasInitializer())
4993 llvm::Constant *Values[5];
4994 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
4995 Values[1] = GetClassName(I->first);
4996 Values[2] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
4997 Values[3] = Values[4] =
4998 llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
4999 I->second->setLinkage(llvm::GlobalValue::InternalLinkage);
5000 I->second->setInitializer(llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
5002 CGM.AddUsedGlobal(I->second);
5005 // Add assembler directives to add lazy undefined symbol references
5006 // for classes which are referenced but not defined. This is
5007 // important for correct linker interaction.
5009 // FIXME: It would be nice if we had an LLVM construct for this.
5010 if (!LazySymbols.empty() || !DefinedSymbols.empty()) {
5011 SmallString<256> Asm;
5012 Asm += CGM.getModule().getModuleInlineAsm();
5013 if (!Asm.empty() && Asm.back() != '\n')
5016 llvm::raw_svector_ostream OS(Asm);
5017 for (llvm::SetVector<IdentifierInfo*>::iterator I = DefinedSymbols.begin(),
5018 e = DefinedSymbols.end(); I != e; ++I)
5019 OS << "\t.objc_class_name_" << (*I)->getName() << "=0\n"
5020 << "\t.globl .objc_class_name_" << (*I)->getName() << "\n";
5021 for (llvm::SetVector<IdentifierInfo*>::iterator I = LazySymbols.begin(),
5022 e = LazySymbols.end(); I != e; ++I) {
5023 OS << "\t.lazy_reference .objc_class_name_" << (*I)->getName() << "\n";
5026 for (size_t i = 0, e = DefinedCategoryNames.size(); i < e; ++i) {
5027 OS << "\t.objc_category_name_" << DefinedCategoryNames[i] << "=0\n"
5028 << "\t.globl .objc_category_name_" << DefinedCategoryNames[i] << "\n";
5031 CGM.getModule().setModuleInlineAsm(OS.str());
5035 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5036 : CGObjCCommonMac(cgm),
5038 ObjCEmptyCacheVar = ObjCEmptyVtableVar = NULL;
5044 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5045 : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(0)
5047 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5048 ASTContext &Ctx = CGM.getContext();
5050 ShortTy = Types.ConvertType(Ctx.ShortTy);
5051 IntTy = Types.ConvertType(Ctx.IntTy);
5052 LongTy = Types.ConvertType(Ctx.LongTy);
5053 LongLongTy = Types.ConvertType(Ctx.LongLongTy);
5054 Int8PtrTy = CGM.Int8PtrTy;
5055 Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5057 ObjectPtrTy = Types.ConvertType(Ctx.getObjCIdType());
5058 PtrObjectPtrTy = llvm::PointerType::getUnqual(ObjectPtrTy);
5059 SelectorPtrTy = Types.ConvertType(Ctx.getObjCSelType());
5061 // I'm not sure I like this. The implicit coordination is a bit
5062 // gross. We should solve this in a reasonable fashion because this
5063 // is a pretty common task (match some runtime data structure with
5064 // an LLVM data structure).
5066 // FIXME: This is leaked.
5067 // FIXME: Merge with rewriter code?
5069 // struct _objc_super {
5073 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5074 Ctx.getTranslationUnitDecl(),
5075 SourceLocation(), SourceLocation(),
5076 &Ctx.Idents.get("_objc_super"));
5077 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), 0,
5078 Ctx.getObjCIdType(), 0, 0, false, ICIS_NoInit));
5079 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), 0,
5080 Ctx.getObjCClassType(), 0, 0, false,
5082 RD->completeDefinition();
5084 SuperCTy = Ctx.getTagDeclType(RD);
5085 SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5087 SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5088 SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5092 // char *attributes;
5094 PropertyTy = llvm::StructType::create("struct._prop_t",
5095 Int8PtrTy, Int8PtrTy, NULL);
5097 // struct _prop_list_t {
5098 // uint32_t entsize; // sizeof(struct _prop_t)
5099 // uint32_t count_of_properties;
5100 // struct _prop_t prop_list[count_of_properties];
5103 llvm::StructType::create("struct._prop_list_t", IntTy, IntTy,
5104 llvm::ArrayType::get(PropertyTy, 0), NULL);
5105 // struct _prop_list_t *
5106 PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5108 // struct _objc_method {
5110 // char *method_type;
5113 MethodTy = llvm::StructType::create("struct._objc_method",
5114 SelectorPtrTy, Int8PtrTy, Int8PtrTy,
5117 // struct _objc_cache *
5118 CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5119 CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5123 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5124 : ObjCCommonTypesHelper(cgm) {
5125 // struct _objc_method_description {
5129 MethodDescriptionTy =
5130 llvm::StructType::create("struct._objc_method_description",
5131 SelectorPtrTy, Int8PtrTy, NULL);
5133 // struct _objc_method_description_list {
5135 // struct _objc_method_description[1];
5137 MethodDescriptionListTy =
5138 llvm::StructType::create("struct._objc_method_description_list",
5140 llvm::ArrayType::get(MethodDescriptionTy, 0),NULL);
5142 // struct _objc_method_description_list *
5143 MethodDescriptionListPtrTy =
5144 llvm::PointerType::getUnqual(MethodDescriptionListTy);
5146 // Protocol description structures
5148 // struct _objc_protocol_extension {
5149 // uint32_t size; // sizeof(struct _objc_protocol_extension)
5150 // struct _objc_method_description_list *optional_instance_methods;
5151 // struct _objc_method_description_list *optional_class_methods;
5152 // struct _objc_property_list *instance_properties;
5153 // const char ** extendedMethodTypes;
5155 ProtocolExtensionTy =
5156 llvm::StructType::create("struct._objc_protocol_extension",
5157 IntTy, MethodDescriptionListPtrTy,
5158 MethodDescriptionListPtrTy, PropertyListPtrTy,
5159 Int8PtrPtrTy, NULL);
5161 // struct _objc_protocol_extension *
5162 ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5164 // Handle recursive construction of Protocol and ProtocolList types
5167 llvm::StructType::create(VMContext, "struct._objc_protocol");
5170 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5171 ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy),
5173 llvm::ArrayType::get(ProtocolTy, 0),
5176 // struct _objc_protocol {
5177 // struct _objc_protocol_extension *isa;
5178 // char *protocol_name;
5179 // struct _objc_protocol **_objc_protocol_list;
5180 // struct _objc_method_description_list *instance_methods;
5181 // struct _objc_method_description_list *class_methods;
5183 ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5184 llvm::PointerType::getUnqual(ProtocolListTy),
5185 MethodDescriptionListPtrTy,
5186 MethodDescriptionListPtrTy,
5189 // struct _objc_protocol_list *
5190 ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5192 ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5194 // Class description structures
5196 // struct _objc_ivar {
5201 IvarTy = llvm::StructType::create("struct._objc_ivar",
5202 Int8PtrTy, Int8PtrTy, IntTy, NULL);
5204 // struct _objc_ivar_list *
5206 llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5207 IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5209 // struct _objc_method_list *
5211 llvm::StructType::create(VMContext, "struct._objc_method_list");
5212 MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5214 // struct _objc_class_extension *
5216 llvm::StructType::create("struct._objc_class_extension",
5217 IntTy, Int8PtrTy, PropertyListPtrTy, NULL);
5218 ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5220 ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5222 // struct _objc_class {
5224 // Class super_class;
5228 // long instance_size;
5229 // struct _objc_ivar_list *ivars;
5230 // struct _objc_method_list *methods;
5231 // struct _objc_cache *cache;
5232 // struct _objc_protocol_list *protocols;
5233 // char *ivar_layout;
5234 // struct _objc_class_ext *ext;
5236 ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5237 llvm::PointerType::getUnqual(ClassTy),
5247 ClassExtensionPtrTy,
5250 ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5252 // struct _objc_category {
5253 // char *category_name;
5254 // char *class_name;
5255 // struct _objc_method_list *instance_method;
5256 // struct _objc_method_list *class_method;
5257 // uint32_t size; // sizeof(struct _objc_category)
5258 // struct _objc_property_list *instance_properties;// category's @property
5261 llvm::StructType::create("struct._objc_category",
5262 Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5263 MethodListPtrTy, ProtocolListPtrTy,
5264 IntTy, PropertyListPtrTy, NULL);
5266 // Global metadata structures
5268 // struct _objc_symtab {
5269 // long sel_ref_cnt;
5271 // short cls_def_cnt;
5272 // short cat_def_cnt;
5273 // char *defs[cls_def_cnt + cat_def_cnt];
5276 llvm::StructType::create("struct._objc_symtab",
5277 LongTy, SelectorPtrTy, ShortTy, ShortTy,
5278 llvm::ArrayType::get(Int8PtrTy, 0), NULL);
5279 SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
5281 // struct _objc_module {
5283 // long size; // sizeof(struct _objc_module)
5285 // struct _objc_symtab* symtab;
5288 llvm::StructType::create("struct._objc_module",
5289 LongTy, LongTy, Int8PtrTy, SymtabPtrTy, NULL);
5292 // FIXME: This is the size of the setjmp buffer and should be target
5293 // specific. 18 is what's used on 32-bit X86.
5294 uint64_t SetJmpBufferSize = 18;
5297 llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
5300 llvm::StructType::create("struct._objc_exception_data",
5301 llvm::ArrayType::get(CGM.Int32Ty,SetJmpBufferSize),
5306 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
5307 : ObjCCommonTypesHelper(cgm) {
5308 // struct _method_list_t {
5309 // uint32_t entsize; // sizeof(struct _objc_method)
5310 // uint32_t method_count;
5311 // struct _objc_method method_list[method_count];
5314 llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
5315 llvm::ArrayType::get(MethodTy, 0), NULL);
5316 // struct method_list_t *
5317 MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
5319 // struct _protocol_t {
5321 // const char * const protocol_name;
5322 // const struct _protocol_list_t * protocol_list; // super protocols
5323 // const struct method_list_t * const instance_methods;
5324 // const struct method_list_t * const class_methods;
5325 // const struct method_list_t *optionalInstanceMethods;
5326 // const struct method_list_t *optionalClassMethods;
5327 // const struct _prop_list_t * properties;
5328 // const uint32_t size; // sizeof(struct _protocol_t)
5329 // const uint32_t flags; // = 0
5330 // const char ** extendedMethodTypes;
5333 // Holder for struct _protocol_list_t *
5334 ProtocolListnfABITy =
5335 llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5338 llvm::StructType::create("struct._protocol_t", ObjectPtrTy, Int8PtrTy,
5339 llvm::PointerType::getUnqual(ProtocolListnfABITy),
5340 MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5341 MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5342 PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy,
5345 // struct _protocol_t*
5346 ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
5348 // struct _protocol_list_t {
5349 // long protocol_count; // Note, this is 32/64 bit
5350 // struct _protocol_t *[protocol_count];
5352 ProtocolListnfABITy->setBody(LongTy,
5353 llvm::ArrayType::get(ProtocolnfABIPtrTy, 0),
5356 // struct _objc_protocol_list*
5357 ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
5360 // unsigned long int *offset; // pointer to ivar offset location
5363 // uint32_t alignment;
5367 llvm::StructType::create("struct._ivar_t",
5368 llvm::PointerType::getUnqual(LongTy),
5369 Int8PtrTy, Int8PtrTy, IntTy, IntTy, NULL);
5371 // struct _ivar_list_t {
5372 // uint32 entsize; // sizeof(struct _ivar_t)
5374 // struct _iver_t list[count];
5377 llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
5378 llvm::ArrayType::get(IvarnfABITy, 0), NULL);
5380 IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
5382 // struct _class_ro_t {
5383 // uint32_t const flags;
5384 // uint32_t const instanceStart;
5385 // uint32_t const instanceSize;
5386 // uint32_t const reserved; // only when building for 64bit targets
5387 // const uint8_t * const ivarLayout;
5388 // const char *const name;
5389 // const struct _method_list_t * const baseMethods;
5390 // const struct _objc_protocol_list *const baseProtocols;
5391 // const struct _ivar_list_t *const ivars;
5392 // const uint8_t * const weakIvarLayout;
5393 // const struct _prop_list_t * const properties;
5396 // FIXME. Add 'reserved' field in 64bit abi mode!
5397 ClassRonfABITy = llvm::StructType::create("struct._class_ro_t",
5398 IntTy, IntTy, IntTy, Int8PtrTy,
5399 Int8PtrTy, MethodListnfABIPtrTy,
5400 ProtocolListnfABIPtrTy,
5402 Int8PtrTy, PropertyListPtrTy, NULL);
5404 // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
5405 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
5406 ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
5409 // struct _class_t {
5410 // struct _class_t *isa;
5411 // struct _class_t * const superclass;
5414 // struct class_ro_t *ro;
5417 ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
5418 ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
5419 llvm::PointerType::getUnqual(ClassnfABITy),
5421 llvm::PointerType::getUnqual(ImpnfABITy),
5422 llvm::PointerType::getUnqual(ClassRonfABITy),
5425 // LLVM for struct _class_t *
5426 ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
5428 // struct _category_t {
5429 // const char * const name;
5430 // struct _class_t *const cls;
5431 // const struct _method_list_t * const instance_methods;
5432 // const struct _method_list_t * const class_methods;
5433 // const struct _protocol_list_t * const protocols;
5434 // const struct _prop_list_t * const properties;
5436 CategorynfABITy = llvm::StructType::create("struct._category_t",
5437 Int8PtrTy, ClassnfABIPtrTy,
5438 MethodListnfABIPtrTy,
5439 MethodListnfABIPtrTy,
5440 ProtocolListnfABIPtrTy,
5444 // New types for nonfragile abi messaging.
5445 CodeGen::CodeGenTypes &Types = CGM.getTypes();
5446 ASTContext &Ctx = CGM.getContext();
5448 // MessageRefTy - LLVM for:
5449 // struct _message_ref_t {
5454 // First the clang type for struct _message_ref_t
5455 RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5456 Ctx.getTranslationUnitDecl(),
5457 SourceLocation(), SourceLocation(),
5458 &Ctx.Idents.get("_message_ref_t"));
5459 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), 0,
5460 Ctx.VoidPtrTy, 0, 0, false, ICIS_NoInit));
5461 RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(), 0,
5462 Ctx.getObjCSelType(), 0, 0, false,
5464 RD->completeDefinition();
5466 MessageRefCTy = Ctx.getTagDeclType(RD);
5467 MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
5468 MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
5470 // MessageRefPtrTy - LLVM for struct _message_ref_t*
5471 MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
5473 // SuperMessageRefTy - LLVM for:
5474 // struct _super_message_ref_t {
5475 // SUPER_IMP messenger;
5479 llvm::StructType::create("struct._super_message_ref_t",
5480 ImpnfABITy, SelectorPtrTy, NULL);
5482 // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
5483 SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
5486 // struct objc_typeinfo {
5487 // const void** vtable; // objc_ehtype_vtable + 2
5488 // const char* name; // c++ typeinfo string
5492 llvm::StructType::create("struct._objc_typeinfo",
5493 llvm::PointerType::getUnqual(Int8PtrTy),
5494 Int8PtrTy, ClassnfABIPtrTy, NULL);
5495 EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
5498 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
5499 FinishNonFragileABIModule();
5504 void CGObjCNonFragileABIMac::
5505 AddModuleClassList(ArrayRef<llvm::GlobalValue*> Container,
5506 const char *SymbolName,
5507 const char *SectionName) {
5508 unsigned NumClasses = Container.size();
5513 SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
5514 for (unsigned i=0; i<NumClasses; i++)
5515 Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
5516 ObjCTypes.Int8PtrTy);
5517 llvm::Constant *Init =
5518 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
5522 llvm::GlobalVariable *GV =
5523 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
5524 llvm::GlobalValue::InternalLinkage,
5527 GV->setAlignment(CGM.getDataLayout().getABITypeAlignment(Init->getType()));
5528 GV->setSection(SectionName);
5529 CGM.AddUsedGlobal(GV);
5532 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
5533 // nonfragile abi has no module definition.
5535 // Build list of all implemented class addresses in array
5536 // L_OBJC_LABEL_CLASS_$.
5537 AddModuleClassList(DefinedClasses,
5538 "\01L_OBJC_LABEL_CLASS_$",
5539 "__DATA, __objc_classlist, regular, no_dead_strip");
5541 for (unsigned i = 0, e = DefinedClasses.size(); i < e; i++) {
5542 llvm::GlobalValue *IMPLGV = DefinedClasses[i];
5543 if (IMPLGV->getLinkage() != llvm::GlobalValue::ExternalWeakLinkage)
5545 IMPLGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
5548 for (unsigned i = 0, e = DefinedMetaClasses.size(); i < e; i++) {
5549 llvm::GlobalValue *IMPLGV = DefinedMetaClasses[i];
5550 if (IMPLGV->getLinkage() != llvm::GlobalValue::ExternalWeakLinkage)
5552 IMPLGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
5555 AddModuleClassList(DefinedNonLazyClasses,
5556 "\01L_OBJC_LABEL_NONLAZY_CLASS_$",
5557 "__DATA, __objc_nlclslist, regular, no_dead_strip");
5559 // Build list of all implemented category addresses in array
5560 // L_OBJC_LABEL_CATEGORY_$.
5561 AddModuleClassList(DefinedCategories,
5562 "\01L_OBJC_LABEL_CATEGORY_$",
5563 "__DATA, __objc_catlist, regular, no_dead_strip");
5564 AddModuleClassList(DefinedNonLazyCategories,
5565 "\01L_OBJC_LABEL_NONLAZY_CATEGORY_$",
5566 "__DATA, __objc_nlcatlist, regular, no_dead_strip");
5571 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of
5572 /// VTableDispatchMethods; false otherwise. What this means is that
5573 /// except for the 19 selectors in the list, we generate 32bit-style
5574 /// message dispatch call for all the rest.
5575 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
5576 // At various points we've experimented with using vtable-based
5577 // dispatch for all methods.
5578 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
5579 case CodeGenOptions::Legacy:
5581 case CodeGenOptions::NonLegacy:
5583 case CodeGenOptions::Mixed:
5587 // If so, see whether this selector is in the white-list of things which must
5588 // use the new dispatch convention. We lazily build a dense set for this.
5589 if (VTableDispatchMethods.empty()) {
5590 VTableDispatchMethods.insert(GetNullarySelector("alloc"));
5591 VTableDispatchMethods.insert(GetNullarySelector("class"));
5592 VTableDispatchMethods.insert(GetNullarySelector("self"));
5593 VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
5594 VTableDispatchMethods.insert(GetNullarySelector("length"));
5595 VTableDispatchMethods.insert(GetNullarySelector("count"));
5597 // These are vtable-based if GC is disabled.
5598 // Optimistically use vtable dispatch for hybrid compiles.
5599 if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
5600 VTableDispatchMethods.insert(GetNullarySelector("retain"));
5601 VTableDispatchMethods.insert(GetNullarySelector("release"));
5602 VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
5605 VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
5606 VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
5607 VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
5608 VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
5609 VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
5610 VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
5611 VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
5613 // These are vtable-based if GC is enabled.
5614 // Optimistically use vtable dispatch for hybrid compiles.
5615 if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5616 VTableDispatchMethods.insert(GetNullarySelector("hash"));
5617 VTableDispatchMethods.insert(GetUnarySelector("addObject"));
5619 // "countByEnumeratingWithState:objects:count"
5620 IdentifierInfo *KeyIdents[] = {
5621 &CGM.getContext().Idents.get("countByEnumeratingWithState"),
5622 &CGM.getContext().Idents.get("objects"),
5623 &CGM.getContext().Idents.get("count")
5625 VTableDispatchMethods.insert(
5626 CGM.getContext().Selectors.getSelector(3, KeyIdents));
5630 return VTableDispatchMethods.count(Sel);
5633 /// BuildClassRoTInitializer - generate meta-data for:
5634 /// struct _class_ro_t {
5635 /// uint32_t const flags;
5636 /// uint32_t const instanceStart;
5637 /// uint32_t const instanceSize;
5638 /// uint32_t const reserved; // only when building for 64bit targets
5639 /// const uint8_t * const ivarLayout;
5640 /// const char *const name;
5641 /// const struct _method_list_t * const baseMethods;
5642 /// const struct _protocol_list_t *const baseProtocols;
5643 /// const struct _ivar_list_t *const ivars;
5644 /// const uint8_t * const weakIvarLayout;
5645 /// const struct _prop_list_t * const properties;
5648 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
5650 unsigned InstanceStart,
5651 unsigned InstanceSize,
5652 const ObjCImplementationDecl *ID) {
5653 std::string ClassName = ID->getNameAsString();
5654 llvm::Constant *Values[10]; // 11 for 64bit targets!
5656 if (CGM.getLangOpts().ObjCAutoRefCount)
5657 flags |= NonFragileABI_Class_CompiledByARC;
5659 Values[ 0] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags);
5660 Values[ 1] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceStart);
5661 Values[ 2] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceSize);
5662 // FIXME. For 64bit targets add 0 here.
5663 Values[ 3] = (flags & NonFragileABI_Class_Meta)
5664 ? GetIvarLayoutName(0, ObjCTypes)
5665 : BuildIvarLayout(ID, true);
5666 Values[ 4] = GetClassName(ID->getIdentifier());
5667 // const struct _method_list_t * const baseMethods;
5668 std::vector<llvm::Constant*> Methods;
5669 std::string MethodListName("\01l_OBJC_$_");
5670 if (flags & NonFragileABI_Class_Meta) {
5671 MethodListName += "CLASS_METHODS_" + ID->getNameAsString();
5672 for (ObjCImplementationDecl::classmeth_iterator
5673 i = ID->classmeth_begin(), e = ID->classmeth_end(); i != e; ++i) {
5674 // Class methods should always be defined.
5675 Methods.push_back(GetMethodConstant(*i));
5678 MethodListName += "INSTANCE_METHODS_" + ID->getNameAsString();
5679 for (ObjCImplementationDecl::instmeth_iterator
5680 i = ID->instmeth_begin(), e = ID->instmeth_end(); i != e; ++i) {
5681 // Instance methods should always be defined.
5682 Methods.push_back(GetMethodConstant(*i));
5684 for (ObjCImplementationDecl::propimpl_iterator
5685 i = ID->propimpl_begin(), e = ID->propimpl_end(); i != e; ++i) {
5686 ObjCPropertyImplDecl *PID = *i;
5688 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
5689 ObjCPropertyDecl *PD = PID->getPropertyDecl();
5691 if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
5692 if (llvm::Constant *C = GetMethodConstant(MD))
5693 Methods.push_back(C);
5694 if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
5695 if (llvm::Constant *C = GetMethodConstant(MD))
5696 Methods.push_back(C);
5700 Values[ 5] = EmitMethodList(MethodListName,
5701 "__DATA, __objc_const", Methods);
5703 const ObjCInterfaceDecl *OID = ID->getClassInterface();
5704 assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
5705 Values[ 6] = EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_"
5707 OID->all_referenced_protocol_begin(),
5708 OID->all_referenced_protocol_end());
5710 if (flags & NonFragileABI_Class_Meta) {
5711 Values[ 7] = llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
5712 Values[ 8] = GetIvarLayoutName(0, ObjCTypes);
5713 Values[ 9] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
5715 Values[ 7] = EmitIvarList(ID);
5716 Values[ 8] = BuildIvarLayout(ID, false);
5717 Values[ 9] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getName(),
5718 ID, ID->getClassInterface(), ObjCTypes);
5720 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassRonfABITy,
5722 llvm::GlobalVariable *CLASS_RO_GV =
5723 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassRonfABITy, false,
5724 llvm::GlobalValue::InternalLinkage,
5726 (flags & NonFragileABI_Class_Meta) ?
5727 std::string("\01l_OBJC_METACLASS_RO_$_")+ClassName :
5728 std::string("\01l_OBJC_CLASS_RO_$_")+ClassName);
5729 CLASS_RO_GV->setAlignment(
5730 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassRonfABITy));
5731 CLASS_RO_GV->setSection("__DATA, __objc_const");
5736 /// BuildClassMetaData - This routine defines that to-level meta-data
5737 /// for the given ClassName for:
5738 /// struct _class_t {
5739 /// struct _class_t *isa;
5740 /// struct _class_t * const superclass;
5743 /// struct class_ro_t *ro;
5746 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassMetaData(
5747 std::string &ClassName,
5748 llvm::Constant *IsAGV,
5749 llvm::Constant *SuperClassGV,
5750 llvm::Constant *ClassRoGV,
5751 bool HiddenVisibility) {
5752 llvm::Constant *Values[] = {
5755 ObjCEmptyCacheVar, // &ObjCEmptyCacheVar
5756 ObjCEmptyVtableVar, // &ObjCEmptyVtableVar
5757 ClassRoGV // &CLASS_RO_GV
5760 Values[1] = llvm::Constant::getNullValue(ObjCTypes.ClassnfABIPtrTy);
5762 Values[3] = llvm::Constant::getNullValue(
5763 llvm::PointerType::getUnqual(ObjCTypes.ImpnfABITy));
5764 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassnfABITy,
5766 llvm::GlobalVariable *GV = GetClassGlobal(ClassName);
5767 GV->setInitializer(Init);
5768 GV->setSection("__DATA, __objc_data");
5770 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy));
5771 if (HiddenVisibility)
5772 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
5777 CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
5778 return OD->getClassMethod(GetNullarySelector("load")) != 0;
5781 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
5782 uint32_t &InstanceStart,
5783 uint32_t &InstanceSize) {
5784 const ASTRecordLayout &RL =
5785 CGM.getContext().getASTObjCImplementationLayout(OID);
5787 // InstanceSize is really instance end.
5788 InstanceSize = RL.getDataSize().getQuantity();
5790 // If there are no fields, the start is the same as the end.
5791 if (!RL.getFieldCount())
5792 InstanceStart = InstanceSize;
5794 InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
5797 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
5798 std::string ClassName = ID->getNameAsString();
5799 if (!ObjCEmptyCacheVar) {
5800 ObjCEmptyCacheVar = new llvm::GlobalVariable(
5804 llvm::GlobalValue::ExternalLinkage,
5806 "_objc_empty_cache");
5808 // Make this entry NULL for any iOS device target, any iOS simulator target,
5809 // OS X with deployment target 10.9 or later.
5810 const llvm::Triple &Triple = CGM.getTarget().getTriple();
5811 if (Triple.isiOS() || (Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 9)))
5812 // This entry will be null.
5813 ObjCEmptyVtableVar = 0;
5815 ObjCEmptyVtableVar = new llvm::GlobalVariable(
5817 ObjCTypes.ImpnfABITy,
5819 llvm::GlobalValue::ExternalLinkage,
5821 "_objc_empty_vtable");
5823 assert(ID->getClassInterface() &&
5824 "CGObjCNonFragileABIMac::GenerateClass - class is 0");
5825 // FIXME: Is this correct (that meta class size is never computed)?
5826 uint32_t InstanceStart =
5827 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
5828 uint32_t InstanceSize = InstanceStart;
5829 uint32_t flags = NonFragileABI_Class_Meta;
5830 std::string ObjCMetaClassName(getMetaclassSymbolPrefix());
5831 std::string ObjCClassName(getClassSymbolPrefix());
5833 llvm::GlobalVariable *SuperClassGV, *IsAGV;
5835 // Build the flags for the metaclass.
5836 bool classIsHidden =
5837 ID->getClassInterface()->getVisibility() == HiddenVisibility;
5839 flags |= NonFragileABI_Class_Hidden;
5841 // FIXME: why is this flag set on the metaclass?
5842 // ObjC metaclasses have no fields and don't really get constructed.
5843 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
5844 flags |= NonFragileABI_Class_HasCXXStructors;
5845 if (!ID->hasNonZeroConstructors())
5846 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
5849 if (!ID->getClassInterface()->getSuperClass()) {
5851 flags |= NonFragileABI_Class_Root;
5852 SuperClassGV = GetClassGlobal(ObjCClassName + ClassName);
5853 IsAGV = GetClassGlobal(ObjCMetaClassName + ClassName);
5855 // Has a root. Current class is not a root.
5856 const ObjCInterfaceDecl *Root = ID->getClassInterface();
5857 while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
5859 IsAGV = GetClassGlobal(ObjCMetaClassName + Root->getNameAsString());
5860 if (Root->isWeakImported())
5861 IsAGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
5862 // work on super class metadata symbol.
5863 std::string SuperClassName =
5865 ID->getClassInterface()->getSuperClass()->getNameAsString();
5866 SuperClassGV = GetClassGlobal(SuperClassName);
5867 if (ID->getClassInterface()->getSuperClass()->isWeakImported())
5868 SuperClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
5870 llvm::GlobalVariable *CLASS_RO_GV = BuildClassRoTInitializer(flags,
5873 std::string TClassName = ObjCMetaClassName + ClassName;
5874 llvm::GlobalVariable *MetaTClass =
5875 BuildClassMetaData(TClassName, IsAGV, SuperClassGV, CLASS_RO_GV,
5877 DefinedMetaClasses.push_back(MetaTClass);
5879 // Metadata for the class
5882 flags |= NonFragileABI_Class_Hidden;
5884 if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
5885 flags |= NonFragileABI_Class_HasCXXStructors;
5887 // Set a flag to enable a runtime optimization when a class has
5888 // fields that require destruction but which don't require
5889 // anything except zero-initialization during construction. This
5890 // is most notably true of __strong and __weak types, but you can
5891 // also imagine there being C++ types with non-trivial default
5892 // constructors that merely set all fields to null.
5893 if (!ID->hasNonZeroConstructors())
5894 flags |= NonFragileABI_Class_HasCXXDestructorOnly;
5897 if (hasObjCExceptionAttribute(CGM.getContext(), ID->getClassInterface()))
5898 flags |= NonFragileABI_Class_Exception;
5900 if (!ID->getClassInterface()->getSuperClass()) {
5901 flags |= NonFragileABI_Class_Root;
5904 // Has a root. Current class is not a root.
5905 std::string RootClassName =
5906 ID->getClassInterface()->getSuperClass()->getNameAsString();
5907 SuperClassGV = GetClassGlobal(ObjCClassName + RootClassName);
5908 if (ID->getClassInterface()->getSuperClass()->isWeakImported())
5909 SuperClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
5911 GetClassSizeInfo(ID, InstanceStart, InstanceSize);
5912 CLASS_RO_GV = BuildClassRoTInitializer(flags,
5917 TClassName = ObjCClassName + ClassName;
5918 llvm::GlobalVariable *ClassMD =
5919 BuildClassMetaData(TClassName, MetaTClass, SuperClassGV, CLASS_RO_GV,
5921 DefinedClasses.push_back(ClassMD);
5923 // Determine if this class is also "non-lazy".
5924 if (ImplementationIsNonLazy(ID))
5925 DefinedNonLazyClasses.push_back(ClassMD);
5927 // Force the definition of the EHType if necessary.
5928 if (flags & NonFragileABI_Class_Exception)
5929 GetInterfaceEHType(ID->getClassInterface(), true);
5930 // Make sure method definition entries are all clear for next implementation.
5931 MethodDefinitions.clear();
5934 /// GenerateProtocolRef - This routine is called to generate code for
5935 /// a protocol reference expression; as in:
5937 /// @protocol(Proto1);
5939 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
5940 /// which will hold address of the protocol meta-data.
5942 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
5943 const ObjCProtocolDecl *PD) {
5945 // This routine is called for @protocol only. So, we must build definition
5946 // of protocol's meta-data (not a reference to it!)
5948 llvm::Constant *Init =
5949 llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
5950 ObjCTypes.getExternalProtocolPtrTy());
5952 std::string ProtocolName("\01l_OBJC_PROTOCOL_REFERENCE_$_");
5953 ProtocolName += PD->getName();
5955 llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
5957 return CGF.Builder.CreateLoad(PTGV);
5958 PTGV = new llvm::GlobalVariable(
5960 Init->getType(), false,
5961 llvm::GlobalValue::WeakAnyLinkage,
5964 PTGV->setSection("__DATA, __objc_protorefs, coalesced, no_dead_strip");
5965 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
5966 CGM.AddUsedGlobal(PTGV);
5967 return CGF.Builder.CreateLoad(PTGV);
5970 /// GenerateCategory - Build metadata for a category implementation.
5971 /// struct _category_t {
5972 /// const char * const name;
5973 /// struct _class_t *const cls;
5974 /// const struct _method_list_t * const instance_methods;
5975 /// const struct _method_list_t * const class_methods;
5976 /// const struct _protocol_list_t * const protocols;
5977 /// const struct _prop_list_t * const properties;
5980 void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
5981 const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
5982 const char *Prefix = "\01l_OBJC_$_CATEGORY_";
5983 std::string ExtCatName(Prefix + Interface->getNameAsString()+
5984 "_$_" + OCD->getNameAsString());
5985 std::string ExtClassName(getClassSymbolPrefix() +
5986 Interface->getNameAsString());
5988 llvm::Constant *Values[6];
5989 Values[0] = GetClassName(OCD->getIdentifier());
5990 // meta-class entry symbol
5991 llvm::GlobalVariable *ClassGV = GetClassGlobal(ExtClassName);
5992 if (Interface->isWeakImported())
5993 ClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
5995 Values[1] = ClassGV;
5996 std::vector<llvm::Constant*> Methods;
5997 std::string MethodListName(Prefix);
5998 MethodListName += "INSTANCE_METHODS_" + Interface->getNameAsString() +
5999 "_$_" + OCD->getNameAsString();
6001 for (ObjCCategoryImplDecl::instmeth_iterator
6002 i = OCD->instmeth_begin(), e = OCD->instmeth_end(); i != e; ++i) {
6003 // Instance methods should always be defined.
6004 Methods.push_back(GetMethodConstant(*i));
6007 Values[2] = EmitMethodList(MethodListName,
6008 "__DATA, __objc_const",
6011 MethodListName = Prefix;
6012 MethodListName += "CLASS_METHODS_" + Interface->getNameAsString() + "_$_" +
6013 OCD->getNameAsString();
6015 for (ObjCCategoryImplDecl::classmeth_iterator
6016 i = OCD->classmeth_begin(), e = OCD->classmeth_end(); i != e; ++i) {
6017 // Class methods should always be defined.
6018 Methods.push_back(GetMethodConstant(*i));
6021 Values[3] = EmitMethodList(MethodListName,
6022 "__DATA, __objc_const",
6024 const ObjCCategoryDecl *Category =
6025 Interface->FindCategoryDeclaration(OCD->getIdentifier());
6027 SmallString<256> ExtName;
6028 llvm::raw_svector_ostream(ExtName) << Interface->getName() << "_$_"
6030 Values[4] = EmitProtocolList("\01l_OBJC_CATEGORY_PROTOCOLS_$_"
6031 + Interface->getName() + "_$_"
6032 + Category->getName(),
6033 Category->protocol_begin(),
6034 Category->protocol_end());
6035 Values[5] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
6036 OCD, Category, ObjCTypes);
6038 Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
6039 Values[5] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
6042 llvm::Constant *Init =
6043 llvm::ConstantStruct::get(ObjCTypes.CategorynfABITy,
6045 llvm::GlobalVariable *GCATV
6046 = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CategorynfABITy,
6048 llvm::GlobalValue::InternalLinkage,
6051 GCATV->setAlignment(
6052 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.CategorynfABITy));
6053 GCATV->setSection("__DATA, __objc_const");
6054 CGM.AddUsedGlobal(GCATV);
6055 DefinedCategories.push_back(GCATV);
6057 // Determine if this category is also "non-lazy".
6058 if (ImplementationIsNonLazy(OCD))
6059 DefinedNonLazyCategories.push_back(GCATV);
6060 // method definition entries must be clear for next implementation.
6061 MethodDefinitions.clear();
6064 /// GetMethodConstant - Return a struct objc_method constant for the
6065 /// given method if it has been defined. The result is null if the
6066 /// method has not been defined. The return value has type MethodPtrTy.
6067 llvm::Constant *CGObjCNonFragileABIMac::GetMethodConstant(
6068 const ObjCMethodDecl *MD) {
6069 llvm::Function *Fn = GetMethodDefinition(MD);
6073 llvm::Constant *Method[] = {
6074 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
6075 ObjCTypes.SelectorPtrTy),
6076 GetMethodVarType(MD),
6077 llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy)
6079 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
6082 /// EmitMethodList - Build meta-data for method declarations
6083 /// struct _method_list_t {
6084 /// uint32_t entsize; // sizeof(struct _objc_method)
6085 /// uint32_t method_count;
6086 /// struct _objc_method method_list[method_count];
6090 CGObjCNonFragileABIMac::EmitMethodList(Twine Name,
6091 const char *Section,
6092 ArrayRef<llvm::Constant*> Methods) {
6093 // Return null for empty list.
6094 if (Methods.empty())
6095 return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
6097 llvm::Constant *Values[3];
6098 // sizeof(struct _objc_method)
6099 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
6100 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
6102 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
6103 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
6105 Values[2] = llvm::ConstantArray::get(AT, Methods);
6106 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
6108 llvm::GlobalVariable *GV =
6109 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6110 llvm::GlobalValue::InternalLinkage, Init, Name);
6111 GV->setAlignment(CGM.getDataLayout().getABITypeAlignment(Init->getType()));
6112 GV->setSection(Section);
6113 CGM.AddUsedGlobal(GV);
6114 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6117 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6119 llvm::GlobalVariable *
6120 CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
6121 const ObjCIvarDecl *Ivar) {
6122 const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
6123 std::string Name = "OBJC_IVAR_$_" + Container->getNameAsString() +
6124 '.' + Ivar->getNameAsString();
6125 llvm::GlobalVariable *IvarOffsetGV =
6126 CGM.getModule().getGlobalVariable(Name);
6129 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.LongTy,
6131 llvm::GlobalValue::ExternalLinkage,
6134 return IvarOffsetGV;
6138 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
6139 const ObjCIvarDecl *Ivar,
6140 unsigned long int Offset) {
6141 llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
6142 IvarOffsetGV->setInitializer(llvm::ConstantInt::get(ObjCTypes.LongTy,
6144 IvarOffsetGV->setAlignment(
6145 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.LongTy));
6147 // FIXME: This matches gcc, but shouldn't the visibility be set on the use as
6148 // well (i.e., in ObjCIvarOffsetVariable).
6149 if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6150 Ivar->getAccessControl() == ObjCIvarDecl::Package ||
6151 ID->getVisibility() == HiddenVisibility)
6152 IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6154 IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
6155 IvarOffsetGV->setSection("__DATA, __objc_ivar");
6156 return IvarOffsetGV;
6159 /// EmitIvarList - Emit the ivar list for the given
6160 /// implementation. The return value has type
6161 /// IvarListnfABIPtrTy.
6162 /// struct _ivar_t {
6163 /// unsigned long int *offset; // pointer to ivar offset location
6166 /// uint32_t alignment;
6169 /// struct _ivar_list_t {
6170 /// uint32 entsize; // sizeof(struct _ivar_t)
6172 /// struct _iver_t list[count];
6176 llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
6177 const ObjCImplementationDecl *ID) {
6179 std::vector<llvm::Constant*> Ivars;
6181 const ObjCInterfaceDecl *OID = ID->getClassInterface();
6182 assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
6184 // FIXME. Consolidate this with similar code in GenerateClass.
6186 for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
6187 IVD; IVD = IVD->getNextIvar()) {
6188 // Ignore unnamed bit-fields.
6189 if (!IVD->getDeclName())
6191 llvm::Constant *Ivar[5];
6192 Ivar[0] = EmitIvarOffsetVar(ID->getClassInterface(), IVD,
6193 ComputeIvarBaseOffset(CGM, ID, IVD));
6194 Ivar[1] = GetMethodVarName(IVD->getIdentifier());
6195 Ivar[2] = GetMethodVarType(IVD);
6196 llvm::Type *FieldTy =
6197 CGM.getTypes().ConvertTypeForMem(IVD->getType());
6198 unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
6199 unsigned Align = CGM.getContext().getPreferredTypeAlign(
6200 IVD->getType().getTypePtr()) >> 3;
6201 Align = llvm::Log2_32(Align);
6202 Ivar[3] = llvm::ConstantInt::get(ObjCTypes.IntTy, Align);
6203 // NOTE. Size of a bitfield does not match gcc's, because of the
6204 // way bitfields are treated special in each. But I am told that
6205 // 'size' for bitfield ivars is ignored by the runtime so it does
6206 // not matter. If it matters, there is enough info to get the
6208 Ivar[4] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
6209 Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarnfABITy, Ivar));
6211 // Return null for empty list.
6213 return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
6215 llvm::Constant *Values[3];
6216 unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy);
6217 Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
6218 Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
6219 llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarnfABITy,
6221 Values[2] = llvm::ConstantArray::get(AT, Ivars);
6222 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
6223 const char *Prefix = "\01l_OBJC_$_INSTANCE_VARIABLES_";
6224 llvm::GlobalVariable *GV =
6225 new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6226 llvm::GlobalValue::InternalLinkage,
6228 Prefix + OID->getName());
6230 CGM.getDataLayout().getABITypeAlignment(Init->getType()));
6231 GV->setSection("__DATA, __objc_const");
6233 CGM.AddUsedGlobal(GV);
6234 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
6237 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
6238 const ObjCProtocolDecl *PD) {
6239 llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
6242 // We use the initializer as a marker of whether this is a forward
6243 // reference or not. At module finalization we add the empty
6244 // contents for protocols which were referenced but never defined.
6246 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy, false,
6247 llvm::GlobalValue::ExternalLinkage,
6249 "\01l_OBJC_PROTOCOL_$_" + PD->getName());
6250 Entry->setSection("__DATA,__datacoal_nt,coalesced");
6256 /// GetOrEmitProtocol - Generate the protocol meta-data:
6258 /// struct _protocol_t {
6260 /// const char * const protocol_name;
6261 /// const struct _protocol_list_t * protocol_list; // super protocols
6262 /// const struct method_list_t * const instance_methods;
6263 /// const struct method_list_t * const class_methods;
6264 /// const struct method_list_t *optionalInstanceMethods;
6265 /// const struct method_list_t *optionalClassMethods;
6266 /// const struct _prop_list_t * properties;
6267 /// const uint32_t size; // sizeof(struct _protocol_t)
6268 /// const uint32_t flags; // = 0
6269 /// const char ** extendedMethodTypes;
6274 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
6275 const ObjCProtocolDecl *PD) {
6276 llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
6278 // Early exit if a defining object has already been generated.
6279 if (Entry && Entry->hasInitializer())
6282 // Use the protocol definition, if there is one.
6283 if (const ObjCProtocolDecl *Def = PD->getDefinition())
6286 // Construct method lists.
6287 std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
6288 std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
6289 std::vector<llvm::Constant*> MethodTypesExt, OptMethodTypesExt;
6290 for (ObjCProtocolDecl::instmeth_iterator
6291 i = PD->instmeth_begin(), e = PD->instmeth_end(); i != e; ++i) {
6292 ObjCMethodDecl *MD = *i;
6293 llvm::Constant *C = GetMethodDescriptionConstant(MD);
6295 return GetOrEmitProtocolRef(PD);
6297 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
6298 OptInstanceMethods.push_back(C);
6299 OptMethodTypesExt.push_back(GetMethodVarType(MD, true));
6301 InstanceMethods.push_back(C);
6302 MethodTypesExt.push_back(GetMethodVarType(MD, true));
6306 for (ObjCProtocolDecl::classmeth_iterator
6307 i = PD->classmeth_begin(), e = PD->classmeth_end(); i != e; ++i) {
6308 ObjCMethodDecl *MD = *i;
6309 llvm::Constant *C = GetMethodDescriptionConstant(MD);
6311 return GetOrEmitProtocolRef(PD);
6313 if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
6314 OptClassMethods.push_back(C);
6315 OptMethodTypesExt.push_back(GetMethodVarType(MD, true));
6317 ClassMethods.push_back(C);
6318 MethodTypesExt.push_back(GetMethodVarType(MD, true));
6322 MethodTypesExt.insert(MethodTypesExt.end(),
6323 OptMethodTypesExt.begin(), OptMethodTypesExt.end());
6325 llvm::Constant *Values[11];
6327 Values[0] = llvm::Constant::getNullValue(ObjCTypes.ObjectPtrTy);
6328 Values[1] = GetClassName(PD->getIdentifier());
6329 Values[2] = EmitProtocolList("\01l_OBJC_$_PROTOCOL_REFS_" + PD->getName(),
6330 PD->protocol_begin(),
6331 PD->protocol_end());
6333 Values[3] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_"
6335 "__DATA, __objc_const",
6337 Values[4] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_"
6339 "__DATA, __objc_const",
6341 Values[5] = EmitMethodList("\01l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_"
6343 "__DATA, __objc_const",
6344 OptInstanceMethods);
6345 Values[6] = EmitMethodList("\01l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_"
6347 "__DATA, __objc_const",
6349 Values[7] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + PD->getName(),
6352 CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
6353 Values[8] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
6354 Values[9] = llvm::Constant::getNullValue(ObjCTypes.IntTy);
6355 Values[10] = EmitProtocolMethodTypes("\01l_OBJC_$_PROTOCOL_METHOD_TYPES_"
6357 MethodTypesExt, ObjCTypes);
6358 llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolnfABITy,
6362 // Already created, fix the linkage and update the initializer.
6363 Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
6364 Entry->setInitializer(Init);
6367 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
6368 false, llvm::GlobalValue::WeakAnyLinkage, Init,
6369 "\01l_OBJC_PROTOCOL_$_" + PD->getName());
6370 Entry->setAlignment(
6371 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABITy));
6372 Entry->setSection("__DATA,__datacoal_nt,coalesced");
6374 Protocols[PD->getIdentifier()] = Entry;
6376 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
6377 CGM.AddUsedGlobal(Entry);
6379 // Use this protocol meta-data to build protocol list table in section
6380 // __DATA, __objc_protolist
6381 llvm::GlobalVariable *PTGV =
6382 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
6383 false, llvm::GlobalValue::WeakAnyLinkage, Entry,
6384 "\01l_OBJC_LABEL_PROTOCOL_$_" + PD->getName());
6386 CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy));
6387 PTGV->setSection("__DATA, __objc_protolist, coalesced, no_dead_strip");
6388 PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6389 CGM.AddUsedGlobal(PTGV);
6393 /// EmitProtocolList - Generate protocol list meta-data:
6395 /// struct _protocol_list_t {
6396 /// long protocol_count; // Note, this is 32/64 bit
6397 /// struct _protocol_t[protocol_count];
6402 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
6403 ObjCProtocolDecl::protocol_iterator begin,
6404 ObjCProtocolDecl::protocol_iterator end) {
6405 SmallVector<llvm::Constant *, 16> ProtocolRefs;
6407 // Just return null for empty protocol lists
6409 return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
6411 // FIXME: We shouldn't need to do this lookup here, should we?
6412 SmallString<256> TmpName;
6413 Name.toVector(TmpName);
6414 llvm::GlobalVariable *GV =
6415 CGM.getModule().getGlobalVariable(TmpName.str(), true);
6417 return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
6419 for (; begin != end; ++begin)
6420 ProtocolRefs.push_back(GetProtocolRef(*begin)); // Implemented???
6422 // This list is null terminated.
6423 ProtocolRefs.push_back(llvm::Constant::getNullValue(
6424 ObjCTypes.ProtocolnfABIPtrTy));
6426 llvm::Constant *Values[2];
6428 llvm::ConstantInt::get(ObjCTypes.LongTy, ProtocolRefs.size() - 1);
6430 llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolnfABIPtrTy,
6431 ProtocolRefs.size()),
6434 llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
6435 GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6436 llvm::GlobalValue::InternalLinkage,
6438 GV->setSection("__DATA, __objc_const");
6440 CGM.getDataLayout().getABITypeAlignment(Init->getType()));
6441 CGM.AddUsedGlobal(GV);
6442 return llvm::ConstantExpr::getBitCast(GV,
6443 ObjCTypes.ProtocolListnfABIPtrTy);
6446 /// GetMethodDescriptionConstant - This routine build following meta-data:
6447 /// struct _objc_method {
6449 /// char *method_type;
6454 CGObjCNonFragileABIMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
6455 llvm::Constant *Desc[3];
6457 llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
6458 ObjCTypes.SelectorPtrTy);
6459 Desc[1] = GetMethodVarType(MD);
6463 // Protocol methods have no implementation. So, this entry is always NULL.
6464 Desc[2] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
6465 return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Desc);
6468 /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
6469 /// This code gen. amounts to generating code for:
6471 /// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
6474 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
6475 CodeGen::CodeGenFunction &CGF,
6477 llvm::Value *BaseValue,
6478 const ObjCIvarDecl *Ivar,
6479 unsigned CVRQualifiers) {
6480 ObjCInterfaceDecl *ID = ObjectTy->getAs<ObjCObjectType>()->getInterface();
6481 llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
6483 if (IsIvarOffsetKnownIdempotent(CGF, ID, Ivar))
6484 if (llvm::LoadInst *LI = cast<llvm::LoadInst>(Offset))
6485 LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
6486 llvm::MDNode::get(VMContext, ArrayRef<llvm::Value*>()));
6488 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
6492 llvm::Value *CGObjCNonFragileABIMac::EmitIvarOffset(
6493 CodeGen::CodeGenFunction &CGF,
6494 const ObjCInterfaceDecl *Interface,
6495 const ObjCIvarDecl *Ivar) {
6496 return CGF.Builder.CreateLoad(ObjCIvarOffsetVariable(Interface, Ivar),"ivar");
6499 static void appendSelectorForMessageRefTable(std::string &buffer,
6500 Selector selector) {
6501 if (selector.isUnarySelector()) {
6502 buffer += selector.getNameForSlot(0);
6506 for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
6507 buffer += selector.getNameForSlot(i);
6512 /// Emit a "v-table" message send. We emit a weak hidden-visibility
6513 /// struct, initially containing the selector pointer and a pointer to
6514 /// a "fixup" variant of the appropriate objc_msgSend. To call, we
6515 /// load and call the function pointer, passing the address of the
6516 /// struct as the second parameter. The runtime determines whether
6517 /// the selector is currently emitted using vtable dispatch; if so, it
6518 /// substitutes a stub function which simply tail-calls through the
6519 /// appropriate vtable slot, and if not, it substitues a stub function
6520 /// which tail-calls objc_msgSend. Both stubs adjust the selector
6521 /// argument to correctly point to the selector.
6523 CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
6524 ReturnValueSlot returnSlot,
6525 QualType resultType,
6530 const CallArgList &formalArgs,
6531 const ObjCMethodDecl *method) {
6532 // Compute the actual arguments.
6535 // First argument: the receiver / super-call structure.
6537 arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
6538 args.add(RValue::get(arg0), arg0Type);
6540 // Second argument: a pointer to the message ref structure. Leave
6541 // the actual argument value blank for now.
6542 args.add(RValue::get(0), ObjCTypes.MessageRefCPtrTy);
6544 args.insert(args.end(), formalArgs.begin(), formalArgs.end());
6546 MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);
6548 NullReturnState nullReturn;
6550 // Find the function to call and the mangled name for the message
6551 // ref structure. Using a different mangled name wouldn't actually
6552 // be a problem; it would just be a waste.
6554 // The runtime currently never uses vtable dispatch for anything
6555 // except normal, non-super message-sends.
6556 // FIXME: don't use this for that.
6557 llvm::Constant *fn = 0;
6558 std::string messageRefName("\01l_");
6559 if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) {
6561 fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
6562 messageRefName += "objc_msgSendSuper2_stret_fixup";
6564 nullReturn.init(CGF, arg0);
6565 fn = ObjCTypes.getMessageSendStretFixupFn();
6566 messageRefName += "objc_msgSend_stret_fixup";
6568 } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
6569 fn = ObjCTypes.getMessageSendFpretFixupFn();
6570 messageRefName += "objc_msgSend_fpret_fixup";
6573 fn = ObjCTypes.getMessageSendSuper2FixupFn();
6574 messageRefName += "objc_msgSendSuper2_fixup";
6576 fn = ObjCTypes.getMessageSendFixupFn();
6577 messageRefName += "objc_msgSend_fixup";
6580 assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend");
6581 messageRefName += '_';
6583 // Append the selector name, except use underscores anywhere we
6584 // would have used colons.
6585 appendSelectorForMessageRefTable(messageRefName, selector);
6587 llvm::GlobalVariable *messageRef
6588 = CGM.getModule().getGlobalVariable(messageRefName);
6590 // Build the message ref structure.
6591 llvm::Constant *values[] = { fn, GetMethodVarName(selector) };
6592 llvm::Constant *init = llvm::ConstantStruct::getAnon(values);
6593 messageRef = new llvm::GlobalVariable(CGM.getModule(),
6596 llvm::GlobalValue::WeakAnyLinkage,
6599 messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
6600 messageRef->setAlignment(16);
6601 messageRef->setSection("__DATA, __objc_msgrefs, coalesced");
6604 bool requiresnullCheck = false;
6605 if (CGM.getLangOpts().ObjCAutoRefCount && method)
6606 for (ObjCMethodDecl::param_const_iterator i = method->param_begin(),
6607 e = method->param_end(); i != e; ++i) {
6608 const ParmVarDecl *ParamDecl = (*i);
6609 if (ParamDecl->hasAttr<NSConsumedAttr>()) {
6610 if (!nullReturn.NullBB)
6611 nullReturn.init(CGF, arg0);
6612 requiresnullCheck = true;
6618 CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy);
6620 // Update the message ref argument.
6621 args[1].RV = RValue::get(mref);
6623 // Load the function to call from the message ref table.
6624 llvm::Value *callee = CGF.Builder.CreateStructGEP(mref, 0);
6625 callee = CGF.Builder.CreateLoad(callee, "msgSend_fn");
6627 callee = CGF.Builder.CreateBitCast(callee, MSI.MessengerType);
6629 RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
6630 return nullReturn.complete(CGF, result, resultType, formalArgs,
6631 requiresnullCheck ? method : 0);
6634 /// Generate code for a message send expression in the nonfragile abi.
6636 CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
6637 ReturnValueSlot Return,
6638 QualType ResultType,
6640 llvm::Value *Receiver,
6641 const CallArgList &CallArgs,
6642 const ObjCInterfaceDecl *Class,
6643 const ObjCMethodDecl *Method) {
6644 return isVTableDispatchedSelector(Sel)
6645 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
6646 Receiver, CGF.getContext().getObjCIdType(),
6647 false, CallArgs, Method)
6648 : EmitMessageSend(CGF, Return, ResultType,
6649 EmitSelector(CGF, Sel),
6650 Receiver, CGF.getContext().getObjCIdType(),
6651 false, CallArgs, Method, ObjCTypes);
6654 llvm::GlobalVariable *
6655 CGObjCNonFragileABIMac::GetClassGlobal(const std::string &Name) {
6656 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
6659 GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
6660 false, llvm::GlobalValue::ExternalLinkage,
6667 llvm::Value *CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
6668 IdentifierInfo *II) {
6669 llvm::GlobalVariable *&Entry = ClassReferences[II];
6672 std::string ClassName(getClassSymbolPrefix() + II->getName().str());
6673 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName);
6675 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
6676 false, llvm::GlobalValue::InternalLinkage,
6678 "\01L_OBJC_CLASSLIST_REFERENCES_$_");
6679 Entry->setAlignment(
6680 CGM.getDataLayout().getABITypeAlignment(
6681 ObjCTypes.ClassnfABIPtrTy));
6682 Entry->setSection("__DATA, __objc_classrefs, regular, no_dead_strip");
6683 CGM.AddUsedGlobal(Entry);
6686 return CGF.Builder.CreateLoad(Entry);
6689 llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
6690 const ObjCInterfaceDecl *ID) {
6691 return EmitClassRefFromId(CGF, ID->getIdentifier());
6694 llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
6695 CodeGenFunction &CGF) {
6696 IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
6697 return EmitClassRefFromId(CGF, II);
6701 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
6702 const ObjCInterfaceDecl *ID) {
6703 llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
6706 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
6707 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName);
6709 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
6710 false, llvm::GlobalValue::InternalLinkage,
6712 "\01L_OBJC_CLASSLIST_SUP_REFS_$_");
6713 Entry->setAlignment(
6714 CGM.getDataLayout().getABITypeAlignment(
6715 ObjCTypes.ClassnfABIPtrTy));
6716 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
6717 CGM.AddUsedGlobal(Entry);
6720 return CGF.Builder.CreateLoad(Entry);
6723 /// EmitMetaClassRef - Return a Value * of the address of _class_t
6726 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
6727 const ObjCInterfaceDecl *ID) {
6728 llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
6730 return CGF.Builder.CreateLoad(Entry);
6732 std::string MetaClassName(getMetaclassSymbolPrefix() + ID->getNameAsString());
6733 llvm::GlobalVariable *MetaClassGV = GetClassGlobal(MetaClassName);
6735 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy, false,
6736 llvm::GlobalValue::InternalLinkage,
6738 "\01L_OBJC_CLASSLIST_SUP_REFS_$_");
6739 Entry->setAlignment(
6740 CGM.getDataLayout().getABITypeAlignment(
6741 ObjCTypes.ClassnfABIPtrTy));
6743 Entry->setSection("__DATA, __objc_superrefs, regular, no_dead_strip");
6744 CGM.AddUsedGlobal(Entry);
6746 return CGF.Builder.CreateLoad(Entry);
6749 /// GetClass - Return a reference to the class for the given interface
6751 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
6752 const ObjCInterfaceDecl *ID) {
6753 if (ID->isWeakImported()) {
6754 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
6755 llvm::GlobalVariable *ClassGV = GetClassGlobal(ClassName);
6756 ClassGV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
6759 return EmitClassRef(CGF, ID);
6762 /// Generates a message send where the super is the receiver. This is
6763 /// a message send to self with special delivery semantics indicating
6764 /// which class's method should be called.
6766 CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
6767 ReturnValueSlot Return,
6768 QualType ResultType,
6770 const ObjCInterfaceDecl *Class,
6771 bool isCategoryImpl,
6772 llvm::Value *Receiver,
6773 bool IsClassMessage,
6774 const CodeGen::CallArgList &CallArgs,
6775 const ObjCMethodDecl *Method) {
6777 // Create and init a super structure; this is a (receiver, class)
6778 // pair we will pass to objc_msgSendSuper.
6779 llvm::Value *ObjCSuper =
6780 CGF.CreateTempAlloca(ObjCTypes.SuperTy, "objc_super");
6782 llvm::Value *ReceiverAsObject =
6783 CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
6784 CGF.Builder.CreateStore(ReceiverAsObject,
6785 CGF.Builder.CreateStructGEP(ObjCSuper, 0));
6787 // If this is a class message the metaclass is passed as the target.
6788 llvm::Value *Target;
6790 Target = EmitMetaClassRef(CGF, Class);
6792 Target = EmitSuperClassRef(CGF, Class);
6794 // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
6796 llvm::Type *ClassTy =
6797 CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
6798 Target = CGF.Builder.CreateBitCast(Target, ClassTy);
6799 CGF.Builder.CreateStore(Target,
6800 CGF.Builder.CreateStructGEP(ObjCSuper, 1));
6802 return (isVTableDispatchedSelector(Sel))
6803 ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
6804 ObjCSuper, ObjCTypes.SuperPtrCTy,
6805 true, CallArgs, Method)
6806 : EmitMessageSend(CGF, Return, ResultType,
6807 EmitSelector(CGF, Sel),
6808 ObjCSuper, ObjCTypes.SuperPtrCTy,
6809 true, CallArgs, Method, ObjCTypes);
6812 llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
6813 Selector Sel, bool lval) {
6814 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
6817 llvm::Constant *Casted =
6818 llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
6819 ObjCTypes.SelectorPtrTy);
6821 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.SelectorPtrTy, false,
6822 llvm::GlobalValue::InternalLinkage,
6823 Casted, "\01L_OBJC_SELECTOR_REFERENCES_");
6824 Entry->setExternallyInitialized(true);
6825 Entry->setSection("__DATA, __objc_selrefs, literal_pointers, no_dead_strip");
6826 CGM.AddUsedGlobal(Entry);
6831 llvm::LoadInst* LI = CGF.Builder.CreateLoad(Entry);
6833 LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
6834 llvm::MDNode::get(VMContext,
6835 ArrayRef<llvm::Value*>()));
6838 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
6839 /// objc_assign_ivar (id src, id *dst, ptrdiff_t)
6841 void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
6844 llvm::Value *ivarOffset) {
6845 llvm::Type * SrcTy = src->getType();
6846 if (!isa<llvm::PointerType>(SrcTy)) {
6847 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
6848 assert(Size <= 8 && "does not support size > 8");
6849 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
6850 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
6851 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
6853 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
6854 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
6855 llvm::Value *args[] = { src, dst, ivarOffset };
6856 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
6859 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
6860 /// objc_assign_strongCast (id src, id *dst)
6862 void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
6863 CodeGen::CodeGenFunction &CGF,
6864 llvm::Value *src, llvm::Value *dst) {
6865 llvm::Type * SrcTy = src->getType();
6866 if (!isa<llvm::PointerType>(SrcTy)) {
6867 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
6868 assert(Size <= 8 && "does not support size > 8");
6869 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
6870 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
6871 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
6873 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
6874 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
6875 llvm::Value *args[] = { src, dst };
6876 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
6877 args, "weakassign");
6880 void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
6881 CodeGen::CodeGenFunction &CGF,
6882 llvm::Value *DestPtr,
6883 llvm::Value *SrcPtr,
6884 llvm::Value *Size) {
6885 SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
6886 DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
6887 llvm::Value *args[] = { DestPtr, SrcPtr, Size };
6888 CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
6891 /// EmitObjCWeakRead - Code gen for loading value of a __weak
6892 /// object: objc_read_weak (id *src)
6894 llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
6895 CodeGen::CodeGenFunction &CGF,
6896 llvm::Value *AddrWeakObj) {
6897 llvm::Type* DestTy =
6898 cast<llvm::PointerType>(AddrWeakObj->getType())->getElementType();
6899 AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
6900 llvm::Value *read_weak =
6901 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
6902 AddrWeakObj, "weakread");
6903 read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
6907 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
6908 /// objc_assign_weak (id src, id *dst)
6910 void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
6911 llvm::Value *src, llvm::Value *dst) {
6912 llvm::Type * SrcTy = src->getType();
6913 if (!isa<llvm::PointerType>(SrcTy)) {
6914 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
6915 assert(Size <= 8 && "does not support size > 8");
6916 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
6917 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
6918 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
6920 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
6921 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
6922 llvm::Value *args[] = { src, dst };
6923 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
6924 args, "weakassign");
6927 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
6928 /// objc_assign_global (id src, id *dst)
6930 void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
6931 llvm::Value *src, llvm::Value *dst,
6933 llvm::Type * SrcTy = src->getType();
6934 if (!isa<llvm::PointerType>(SrcTy)) {
6935 unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
6936 assert(Size <= 8 && "does not support size > 8");
6937 src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
6938 : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
6939 src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
6941 src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
6942 dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
6943 llvm::Value *args[] = { src, dst };
6945 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
6946 args, "globalassign");
6948 CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
6949 args, "threadlocalassign");
6953 CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
6954 const ObjCAtSynchronizedStmt &S) {
6955 EmitAtSynchronizedStmt(CGF, S,
6956 cast<llvm::Function>(ObjCTypes.getSyncEnterFn()),
6957 cast<llvm::Function>(ObjCTypes.getSyncExitFn()));
6961 CGObjCNonFragileABIMac::GetEHType(QualType T) {
6962 // There's a particular fixed type info for 'id'.
6963 if (T->isObjCIdType() ||
6964 T->isObjCQualifiedIdType()) {
6965 llvm::Constant *IDEHType =
6966 CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
6969 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
6971 llvm::GlobalValue::ExternalLinkage,
6972 0, "OBJC_EHTYPE_id");
6976 // All other types should be Objective-C interface pointer types.
6977 const ObjCObjectPointerType *PT =
6978 T->getAs<ObjCObjectPointerType>();
6979 assert(PT && "Invalid @catch type.");
6980 const ObjCInterfaceType *IT = PT->getInterfaceType();
6981 assert(IT && "Invalid @catch type.");
6982 return GetInterfaceEHType(IT->getDecl(), false);
6985 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
6986 const ObjCAtTryStmt &S) {
6987 EmitTryCatchStmt(CGF, S,
6988 cast<llvm::Function>(ObjCTypes.getObjCBeginCatchFn()),
6989 cast<llvm::Function>(ObjCTypes.getObjCEndCatchFn()),
6990 cast<llvm::Function>(ObjCTypes.getExceptionRethrowFn()));
6993 /// EmitThrowStmt - Generate code for a throw statement.
6994 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
6995 const ObjCAtThrowStmt &S,
6996 bool ClearInsertionPoint) {
6997 if (const Expr *ThrowExpr = S.getThrowExpr()) {
6998 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
6999 Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7000 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception)
7001 .setDoesNotReturn();
7003 CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn())
7004 .setDoesNotReturn();
7007 CGF.Builder.CreateUnreachable();
7008 if (ClearInsertionPoint)
7009 CGF.Builder.ClearInsertionPoint();
7013 CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
7014 bool ForDefinition) {
7015 llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
7017 // If we don't need a definition, return the entry if found or check
7018 // if we use an external reference.
7019 if (!ForDefinition) {
7023 // If this type (or a super class) has the __objc_exception__
7024 // attribute, emit an external reference.
7025 if (hasObjCExceptionAttribute(CGM.getContext(), ID))
7027 new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7028 llvm::GlobalValue::ExternalLinkage,
7031 ID->getIdentifier()->getName()));
7034 // Otherwise we need to either make a new entry or fill in the
7036 assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
7037 std::string ClassName(getClassSymbolPrefix() + ID->getNameAsString());
7038 std::string VTableName = "objc_ehtype_vtable";
7039 llvm::GlobalVariable *VTableGV =
7040 CGM.getModule().getGlobalVariable(VTableName);
7042 VTableGV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy,
7044 llvm::GlobalValue::ExternalLinkage,
7047 llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
7049 llvm::Constant *Values[] = {
7050 llvm::ConstantExpr::getGetElementPtr(VTableGV, VTableIdx),
7051 GetClassName(ID->getIdentifier()),
7052 GetClassGlobal(ClassName)
7054 llvm::Constant *Init =
7055 llvm::ConstantStruct::get(ObjCTypes.EHTypeTy, Values);
7058 Entry->setInitializer(Init);
7060 Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7061 llvm::GlobalValue::WeakAnyLinkage,
7064 ID->getIdentifier()->getName()));
7067 if (ID->getVisibility() == HiddenVisibility)
7068 Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7069 Entry->setAlignment(CGM.getDataLayout().getABITypeAlignment(
7070 ObjCTypes.EHTypeTy));
7072 if (ForDefinition) {
7073 Entry->setSection("__DATA,__objc_const");
7074 Entry->setLinkage(llvm::GlobalValue::ExternalLinkage);
7076 Entry->setSection("__DATA,__datacoal_nt,coalesced");
7084 CodeGen::CGObjCRuntime *
7085 CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
7086 switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
7087 case ObjCRuntime::FragileMacOSX:
7088 return new CGObjCMac(CGM);
7090 case ObjCRuntime::MacOSX:
7091 case ObjCRuntime::iOS:
7092 return new CGObjCNonFragileABIMac(CGM);
7094 case ObjCRuntime::GNUstep:
7095 case ObjCRuntime::GCC:
7096 case ObjCRuntime::ObjFW:
7097 llvm_unreachable("these runtimes are not Mac runtimes");
7099 llvm_unreachable("bad runtime");