clang  3.9.0svn
CGObjCMac.cpp
Go to the documentation of this file.
1 //===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This provides Objective-C code generation targeting the Apple runtime.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CGObjCRuntime.h"
15 #include "CGBlocks.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"
28 #include "llvm/ADT/DenseSet.h"
29 #include "llvm/ADT/SetVector.h"
30 #include "llvm/ADT/SmallPtrSet.h"
31 #include "llvm/ADT/SmallString.h"
32 #include "llvm/IR/CallSite.h"
33 #include "llvm/IR/DataLayout.h"
34 #include "llvm/IR/InlineAsm.h"
35 #include "llvm/IR/IntrinsicInst.h"
36 #include "llvm/IR/LLVMContext.h"
37 #include "llvm/IR/Module.h"
38 #include "llvm/Support/raw_ostream.h"
39 #include <cstdio>
40 
41 using namespace clang;
42 using namespace CodeGen;
43 
44 namespace {
45 
46 // FIXME: We should find a nicer way to make the labels for metadata, string
47 // concatenation is lame.
48 
49 class ObjCCommonTypesHelper {
50 protected:
51  llvm::LLVMContext &VMContext;
52 
53 private:
54  // The types of these functions don't really matter because we
55  // should always bitcast before calling them.
56 
57  /// id objc_msgSend (id, SEL, ...)
58  ///
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
63  // be called a lot.
64  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
65  return
66  CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
67  params, true),
68  "objc_msgSend",
69  llvm::AttributeSet::get(CGM.getLLVMContext(),
70  llvm::AttributeSet::FunctionIndex,
71  llvm::Attribute::NonLazyBind));
72  }
73 
74  /// void objc_msgSend_stret (id, SEL, ...)
75  ///
76  /// The messenger used when the return value is an aggregate returned
77  /// by indirect reference in the first argument, and therefore the
78  /// self and selector parameters are shifted over by one.
79  llvm::Constant *getMessageSendStretFn() const {
80  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
81  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
82  params, true),
83  "objc_msgSend_stret");
84 
85  }
86 
87  /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
88  ///
89  /// The messenger used when the return value is returned on the x87
90  /// floating-point stack; without a special entrypoint, the nil case
91  /// would be unbalanced.
92  llvm::Constant *getMessageSendFpretFn() const {
93  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
94  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
95  params, true),
96  "objc_msgSend_fpret");
97 
98  }
99 
100  /// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
101  ///
102  /// The messenger used when the return value is returned in two values on the
103  /// x87 floating point stack; without a special entrypoint, the nil case
104  /// would be unbalanced. Only used on 64-bit X86.
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, nullptr);
110 
111  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType,
112  params, true),
113  "objc_msgSend_fp2ret");
114  }
115 
116  /// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
117  ///
118  /// The messenger used for super calls, which have different dispatch
119  /// semantics. The class passed is the superclass of the current
120  /// class.
121  llvm::Constant *getMessageSendSuperFn() const {
122  llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
123  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
124  params, true),
125  "objc_msgSendSuper");
126  }
127 
128  /// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
129  ///
130  /// A slightly different messenger used for super calls. The class
131  /// passed is the current class.
132  llvm::Constant *getMessageSendSuperFn2() const {
133  llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
134  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
135  params, true),
136  "objc_msgSendSuper2");
137  }
138 
139  /// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super,
140  /// SEL op, ...)
141  ///
142  /// The messenger used for super calls which return an aggregate indirectly.
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");
148  }
149 
150  /// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
151  /// SEL op, ...)
152  ///
153  /// objc_msgSendSuper_stret with the super2 semantics.
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");
159  }
160 
161  llvm::Constant *getMessageSendSuperFpretFn() const {
162  // There is no objc_msgSendSuper_fpret? How can that work?
163  return getMessageSendSuperFn();
164  }
165 
166  llvm::Constant *getMessageSendSuperFpretFn2() const {
167  // There is no objc_msgSendSuper_fpret? How can that work?
168  return getMessageSendSuperFn2();
169  }
170 
171 protected:
173 
174 public:
175  llvm::Type *ShortTy, *IntTy, *LongTy, *LongLongTy;
176  llvm::Type *Int8PtrTy, *Int8PtrPtrTy;
177  llvm::Type *IvarOffsetVarTy;
178 
179  /// ObjectPtrTy - LLVM type for object handles (typeof(id))
180  llvm::Type *ObjectPtrTy;
181 
182  /// PtrObjectPtrTy - LLVM type for id *
183  llvm::Type *PtrObjectPtrTy;
184 
185  /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
186  llvm::Type *SelectorPtrTy;
187 
188 private:
189  /// ProtocolPtrTy - LLVM type for external protocol handles
190  /// (typeof(Protocol))
191  llvm::Type *ExternalProtocolPtrTy;
192 
193 public:
194  llvm::Type *getExternalProtocolPtrTy() {
195  if (!ExternalProtocolPtrTy) {
196  // FIXME: It would be nice to unify this with the opaque type, so that the
197  // IR comes out a bit cleaner.
198  CodeGen::CodeGenTypes &Types = CGM.getTypes();
199  ASTContext &Ctx = CGM.getContext();
200  llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
201  ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
202  }
203 
204  return ExternalProtocolPtrTy;
205  }
206 
207  // SuperCTy - clang type for struct objc_super.
208  QualType SuperCTy;
209  // SuperPtrCTy - clang type for struct objc_super *.
210  QualType SuperPtrCTy;
211 
212  /// SuperTy - LLVM type for struct objc_super.
213  llvm::StructType *SuperTy;
214  /// SuperPtrTy - LLVM type for struct objc_super *.
215  llvm::Type *SuperPtrTy;
216 
217  /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
218  /// in GCC parlance).
219  llvm::StructType *PropertyTy;
220 
221  /// PropertyListTy - LLVM type for struct objc_property_list
222  /// (_prop_list_t in GCC parlance).
223  llvm::StructType *PropertyListTy;
224  /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
225  llvm::Type *PropertyListPtrTy;
226 
227  // MethodTy - LLVM type for struct objc_method.
228  llvm::StructType *MethodTy;
229 
230  /// CacheTy - LLVM type for struct objc_cache.
231  llvm::Type *CacheTy;
232  /// CachePtrTy - LLVM type for struct objc_cache *.
233  llvm::Type *CachePtrTy;
234 
235  llvm::Constant *getGetPropertyFn() {
236  CodeGen::CodeGenTypes &Types = CGM.getTypes();
237  ASTContext &Ctx = CGM.getContext();
238  // id objc_getProperty (id, SEL, ptrdiff_t, bool)
240  CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
241  CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
242  Params.push_back(IdType);
243  Params.push_back(SelType);
244  Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
245  Params.push_back(Ctx.BoolTy);
246  llvm::FunctionType *FTy =
247  Types.GetFunctionType(
248  Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
249  return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
250  }
251 
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)
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(
267  Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
268  return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
269  }
270 
271  llvm::Constant *getOptimizedSetPropertyFn(bool atomic, bool copy) {
272  CodeGen::CodeGenTypes &Types = CGM.getTypes();
273  ASTContext &Ctx = CGM.getContext();
274  // void objc_setProperty_atomic(id self, SEL _cmd,
275  // id newValue, ptrdiff_t offset);
276  // void objc_setProperty_nonatomic(id self, SEL _cmd,
277  // id newValue, ptrdiff_t offset);
278  // void objc_setProperty_atomic_copy(id self, SEL _cmd,
279  // id newValue, ptrdiff_t offset);
280  // void objc_setProperty_nonatomic_copy(id self, SEL _cmd,
281  // id newValue, ptrdiff_t offset);
282 
284  CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
285  CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
286  Params.push_back(IdType);
287  Params.push_back(SelType);
288  Params.push_back(IdType);
289  Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
290  llvm::FunctionType *FTy =
291  Types.GetFunctionType(
292  Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
293  const char *name;
294  if (atomic && copy)
295  name = "objc_setProperty_atomic_copy";
296  else if (atomic && !copy)
297  name = "objc_setProperty_atomic";
298  else if (!atomic && copy)
299  name = "objc_setProperty_nonatomic_copy";
300  else
301  name = "objc_setProperty_nonatomic";
302 
303  return CGM.CreateRuntimeFunction(FTy, name);
304  }
305 
306  llvm::Constant *getCopyStructFn() {
307  CodeGen::CodeGenTypes &Types = CGM.getTypes();
308  ASTContext &Ctx = CGM.getContext();
309  // void objc_copyStruct (void *, const void *, size_t, bool, bool)
311  Params.push_back(Ctx.VoidPtrTy);
312  Params.push_back(Ctx.VoidPtrTy);
313  Params.push_back(Ctx.LongTy);
314  Params.push_back(Ctx.BoolTy);
315  Params.push_back(Ctx.BoolTy);
316  llvm::FunctionType *FTy =
317  Types.GetFunctionType(
318  Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
319  return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
320  }
321 
322  /// This routine declares and returns address of:
323  /// void objc_copyCppObjectAtomic(
324  /// void *dest, const void *src,
325  /// void (*copyHelper) (void *dest, const void *source));
326  llvm::Constant *getCppAtomicObjectFunction() {
327  CodeGen::CodeGenTypes &Types = CGM.getTypes();
328  ASTContext &Ctx = CGM.getContext();
329  /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
331  Params.push_back(Ctx.VoidPtrTy);
332  Params.push_back(Ctx.VoidPtrTy);
333  Params.push_back(Ctx.VoidPtrTy);
334  llvm::FunctionType *FTy =
335  Types.GetFunctionType(
336  Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
337  return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
338  }
339 
340  llvm::Constant *getEnumerationMutationFn() {
341  CodeGen::CodeGenTypes &Types = CGM.getTypes();
342  ASTContext &Ctx = CGM.getContext();
343  // void objc_enumerationMutation (id)
345  Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
346  llvm::FunctionType *FTy =
347  Types.GetFunctionType(
348  Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
349  return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
350  }
351 
352  llvm::Constant *getLookUpClassFn() {
353  CodeGen::CodeGenTypes &Types = CGM.getTypes();
354  ASTContext &Ctx = CGM.getContext();
355  // Class objc_lookUpClass (const char *)
357  Params.push_back(
359  llvm::FunctionType *FTy =
362  Params));
363  return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass");
364  }
365 
366  /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
367  llvm::Constant *getGcReadWeakFn() {
368  // id objc_read_weak (id *)
369  llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
370  llvm::FunctionType *FTy =
371  llvm::FunctionType::get(ObjectPtrTy, args, false);
372  return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
373  }
374 
375  /// GcAssignWeakFn -- LLVM objc_assign_weak function.
376  llvm::Constant *getGcAssignWeakFn() {
377  // id objc_assign_weak (id, id *)
378  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
379  llvm::FunctionType *FTy =
380  llvm::FunctionType::get(ObjectPtrTy, args, false);
381  return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
382  }
383 
384  /// GcAssignGlobalFn -- LLVM objc_assign_global function.
385  llvm::Constant *getGcAssignGlobalFn() {
386  // id objc_assign_global(id, id *)
387  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
388  llvm::FunctionType *FTy =
389  llvm::FunctionType::get(ObjectPtrTy, args, false);
390  return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
391  }
392 
393  /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
394  llvm::Constant *getGcAssignThreadLocalFn() {
395  // id objc_assign_threadlocal(id src, id * dest)
396  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
397  llvm::FunctionType *FTy =
398  llvm::FunctionType::get(ObjectPtrTy, args, false);
399  return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
400  }
401 
402  /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
403  llvm::Constant *getGcAssignIvarFn() {
404  // id objc_assign_ivar(id, id *, ptrdiff_t)
405  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
406  CGM.PtrDiffTy };
407  llvm::FunctionType *FTy =
408  llvm::FunctionType::get(ObjectPtrTy, args, false);
409  return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
410  }
411 
412  /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
413  llvm::Constant *GcMemmoveCollectableFn() {
414  // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
415  llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
416  llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
417  return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
418  }
419 
420  /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
421  llvm::Constant *getGcAssignStrongCastFn() {
422  // id objc_assign_strongCast(id, id *)
423  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
424  llvm::FunctionType *FTy =
425  llvm::FunctionType::get(ObjectPtrTy, args, false);
426  return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
427  }
428 
429  /// ExceptionThrowFn - LLVM objc_exception_throw function.
430  llvm::Constant *getExceptionThrowFn() {
431  // void objc_exception_throw(id)
432  llvm::Type *args[] = { ObjectPtrTy };
433  llvm::FunctionType *FTy =
434  llvm::FunctionType::get(CGM.VoidTy, args, false);
435  return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
436  }
437 
438  /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
439  llvm::Constant *getExceptionRethrowFn() {
440  // void objc_exception_rethrow(void)
441  llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
442  return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
443  }
444 
445  /// SyncEnterFn - LLVM object_sync_enter function.
446  llvm::Constant *getSyncEnterFn() {
447  // int objc_sync_enter (id)
448  llvm::Type *args[] = { ObjectPtrTy };
449  llvm::FunctionType *FTy =
450  llvm::FunctionType::get(CGM.IntTy, args, false);
451  return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
452  }
453 
454  /// SyncExitFn - LLVM object_sync_exit function.
455  llvm::Constant *getSyncExitFn() {
456  // int objc_sync_exit (id)
457  llvm::Type *args[] = { ObjectPtrTy };
458  llvm::FunctionType *FTy =
459  llvm::FunctionType::get(CGM.IntTy, args, false);
460  return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
461  }
462 
463  llvm::Constant *getSendFn(bool IsSuper) const {
464  return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
465  }
466 
467  llvm::Constant *getSendFn2(bool IsSuper) const {
468  return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
469  }
470 
471  llvm::Constant *getSendStretFn(bool IsSuper) const {
472  return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
473  }
474 
475  llvm::Constant *getSendStretFn2(bool IsSuper) const {
476  return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
477  }
478 
479  llvm::Constant *getSendFpretFn(bool IsSuper) const {
480  return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
481  }
482 
483  llvm::Constant *getSendFpretFn2(bool IsSuper) const {
484  return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
485  }
486 
487  llvm::Constant *getSendFp2retFn(bool IsSuper) const {
488  return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
489  }
490 
491  llvm::Constant *getSendFp2RetFn2(bool IsSuper) const {
492  return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn();
493  }
494 
495  ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
496 };
497 
498 /// ObjCTypesHelper - Helper class that encapsulates lazy
499 /// construction of varies types used during ObjC generation.
500 class ObjCTypesHelper : public ObjCCommonTypesHelper {
501 public:
502  /// SymtabTy - LLVM type for struct objc_symtab.
503  llvm::StructType *SymtabTy;
504  /// SymtabPtrTy - LLVM type for struct objc_symtab *.
505  llvm::Type *SymtabPtrTy;
506  /// ModuleTy - LLVM type for struct objc_module.
507  llvm::StructType *ModuleTy;
508 
509  /// ProtocolTy - LLVM type for struct objc_protocol.
510  llvm::StructType *ProtocolTy;
511  /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
512  llvm::Type *ProtocolPtrTy;
513  /// ProtocolExtensionTy - LLVM type for struct
514  /// objc_protocol_extension.
515  llvm::StructType *ProtocolExtensionTy;
516  /// ProtocolExtensionTy - LLVM type for struct
517  /// objc_protocol_extension *.
518  llvm::Type *ProtocolExtensionPtrTy;
519  /// MethodDescriptionTy - LLVM type for struct
520  /// objc_method_description.
521  llvm::StructType *MethodDescriptionTy;
522  /// MethodDescriptionListTy - LLVM type for struct
523  /// objc_method_description_list.
524  llvm::StructType *MethodDescriptionListTy;
525  /// MethodDescriptionListPtrTy - LLVM type for struct
526  /// objc_method_description_list *.
527  llvm::Type *MethodDescriptionListPtrTy;
528  /// ProtocolListTy - LLVM type for struct objc_property_list.
529  llvm::StructType *ProtocolListTy;
530  /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
531  llvm::Type *ProtocolListPtrTy;
532  /// CategoryTy - LLVM type for struct objc_category.
533  llvm::StructType *CategoryTy;
534  /// ClassTy - LLVM type for struct objc_class.
535  llvm::StructType *ClassTy;
536  /// ClassPtrTy - LLVM type for struct objc_class *.
537  llvm::Type *ClassPtrTy;
538  /// ClassExtensionTy - LLVM type for struct objc_class_ext.
539  llvm::StructType *ClassExtensionTy;
540  /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
541  llvm::Type *ClassExtensionPtrTy;
542  // IvarTy - LLVM type for struct objc_ivar.
543  llvm::StructType *IvarTy;
544  /// IvarListTy - LLVM type for struct objc_ivar_list.
545  llvm::Type *IvarListTy;
546  /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
547  llvm::Type *IvarListPtrTy;
548  /// MethodListTy - LLVM type for struct objc_method_list.
549  llvm::Type *MethodListTy;
550  /// MethodListPtrTy - LLVM type for struct objc_method_list *.
551  llvm::Type *MethodListPtrTy;
552 
553  /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
554  llvm::Type *ExceptionDataTy;
555 
556  /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
557  llvm::Constant *getExceptionTryEnterFn() {
558  llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
559  return CGM.CreateRuntimeFunction(
560  llvm::FunctionType::get(CGM.VoidTy, params, false),
561  "objc_exception_try_enter");
562  }
563 
564  /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
565  llvm::Constant *getExceptionTryExitFn() {
566  llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
567  return CGM.CreateRuntimeFunction(
568  llvm::FunctionType::get(CGM.VoidTy, params, false),
569  "objc_exception_try_exit");
570  }
571 
572  /// ExceptionExtractFn - LLVM objc_exception_extract function.
573  llvm::Constant *getExceptionExtractFn() {
574  llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
575  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
576  params, false),
577  "objc_exception_extract");
578  }
579 
580  /// ExceptionMatchFn - LLVM objc_exception_match function.
581  llvm::Constant *getExceptionMatchFn() {
582  llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
583  return CGM.CreateRuntimeFunction(
584  llvm::FunctionType::get(CGM.Int32Ty, params, false),
585  "objc_exception_match");
586  }
587 
588  /// SetJmpFn - LLVM _setjmp function.
589  llvm::Constant *getSetJmpFn() {
590  // This is specifically the prototype for x86.
591  llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
592  return
593  CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty,
594  params, false),
595  "_setjmp",
596  llvm::AttributeSet::get(CGM.getLLVMContext(),
597  llvm::AttributeSet::FunctionIndex,
598  llvm::Attribute::NonLazyBind));
599  }
600 
601 public:
602  ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
603 };
604 
605 /// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
606 /// modern abi
607 class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
608 public:
609  // MethodListnfABITy - LLVM for struct _method_list_t
610  llvm::StructType *MethodListnfABITy;
611 
612  // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
613  llvm::Type *MethodListnfABIPtrTy;
614 
615  // ProtocolnfABITy = LLVM for struct _protocol_t
616  llvm::StructType *ProtocolnfABITy;
617 
618  // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
619  llvm::Type *ProtocolnfABIPtrTy;
620 
621  // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
622  llvm::StructType *ProtocolListnfABITy;
623 
624  // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
625  llvm::Type *ProtocolListnfABIPtrTy;
626 
627  // ClassnfABITy - LLVM for struct _class_t
628  llvm::StructType *ClassnfABITy;
629 
630  // ClassnfABIPtrTy - LLVM for struct _class_t*
631  llvm::Type *ClassnfABIPtrTy;
632 
633  // IvarnfABITy - LLVM for struct _ivar_t
634  llvm::StructType *IvarnfABITy;
635 
636  // IvarListnfABITy - LLVM for struct _ivar_list_t
637  llvm::StructType *IvarListnfABITy;
638 
639  // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
640  llvm::Type *IvarListnfABIPtrTy;
641 
642  // ClassRonfABITy - LLVM for struct _class_ro_t
643  llvm::StructType *ClassRonfABITy;
644 
645  // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
646  llvm::Type *ImpnfABITy;
647 
648  // CategorynfABITy - LLVM for struct _category_t
649  llvm::StructType *CategorynfABITy;
650 
651  // New types for nonfragile abi messaging.
652 
653  // MessageRefTy - LLVM for:
654  // struct _message_ref_t {
655  // IMP messenger;
656  // SEL name;
657  // };
658  llvm::StructType *MessageRefTy;
659  // MessageRefCTy - clang type for struct _message_ref_t
660  QualType MessageRefCTy;
661 
662  // MessageRefPtrTy - LLVM for struct _message_ref_t*
663  llvm::Type *MessageRefPtrTy;
664  // MessageRefCPtrTy - clang type for struct _message_ref_t*
665  QualType MessageRefCPtrTy;
666 
667  // SuperMessageRefTy - LLVM for:
668  // struct _super_message_ref_t {
669  // SUPER_IMP messenger;
670  // SEL name;
671  // };
672  llvm::StructType *SuperMessageRefTy;
673 
674  // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
675  llvm::Type *SuperMessageRefPtrTy;
676 
677  llvm::Constant *getMessageSendFixupFn() {
678  // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
679  llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
680  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
681  params, true),
682  "objc_msgSend_fixup");
683  }
684 
685  llvm::Constant *getMessageSendFpretFixupFn() {
686  // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
687  llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
688  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
689  params, true),
690  "objc_msgSend_fpret_fixup");
691  }
692 
693  llvm::Constant *getMessageSendStretFixupFn() {
694  // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
695  llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
696  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
697  params, true),
698  "objc_msgSend_stret_fixup");
699  }
700 
701  llvm::Constant *getMessageSendSuper2FixupFn() {
702  // id objc_msgSendSuper2_fixup (struct objc_super *,
703  // struct _super_message_ref_t*, ...)
704  llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
705  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
706  params, true),
707  "objc_msgSendSuper2_fixup");
708  }
709 
710  llvm::Constant *getMessageSendSuper2StretFixupFn() {
711  // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
712  // struct _super_message_ref_t*, ...)
713  llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
714  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
715  params, true),
716  "objc_msgSendSuper2_stret_fixup");
717  }
718 
719  llvm::Constant *getObjCEndCatchFn() {
720  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
721  "objc_end_catch");
722 
723  }
724 
725  llvm::Constant *getObjCBeginCatchFn() {
726  llvm::Type *params[] = { Int8PtrTy };
727  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
728  params, false),
729  "objc_begin_catch");
730  }
731 
732  llvm::StructType *EHTypeTy;
733  llvm::Type *EHTypePtrTy;
734 
735  ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
736 };
737 
738 class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
739 public:
740  class SKIP_SCAN {
741  public:
742  unsigned skip;
743  unsigned scan;
744  SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
745  : skip(_skip), scan(_scan) {}
746  };
747 
748  /// opcode for captured block variables layout 'instructions'.
749  /// In the following descriptions, 'I' is the value of the immediate field.
750  /// (field following the opcode).
751  ///
752  enum BLOCK_LAYOUT_OPCODE {
753  /// An operator which affects how the following layout should be
754  /// interpreted.
755  /// I == 0: Halt interpretation and treat everything else as
756  /// a non-pointer. Note that this instruction is equal
757  /// to '\0'.
758  /// I != 0: Currently unused.
759  BLOCK_LAYOUT_OPERATOR = 0,
760 
761  /// The next I+1 bytes do not contain a value of object pointer type.
762  /// Note that this can leave the stream unaligned, meaning that
763  /// subsequent word-size instructions do not begin at a multiple of
764  /// the pointer size.
765  BLOCK_LAYOUT_NON_OBJECT_BYTES = 1,
766 
767  /// The next I+1 words do not contain a value of object pointer type.
768  /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
769  /// when the required skip quantity is a multiple of the pointer size.
770  BLOCK_LAYOUT_NON_OBJECT_WORDS = 2,
771 
772  /// The next I+1 words are __strong pointers to Objective-C
773  /// objects or blocks.
774  BLOCK_LAYOUT_STRONG = 3,
775 
776  /// The next I+1 words are pointers to __block variables.
777  BLOCK_LAYOUT_BYREF = 4,
778 
779  /// The next I+1 words are __weak pointers to Objective-C
780  /// objects or blocks.
781  BLOCK_LAYOUT_WEAK = 5,
782 
783  /// The next I+1 words are __unsafe_unretained pointers to
784  /// Objective-C objects or blocks.
785  BLOCK_LAYOUT_UNRETAINED = 6
786 
787  /// The next I+1 words are block or object pointers with some
788  /// as-yet-unspecified ownership semantics. If we add more
789  /// flavors of ownership semantics, values will be taken from
790  /// this range.
791  ///
792  /// This is included so that older tools can at least continue
793  /// processing the layout past such things.
794  //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
795 
796  /// All other opcodes are reserved. Halt interpretation and
797  /// treat everything else as opaque.
798  };
799 
800  class RUN_SKIP {
801  public:
802  enum BLOCK_LAYOUT_OPCODE opcode;
803  CharUnits block_var_bytepos;
804  CharUnits block_var_size;
805  RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
806  CharUnits BytePos = CharUnits::Zero(),
807  CharUnits Size = CharUnits::Zero())
808  : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {}
809 
810  // Allow sorting based on byte pos.
811  bool operator<(const RUN_SKIP &b) const {
812  return block_var_bytepos < b.block_var_bytepos;
813  }
814  };
815 
816 protected:
817  llvm::LLVMContext &VMContext;
818  // FIXME! May not be needing this after all.
819  unsigned ObjCABI;
820 
821  // arc/mrr layout of captured block literal variables.
822  SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
823 
824  /// LazySymbols - Symbols to generate a lazy reference for. See
825  /// DefinedSymbols and FinishModule().
826  llvm::SetVector<IdentifierInfo*> LazySymbols;
827 
828  /// DefinedSymbols - External symbols which are defined by this
829  /// module. The symbols in this list and LazySymbols are used to add
830  /// special linker symbols which ensure that Objective-C modules are
831  /// linked properly.
832  llvm::SetVector<IdentifierInfo*> DefinedSymbols;
833 
834  /// ClassNames - uniqued class names.
835  llvm::StringMap<llvm::GlobalVariable*> ClassNames;
836 
837  /// MethodVarNames - uniqued method variable names.
838  llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
839 
840  /// DefinedCategoryNames - list of category names in form Class_Category.
841  llvm::SmallSetVector<std::string, 16> DefinedCategoryNames;
842 
843  /// MethodVarTypes - uniqued method type signatures. We have to use
844  /// a StringMap here because have no other unique reference.
845  llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
846 
847  /// MethodDefinitions - map of methods which have been defined in
848  /// this translation unit.
849  llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
850 
851  /// PropertyNames - uniqued method variable names.
852  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
853 
854  /// ClassReferences - uniqued class references.
855  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
856 
857  /// SelectorReferences - uniqued selector references.
858  llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
859 
860  /// Protocols - Protocols for which an objc_protocol structure has
861  /// been emitted. Forward declarations are handled by creating an
862  /// empty structure whose initializer is filled in when/if defined.
863  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
864 
865  /// DefinedProtocols - Protocols which have actually been
866  /// defined. We should not need this, see FIXME in GenerateProtocol.
867  llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
868 
869  /// DefinedClasses - List of defined classes.
871 
872  /// ImplementedClasses - List of @implemented classes.
874 
875  /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
876  SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
877 
878  /// DefinedCategories - List of defined categories.
879  SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
880 
881  /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
882  SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
883 
884  /// GetNameForMethod - Return a name for the given method.
885  /// \param[out] NameOut - The return value.
886  void GetNameForMethod(const ObjCMethodDecl *OMD,
887  const ObjCContainerDecl *CD,
888  SmallVectorImpl<char> &NameOut);
889 
890  /// GetMethodVarName - Return a unique constant for the given
891  /// selector's name. The return value has type char *.
892  llvm::Constant *GetMethodVarName(Selector Sel);
893  llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
894 
895  /// GetMethodVarType - Return a unique constant for the given
896  /// method's type encoding string. The return value has type char *.
897 
898  // FIXME: This is a horrible name.
899  llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
900  bool Extended = false);
901  llvm::Constant *GetMethodVarType(const FieldDecl *D);
902 
903  /// GetPropertyName - Return a unique constant for the given
904  /// name. The return value has type char *.
905  llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
906 
907  // FIXME: This can be dropped once string functions are unified.
908  llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
909  const Decl *Container);
910 
911  /// GetClassName - Return a unique constant for the given selector's
912  /// runtime name (which may change via use of objc_runtime_name attribute on
913  /// class or protocol definition. The return value has type char *.
914  llvm::Constant *GetClassName(StringRef RuntimeName);
915 
916  llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
917 
918  /// BuildIvarLayout - Builds ivar layout bitmap for the class
919  /// implementation for the __strong or __weak case.
920  ///
921  /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there
922  /// are any weak ivars defined directly in the class. Meaningless unless
923  /// building a weak layout. Does not guarantee that the layout will
924  /// actually have any entries, because the ivar might be under-aligned.
925  llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
926  CharUnits beginOffset,
927  CharUnits endOffset,
928  bool forStrongLayout,
929  bool hasMRCWeakIvars);
930 
931  llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,
932  CharUnits beginOffset,
933  CharUnits endOffset) {
934  return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
935  }
936 
937  llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
938  CharUnits beginOffset,
939  CharUnits endOffset,
940  bool hasMRCWeakIvars) {
941  return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
942  }
943 
944  Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
945 
946  void UpdateRunSkipBlockVars(bool IsByref,
947  Qualifiers::ObjCLifetime LifeTime,
948  CharUnits FieldOffset,
949  CharUnits FieldSize);
950 
951  void BuildRCBlockVarRecordLayout(const RecordType *RT,
952  CharUnits BytePos, bool &HasUnion,
953  bool ByrefLayout=false);
954 
955  void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
956  const RecordDecl *RD,
957  ArrayRef<const FieldDecl*> RecFields,
958  CharUnits BytePos, bool &HasUnion,
959  bool ByrefLayout);
960 
961  uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
962 
963  llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
964 
965  /// GetIvarLayoutName - Returns a unique constant for the given
966  /// ivar layout bitmap.
967  llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
968  const ObjCCommonTypesHelper &ObjCTypes);
969 
970  /// EmitPropertyList - Emit the given property list. The return
971  /// value has type PropertyListPtrTy.
972  llvm::Constant *EmitPropertyList(Twine Name,
973  const Decl *Container,
974  const ObjCContainerDecl *OCD,
975  const ObjCCommonTypesHelper &ObjCTypes,
976  bool IsClassProperty);
977 
978  /// EmitProtocolMethodTypes - Generate the array of extended method type
979  /// strings. The return value has type Int8PtrPtrTy.
980  llvm::Constant *EmitProtocolMethodTypes(Twine Name,
981  ArrayRef<llvm::Constant*> MethodTypes,
982  const ObjCCommonTypesHelper &ObjCTypes);
983 
984  /// PushProtocolProperties - Push protocol's property on the input stack.
985  void PushProtocolProperties(
986  llvm::SmallPtrSet<const IdentifierInfo*, 16> &PropertySet,
988  const Decl *Container,
989  const ObjCProtocolDecl *Proto,
990  const ObjCCommonTypesHelper &ObjCTypes,
991  bool IsClassProperty);
992 
993  /// GetProtocolRef - Return a reference to the internal protocol
994  /// description, creating an empty one if it has not been
995  /// defined. The return value has type ProtocolPtrTy.
996  llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
997 
998  /// Return a reference to the given Class using runtime calls rather than
999  /// by a symbol reference.
1000  llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,
1001  const ObjCInterfaceDecl *ID,
1002  ObjCCommonTypesHelper &ObjCTypes);
1003 
1004 public:
1005  /// CreateMetadataVar - Create a global variable with internal
1006  /// linkage for use by the Objective-C runtime.
1007  ///
1008  /// This is a convenience wrapper which not only creates the
1009  /// variable, but also sets the section and alignment and adds the
1010  /// global to the "llvm.used" list.
1011  ///
1012  /// \param Name - The variable name.
1013  /// \param Init - The variable initializer; this is also used to
1014  /// define the type of the variable.
1015  /// \param Section - The section the variable should go into, or empty.
1016  /// \param Align - The alignment for the variable, or 0.
1017  /// \param AddToUsed - Whether the variable should be added to
1018  /// "llvm.used".
1019  llvm::GlobalVariable *CreateMetadataVar(Twine Name, llvm::Constant *Init,
1020  StringRef Section, CharUnits Align,
1021  bool AddToUsed);
1022 
1023 protected:
1024  CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1025  ReturnValueSlot Return,
1026  QualType ResultType,
1027  llvm::Value *Sel,
1028  llvm::Value *Arg0,
1029  QualType Arg0Ty,
1030  bool IsSuper,
1031  const CallArgList &CallArgs,
1032  const ObjCMethodDecl *OMD,
1033  const ObjCInterfaceDecl *ClassReceiver,
1034  const ObjCCommonTypesHelper &ObjCTypes);
1035 
1036  /// EmitImageInfo - Emit the image info marker used to encode some module
1037  /// level information.
1038  void EmitImageInfo();
1039 
1040 public:
1041  CGObjCCommonMac(CodeGen::CodeGenModule &cgm) :
1042  CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) { }
1043 
1044  bool isNonFragileABI() const {
1045  return ObjCABI == 2;
1046  }
1047 
1048  ConstantAddress GenerateConstantString(const StringLiteral *SL) override;
1049 
1050  llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1051  const ObjCContainerDecl *CD=nullptr) override;
1052 
1053  void GenerateProtocol(const ObjCProtocolDecl *PD) override;
1054 
1055  /// GetOrEmitProtocol - Get the protocol object for the given
1056  /// declaration, emitting it if necessary. The return value has type
1057  /// ProtocolPtrTy.
1058  virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
1059 
1060  /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1061  /// object for the given declaration, emitting it if needed. These
1062  /// forward references will be filled in with empty bodies if no
1063  /// definition is seen. The return value has type ProtocolPtrTy.
1064  virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1065  llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1066  const CGBlockInfo &blockInfo) override;
1067  llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1068  const CGBlockInfo &blockInfo) override;
1069 
1070  llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1071  QualType T) override;
1072 };
1073 
1074 class CGObjCMac : public CGObjCCommonMac {
1075 private:
1076  ObjCTypesHelper ObjCTypes;
1077 
1078  /// EmitModuleInfo - Another marker encoding module level
1079  /// information.
1080  void EmitModuleInfo();
1081 
1082  /// EmitModuleSymols - Emit module symbols, the list of defined
1083  /// classes and categories. The result has type SymtabPtrTy.
1084  llvm::Constant *EmitModuleSymbols();
1085 
1086  /// FinishModule - Write out global data structures at the end of
1087  /// processing a translation unit.
1088  void FinishModule();
1089 
1090  /// EmitClassExtension - Generate the class extension structure used
1091  /// to store the weak ivar layout and properties. The return value
1092  /// has type ClassExtensionPtrTy.
1093  llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID,
1094  CharUnits instanceSize,
1095  bool hasMRCWeakIvars,
1096  bool isClassProperty);
1097 
1098  /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1099  /// for the given class.
1100  llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1101  const ObjCInterfaceDecl *ID);
1102 
1103  llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1104  IdentifierInfo *II);
1105 
1106  llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1107 
1108  /// EmitSuperClassRef - Emits reference to class's main metadata class.
1109  llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1110 
1111  /// EmitIvarList - Emit the ivar list for the given
1112  /// implementation. If ForClass is true the list of class ivars
1113  /// (i.e. metaclass ivars) is emitted, otherwise the list of
1114  /// interface ivars will be emitted. The return value has type
1115  /// IvarListPtrTy.
1116  llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1117  bool ForClass);
1118 
1119  /// EmitMetaClass - Emit a forward reference to the class structure
1120  /// for the metaclass of the given interface. The return value has
1121  /// type ClassPtrTy.
1122  llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1123 
1124  /// EmitMetaClass - Emit a class structure for the metaclass of the
1125  /// given implementation. The return value has type ClassPtrTy.
1126  llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1127  llvm::Constant *Protocols,
1128  ArrayRef<llvm::Constant*> Methods);
1129 
1130  llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
1131 
1132  llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
1133 
1134  /// EmitMethodList - Emit the method list for the given
1135  /// implementation. The return value has type MethodListPtrTy.
1136  llvm::Constant *EmitMethodList(Twine Name, StringRef Section,
1137  ArrayRef<llvm::Constant *> Methods);
1138 
1139  /// EmitMethodDescList - Emit a method description list for a list of
1140  /// method declarations.
1141  /// - TypeName: The name for the type containing the methods.
1142  /// - IsProtocol: True iff these methods are for a protocol.
1143  /// - ClassMethds: True iff these are class methods.
1144  /// - Required: When true, only "required" methods are
1145  /// listed. Similarly, when false only "optional" methods are
1146  /// listed. For classes this should always be true.
1147  /// - begin, end: The method list to output.
1148  ///
1149  /// The return value has type MethodDescriptionListPtrTy.
1150  llvm::Constant *EmitMethodDescList(Twine Name, StringRef Section,
1151  ArrayRef<llvm::Constant *> Methods);
1152 
1153  /// GetOrEmitProtocol - Get the protocol object for the given
1154  /// declaration, emitting it if necessary. The return value has type
1155  /// ProtocolPtrTy.
1156  llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1157 
1158  /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1159  /// object for the given declaration, emitting it if needed. These
1160  /// forward references will be filled in with empty bodies if no
1161  /// definition is seen. The return value has type ProtocolPtrTy.
1162  llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1163 
1164  /// EmitProtocolExtension - Generate the protocol extension
1165  /// structure used to store optional instance and class methods, and
1166  /// protocol properties. The return value has type
1167  /// ProtocolExtensionPtrTy.
1168  llvm::Constant *
1169  EmitProtocolExtension(const ObjCProtocolDecl *PD,
1170  ArrayRef<llvm::Constant*> OptInstanceMethods,
1171  ArrayRef<llvm::Constant*> OptClassMethods,
1172  ArrayRef<llvm::Constant*> MethodTypesExt);
1173 
1174  /// EmitProtocolList - Generate the list of referenced
1175  /// protocols. The return value has type ProtocolListPtrTy.
1176  llvm::Constant *EmitProtocolList(Twine Name,
1179 
1180  /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1181  /// for the given selector.
1182  llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1183  Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1184 
1185 public:
1186  CGObjCMac(CodeGen::CodeGenModule &cgm);
1187 
1188  llvm::Function *ModuleInitFunction() override;
1189 
1190  CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1191  ReturnValueSlot Return,
1192  QualType ResultType,
1193  Selector Sel, llvm::Value *Receiver,
1194  const CallArgList &CallArgs,
1195  const ObjCInterfaceDecl *Class,
1196  const ObjCMethodDecl *Method) override;
1197 
1199  GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1200  ReturnValueSlot Return, QualType ResultType,
1201  Selector Sel, const ObjCInterfaceDecl *Class,
1202  bool isCategoryImpl, llvm::Value *Receiver,
1203  bool IsClassMessage, const CallArgList &CallArgs,
1204  const ObjCMethodDecl *Method) override;
1205 
1206  llvm::Value *GetClass(CodeGenFunction &CGF,
1207  const ObjCInterfaceDecl *ID) override;
1208 
1209  llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
1210  Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
1211 
1212  /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1213  /// untyped one.
1214  llvm::Value *GetSelector(CodeGenFunction &CGF,
1215  const ObjCMethodDecl *Method) override;
1216 
1217  llvm::Constant *GetEHType(QualType T) override;
1218 
1219  void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1220 
1221  void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1222 
1223  void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1224 
1225  llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1226  const ObjCProtocolDecl *PD) override;
1227 
1228  llvm::Constant *GetPropertyGetFunction() override;
1229  llvm::Constant *GetPropertySetFunction() override;
1230  llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1231  bool copy) override;
1232  llvm::Constant *GetGetStructFunction() override;
1233  llvm::Constant *GetSetStructFunction() override;
1234  llvm::Constant *GetCppAtomicObjectGetFunction() override;
1235  llvm::Constant *GetCppAtomicObjectSetFunction() override;
1236  llvm::Constant *EnumerationMutationFunction() override;
1237 
1238  void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1239  const ObjCAtTryStmt &S) override;
1240  void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1241  const ObjCAtSynchronizedStmt &S) override;
1242  void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1243  void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1244  bool ClearInsertionPoint=true) override;
1245  llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1246  Address AddrWeakObj) override;
1247  void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1248  llvm::Value *src, Address dst) override;
1249  void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1250  llvm::Value *src, Address dest,
1251  bool threadlocal = false) override;
1252  void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1253  llvm::Value *src, Address dest,
1254  llvm::Value *ivarOffset) override;
1255  void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1256  llvm::Value *src, Address dest) override;
1257  void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1258  Address dest, Address src,
1259  llvm::Value *size) override;
1260 
1261  LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1262  llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1263  unsigned CVRQualifiers) override;
1264  llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1265  const ObjCInterfaceDecl *Interface,
1266  const ObjCIvarDecl *Ivar) override;
1267 
1268  /// GetClassGlobal - Return the global variable for the Objective-C
1269  /// class of the given name.
1270  llvm::GlobalVariable *GetClassGlobal(StringRef Name,
1271  bool Weak = false) override {
1272  llvm_unreachable("CGObjCMac::GetClassGlobal");
1273  }
1274 };
1275 
1276 class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1277 private:
1278  ObjCNonFragileABITypesHelper ObjCTypes;
1279  llvm::GlobalVariable* ObjCEmptyCacheVar;
1280  llvm::GlobalVariable* ObjCEmptyVtableVar;
1281 
1282  /// SuperClassReferences - uniqued super class references.
1283  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1284 
1285  /// MetaClassReferences - uniqued meta class references.
1286  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1287 
1288  /// EHTypeReferences - uniqued class ehtype references.
1289  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1290 
1291  /// VTableDispatchMethods - List of methods for which we generate
1292  /// vtable-based message dispatch.
1293  llvm::DenseSet<Selector> VTableDispatchMethods;
1294 
1295  /// DefinedMetaClasses - List of defined meta-classes.
1296  std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1297 
1298  /// isVTableDispatchedSelector - Returns true if SEL is a
1299  /// vtable-based selector.
1300  bool isVTableDispatchedSelector(Selector Sel);
1301 
1302  /// FinishNonFragileABIModule - Write out global data structures at the end of
1303  /// processing a translation unit.
1304  void FinishNonFragileABIModule();
1305 
1306  /// AddModuleClassList - Add the given list of class pointers to the
1307  /// module with the provided symbol and section names.
1308  void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container,
1309  StringRef SymbolName, StringRef SectionName);
1310 
1311  llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1312  unsigned InstanceStart,
1313  unsigned InstanceSize,
1314  const ObjCImplementationDecl *ID);
1315  llvm::GlobalVariable * BuildClassMetaData(const std::string &ClassName,
1316  llvm::Constant *IsAGV,
1317  llvm::Constant *SuperClassGV,
1318  llvm::Constant *ClassRoGV,
1319  bool HiddenVisibility,
1320  bool Weak);
1321 
1322  llvm::Constant *GetMethodConstant(const ObjCMethodDecl *MD);
1323 
1324  llvm::Constant *GetMethodDescriptionConstant(const ObjCMethodDecl *MD);
1325 
1326  /// EmitMethodList - Emit the method list for the given
1327  /// implementation. The return value has type MethodListnfABITy.
1328  llvm::Constant *EmitMethodList(Twine Name, StringRef 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);
1336 
1337  llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1338  const ObjCIvarDecl *Ivar,
1339  unsigned long int offset);
1340 
1341  /// GetOrEmitProtocol - Get the protocol object for the given
1342  /// declaration, emitting it if necessary. The return value has type
1343  /// ProtocolPtrTy.
1344  llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1345 
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  llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1351 
1352  /// EmitProtocolList - Generate the list of referenced
1353  /// protocols. The return value has type ProtocolListPtrTy.
1354  llvm::Constant *EmitProtocolList(Twine Name,
1357 
1358  CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1359  ReturnValueSlot Return,
1360  QualType ResultType,
1361  Selector Sel,
1362  llvm::Value *Receiver,
1363  QualType Arg0Ty,
1364  bool IsSuper,
1365  const CallArgList &CallArgs,
1366  const ObjCMethodDecl *Method);
1367 
1368  /// GetClassGlobal - Return the global variable for the Objective-C
1369  /// class of the given name.
1370  llvm::GlobalVariable *GetClassGlobal(StringRef Name,
1371  bool Weak = false) override;
1372 
1373  /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1374  /// for the given class reference.
1375  llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1376  const ObjCInterfaceDecl *ID);
1377 
1378  llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1379  IdentifierInfo *II, bool Weak,
1380  const ObjCInterfaceDecl *ID);
1381 
1382  llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1383 
1384  /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1385  /// for the given super class reference.
1386  llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1387  const ObjCInterfaceDecl *ID);
1388 
1389  /// EmitMetaClassRef - Return a Value * of the address of _class_t
1390  /// meta-data
1391  llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1392  const ObjCInterfaceDecl *ID, bool Weak);
1393 
1394  /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1395  /// the given ivar.
1396  ///
1397  llvm::GlobalVariable * ObjCIvarOffsetVariable(
1398  const ObjCInterfaceDecl *ID,
1399  const ObjCIvarDecl *Ivar);
1400 
1401  /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1402  /// for the given selector.
1403  llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1404  Address EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel);
1405 
1406  /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1407  /// interface. The return value has type EHTypePtrTy.
1408  llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1409  bool ForDefinition);
1410 
1411  StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }
1412 
1413  StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; }
1414 
1415  void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1416  uint32_t &InstanceStart,
1417  uint32_t &InstanceSize);
1418 
1419  // Shamelessly stolen from Analysis/CFRefCount.cpp
1420  Selector GetNullarySelector(const char* name) const {
1421  IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1422  return CGM.getContext().Selectors.getSelector(0, &II);
1423  }
1424 
1425  Selector GetUnarySelector(const char* name) const {
1426  IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1427  return CGM.getContext().Selectors.getSelector(1, &II);
1428  }
1429 
1430  /// ImplementationIsNonLazy - Check whether the given category or
1431  /// class implementation is "non-lazy".
1432  bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1433 
1434  bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1435  const ObjCIvarDecl *IV) {
1436  // Annotate the load as an invariant load iff inside an instance method
1437  // and ivar belongs to instance method's class and one of its super class.
1438  // This check is needed because the ivar offset is a lazily
1439  // initialised value that may depend on objc_msgSend to perform a fixup on
1440  // the first message dispatch.
1441  //
1442  // An additional opportunity to mark the load as invariant arises when the
1443  // base of the ivar access is a parameter to an Objective C method.
1444  // However, because the parameters are not available in the current
1445  // interface, we cannot perform this check.
1446  if (const ObjCMethodDecl *MD =
1447  dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1448  if (MD->isInstanceMethod())
1449  if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1450  return IV->getContainingInterface()->isSuperClassOf(ID);
1451  return false;
1452  }
1453 
1454 public:
1455  CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1456  // FIXME. All stubs for now!
1457  llvm::Function *ModuleInitFunction() override;
1458 
1459  CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1460  ReturnValueSlot Return,
1461  QualType ResultType, Selector Sel,
1462  llvm::Value *Receiver,
1463  const CallArgList &CallArgs,
1464  const ObjCInterfaceDecl *Class,
1465  const ObjCMethodDecl *Method) override;
1466 
1468  GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1469  ReturnValueSlot Return, QualType ResultType,
1470  Selector Sel, const ObjCInterfaceDecl *Class,
1471  bool isCategoryImpl, llvm::Value *Receiver,
1472  bool IsClassMessage, const CallArgList &CallArgs,
1473  const ObjCMethodDecl *Method) override;
1474 
1475  llvm::Value *GetClass(CodeGenFunction &CGF,
1476  const ObjCInterfaceDecl *ID) override;
1477 
1478  llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override
1479  { return EmitSelector(CGF, Sel); }
1480  Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
1481  { return EmitSelectorAddr(CGF, Sel); }
1482 
1483  /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1484  /// untyped one.
1485  llvm::Value *GetSelector(CodeGenFunction &CGF,
1486  const ObjCMethodDecl *Method) override
1487  { return EmitSelector(CGF, Method->getSelector()); }
1488 
1489  void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1490 
1491  void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1492 
1493  void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1494 
1495  llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1496  const ObjCProtocolDecl *PD) override;
1497 
1498  llvm::Constant *GetEHType(QualType T) override;
1499 
1500  llvm::Constant *GetPropertyGetFunction() override {
1501  return ObjCTypes.getGetPropertyFn();
1502  }
1503  llvm::Constant *GetPropertySetFunction() override {
1504  return ObjCTypes.getSetPropertyFn();
1505  }
1506 
1507  llvm::Constant *GetOptimizedPropertySetFunction(bool atomic,
1508  bool copy) override {
1509  return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1510  }
1511 
1512  llvm::Constant *GetSetStructFunction() override {
1513  return ObjCTypes.getCopyStructFn();
1514  }
1515 
1516  llvm::Constant *GetGetStructFunction() override {
1517  return ObjCTypes.getCopyStructFn();
1518  }
1519 
1520  llvm::Constant *GetCppAtomicObjectSetFunction() override {
1521  return ObjCTypes.getCppAtomicObjectFunction();
1522  }
1523 
1524  llvm::Constant *GetCppAtomicObjectGetFunction() override {
1525  return ObjCTypes.getCppAtomicObjectFunction();
1526  }
1527 
1528  llvm::Constant *EnumerationMutationFunction() override {
1529  return ObjCTypes.getEnumerationMutationFn();
1530  }
1531 
1532  void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1533  const ObjCAtTryStmt &S) override;
1534  void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1535  const ObjCAtSynchronizedStmt &S) override;
1536  void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1537  bool ClearInsertionPoint=true) override;
1538  llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1539  Address AddrWeakObj) override;
1540  void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1541  llvm::Value *src, Address edst) override;
1542  void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1543  llvm::Value *src, Address dest,
1544  bool threadlocal = false) override;
1545  void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1546  llvm::Value *src, Address dest,
1547  llvm::Value *ivarOffset) override;
1548  void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1549  llvm::Value *src, Address dest) override;
1550  void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1551  Address dest, Address src,
1552  llvm::Value *size) override;
1553  LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1554  llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1555  unsigned CVRQualifiers) override;
1556  llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1557  const ObjCInterfaceDecl *Interface,
1558  const ObjCIvarDecl *Ivar) override;
1559 };
1560 
1561 /// A helper class for performing the null-initialization of a return
1562 /// value.
1563 struct NullReturnState {
1564  llvm::BasicBlock *NullBB;
1565  NullReturnState() : NullBB(nullptr) {}
1566 
1567  /// Perform a null-check of the given receiver.
1568  void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1569  // Make blocks for the null-receiver and call edges.
1570  NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1571  llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1572 
1573  // Check for a null receiver and, if there is one, jump to the
1574  // null-receiver block. There's no point in trying to avoid it:
1575  // we're always going to put *something* there, because otherwise
1576  // we shouldn't have done this null-check in the first place.
1577  llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1578  CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1579 
1580  // Otherwise, start performing the call.
1581  CGF.EmitBlock(callBB);
1582  }
1583 
1584  /// Complete the null-return operation. It is valid to call this
1585  /// regardless of whether 'init' has been called.
1586  RValue complete(CodeGenFunction &CGF, RValue result, QualType resultType,
1587  const CallArgList &CallArgs,
1588  const ObjCMethodDecl *Method) {
1589  // If we never had to do a null-check, just use the raw result.
1590  if (!NullBB) return result;
1591 
1592  // The continuation block. This will be left null if we don't have an
1593  // IP, which can happen if the method we're calling is marked noreturn.
1594  llvm::BasicBlock *contBB = nullptr;
1595 
1596  // Finish the call path.
1597  llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1598  if (callBB) {
1599  contBB = CGF.createBasicBlock("msgSend.cont");
1600  CGF.Builder.CreateBr(contBB);
1601  }
1602 
1603  // Okay, start emitting the null-receiver block.
1604  CGF.EmitBlock(NullBB);
1605 
1606  // Release any consumed arguments we've got.
1607  if (Method) {
1608  CallArgList::const_iterator I = CallArgs.begin();
1610  e = Method->param_end(); i != e; ++i, ++I) {
1611  const ParmVarDecl *ParamDecl = (*i);
1612  if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1613  RValue RV = I->RV;
1614  assert(RV.isScalar() &&
1615  "NullReturnState::complete - arg not on object");
1617  }
1618  }
1619  }
1620 
1621  // The phi code below assumes that we haven't needed any control flow yet.
1622  assert(CGF.Builder.GetInsertBlock() == NullBB);
1623 
1624  // If we've got a void return, just jump to the continuation block.
1625  if (result.isScalar() && resultType->isVoidType()) {
1626  // No jumps required if the message-send was noreturn.
1627  if (contBB) CGF.EmitBlock(contBB);
1628  return result;
1629  }
1630 
1631  // If we've got a scalar return, build a phi.
1632  if (result.isScalar()) {
1633  // Derive the null-initialization value.
1634  llvm::Constant *null = CGF.CGM.EmitNullConstant(resultType);
1635 
1636  // If no join is necessary, just flow out.
1637  if (!contBB) return RValue::get(null);
1638 
1639  // Otherwise, build a phi.
1640  CGF.EmitBlock(contBB);
1641  llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1642  phi->addIncoming(result.getScalarVal(), callBB);
1643  phi->addIncoming(null, NullBB);
1644  return RValue::get(phi);
1645  }
1646 
1647  // If we've got an aggregate return, null the buffer out.
1648  // FIXME: maybe we should be doing things differently for all the
1649  // cases where the ABI has us returning (1) non-agg values in
1650  // memory or (2) agg values in registers.
1651  if (result.isAggregate()) {
1652  assert(result.isAggregate() && "null init of non-aggregate result?");
1653  CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
1654  if (contBB) CGF.EmitBlock(contBB);
1655  return result;
1656  }
1657 
1658  // Complex types.
1659  CGF.EmitBlock(contBB);
1660  CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1661 
1662  // Find the scalar type and its zero value.
1663  llvm::Type *scalarTy = callResult.first->getType();
1664  llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1665 
1666  // Build phis for both coordinates.
1667  llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1668  real->addIncoming(callResult.first, callBB);
1669  real->addIncoming(scalarZero, NullBB);
1670  llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1671  imag->addIncoming(callResult.second, callBB);
1672  imag->addIncoming(scalarZero, NullBB);
1673  return RValue::getComplex(real, imag);
1674  }
1675 };
1676 
1677 } // end anonymous namespace
1678 
1679 /* *** Helper Functions *** */
1680 
1681 /// getConstantGEP() - Help routine to construct simple GEPs.
1682 static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1683  llvm::GlobalVariable *C, unsigned idx0,
1684  unsigned idx1) {
1685  llvm::Value *Idxs[] = {
1686  llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1687  llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1688  };
1689  return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1690 }
1691 
1692 /// hasObjCExceptionAttribute - Return true if this class or any super
1693 /// class has the __objc_exception__ attribute.
1695  const ObjCInterfaceDecl *OID) {
1696  if (OID->hasAttr<ObjCExceptionAttr>())
1697  return true;
1698  if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1699  return hasObjCExceptionAttribute(Context, Super);
1700  return false;
1701 }
1702 
1703 /* *** CGObjCMac Public Interface *** */
1704 
1705 CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1706  ObjCTypes(cgm) {
1707  ObjCABI = 1;
1708  EmitImageInfo();
1709 }
1710 
1711 /// GetClass - Return a reference to the class for the given interface
1712 /// decl.
1713 llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1714  const ObjCInterfaceDecl *ID) {
1715  return EmitClassRef(CGF, ID);
1716 }
1717 
1718 /// GetSelector - Return the pointer to the unique'd string for this selector.
1719 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1720  return EmitSelector(CGF, Sel);
1721 }
1722 Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1723  return EmitSelectorAddr(CGF, Sel);
1724 }
1725 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1726  *Method) {
1727  return EmitSelector(CGF, Method->getSelector());
1728 }
1729 
1730 llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1731  if (T->isObjCIdType() ||
1732  T->isObjCQualifiedIdType()) {
1733  return CGM.GetAddrOfRTTIDescriptor(
1734  CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1735  }
1736  if (T->isObjCClassType() ||
1737  T->isObjCQualifiedClassType()) {
1738  return CGM.GetAddrOfRTTIDescriptor(
1739  CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1740  }
1741  if (T->isObjCObjectPointerType())
1742  return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true);
1743 
1744  llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1745 }
1746 
1747 /// Generate a constant CFString object.
1748 /*
1749  struct __builtin_CFString {
1750  const int *isa; // point to __CFConstantStringClassReference
1751  int flags;
1752  const char *str;
1753  long length;
1754  };
1755 */
1756 
1757 /// or Generate a constant NSString object.
1758 /*
1759  struct __builtin_NSString {
1760  const int *isa; // point to __NSConstantStringClassReference
1761  const char *str;
1762  unsigned int length;
1763  };
1764 */
1765 
1766 ConstantAddress CGObjCCommonMac::GenerateConstantString(
1767  const StringLiteral *SL) {
1768  return (CGM.getLangOpts().NoConstantCFStrings == 0 ?
1769  CGM.GetAddrOfConstantCFString(SL) :
1770  CGM.GetAddrOfConstantString(SL));
1771 }
1772 
1773 enum {
1775 };
1776 
1777 /// Generates a message send where the super is the receiver. This is
1778 /// a message send to self with special delivery semantics indicating
1779 /// which class's method should be called.
1781 CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1782  ReturnValueSlot Return,
1783  QualType ResultType,
1784  Selector Sel,
1785  const ObjCInterfaceDecl *Class,
1786  bool isCategoryImpl,
1787  llvm::Value *Receiver,
1788  bool IsClassMessage,
1789  const CodeGen::CallArgList &CallArgs,
1790  const ObjCMethodDecl *Method) {
1791  // Create and init a super structure; this is a (receiver, class)
1792  // pair we will pass to objc_msgSendSuper.
1793  Address ObjCSuper =
1794  CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
1795  "objc_super");
1796  llvm::Value *ReceiverAsObject =
1797  CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
1798  CGF.Builder.CreateStore(
1799  ReceiverAsObject,
1800  CGF.Builder.CreateStructGEP(ObjCSuper, 0, CharUnits::Zero()));
1801 
1802  // If this is a class message the metaclass is passed as the target.
1803  llvm::Value *Target;
1804  if (IsClassMessage) {
1805  if (isCategoryImpl) {
1806  // Message sent to 'super' in a class method defined in a category
1807  // implementation requires an odd treatment.
1808  // If we are in a class method, we must retrieve the
1809  // _metaclass_ for the current class, pointed at by
1810  // the class's "isa" pointer. The following assumes that
1811  // isa" is the first ivar in a class (which it must be).
1812  Target = EmitClassRef(CGF, Class->getSuperClass());
1813  Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
1814  Target = CGF.Builder.CreateAlignedLoad(Target, CGF.getPointerAlign());
1815  } else {
1816  llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
1817  llvm::Value *SuperPtr =
1818  CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
1819  llvm::Value *Super =
1820  CGF.Builder.CreateAlignedLoad(SuperPtr, CGF.getPointerAlign());
1821  Target = Super;
1822  }
1823  } else if (isCategoryImpl)
1824  Target = EmitClassRef(CGF, Class->getSuperClass());
1825  else {
1826  llvm::Value *ClassPtr = EmitSuperClassRef(Class);
1827  ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
1828  Target = CGF.Builder.CreateAlignedLoad(ClassPtr, CGF.getPointerAlign());
1829  }
1830  // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
1831  // ObjCTypes types.
1832  llvm::Type *ClassTy =
1834  Target = CGF.Builder.CreateBitCast(Target, ClassTy);
1835  CGF.Builder.CreateStore(Target,
1836  CGF.Builder.CreateStructGEP(ObjCSuper, 1, CGF.getPointerSize()));
1837  return EmitMessageSend(CGF, Return, ResultType,
1838  EmitSelector(CGF, Sel),
1839  ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
1840  true, CallArgs, Method, Class, ObjCTypes);
1841 }
1842 
1843 /// Generate code for a message send expression.
1844 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1845  ReturnValueSlot Return,
1846  QualType ResultType,
1847  Selector Sel,
1848  llvm::Value *Receiver,
1849  const CallArgList &CallArgs,
1850  const ObjCInterfaceDecl *Class,
1851  const ObjCMethodDecl *Method) {
1852  return EmitMessageSend(CGF, Return, ResultType,
1853  EmitSelector(CGF, Sel),
1854  Receiver, CGF.getContext().getObjCIdType(),
1855  false, CallArgs, Method, Class, ObjCTypes);
1856 }
1857 
1858 static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
1859  do {
1860  if (ID->isWeakImported())
1861  return true;
1862  } while ((ID = ID->getSuperClass()));
1863 
1864  return false;
1865 }
1866 
1868 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1869  ReturnValueSlot Return,
1870  QualType ResultType,
1871  llvm::Value *Sel,
1872  llvm::Value *Arg0,
1873  QualType Arg0Ty,
1874  bool IsSuper,
1875  const CallArgList &CallArgs,
1876  const ObjCMethodDecl *Method,
1877  const ObjCInterfaceDecl *ClassReceiver,
1878  const ObjCCommonTypesHelper &ObjCTypes) {
1879  CallArgList ActualArgs;
1880  if (!IsSuper)
1881  Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
1882  ActualArgs.add(RValue::get(Arg0), Arg0Ty);
1883  ActualArgs.add(RValue::get(Sel), CGF.getContext().getObjCSelType());
1884  ActualArgs.addFrom(CallArgs);
1885 
1886  // If we're calling a method, use the formal signature.
1887  MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
1888 
1889  if (Method)
1890  assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==
1891  CGM.getContext().getCanonicalType(ResultType) &&
1892  "Result type mismatch!");
1893 
1894  bool ReceiverCanBeNull = true;
1895 
1896  // Super dispatch assumes that self is non-null; even the messenger
1897  // doesn't have a null check internally.
1898  if (IsSuper) {
1899  ReceiverCanBeNull = false;
1900 
1901  // If this is a direct dispatch of a class method, check whether the class,
1902  // or anything in its hierarchy, was weak-linked.
1903  } else if (ClassReceiver && Method && Method->isClassMethod()) {
1904  ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);
1905 
1906  // If we're emitting a method, and self is const (meaning just ARC, for now),
1907  // and the receiver is a load of self, then self is a valid object.
1908  } else if (auto CurMethod =
1909  dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
1910  auto Self = CurMethod->getSelfDecl();
1911  if (Self->getType().isConstQualified()) {
1912  if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {
1913  llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer();
1914  if (SelfAddr == LI->getPointerOperand()) {
1915  ReceiverCanBeNull = false;
1916  }
1917  }
1918  }
1919  }
1920 
1921  NullReturnState nullReturn;
1922 
1923  llvm::Constant *Fn = nullptr;
1924  if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
1925  if (ReceiverCanBeNull) nullReturn.init(CGF, Arg0);
1926  Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
1927  : ObjCTypes.getSendStretFn(IsSuper);
1928  } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
1929  Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
1930  : ObjCTypes.getSendFpretFn(IsSuper);
1931  } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
1932  Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
1933  : ObjCTypes.getSendFp2retFn(IsSuper);
1934  } else {
1935  // arm64 uses objc_msgSend for stret methods and yet null receiver check
1936  // must be made for it.
1937  if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
1938  nullReturn.init(CGF, Arg0);
1939  Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
1940  : ObjCTypes.getSendFn(IsSuper);
1941  }
1942 
1943  // Emit a null-check if there's a consumed argument other than the receiver.
1944  bool RequiresNullCheck = false;
1945  if (ReceiverCanBeNull && CGM.getLangOpts().ObjCAutoRefCount && Method) {
1946  for (const auto *ParamDecl : Method->parameters()) {
1947  if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1948  if (!nullReturn.NullBB)
1949  nullReturn.init(CGF, Arg0);
1950  RequiresNullCheck = true;
1951  break;
1952  }
1953  }
1954  }
1955 
1956  llvm::Instruction *CallSite;
1957  Fn = llvm::ConstantExpr::getBitCast(Fn, MSI.MessengerType);
1958  RValue rvalue = CGF.EmitCall(MSI.CallInfo, Fn, Return, ActualArgs,
1959  CGCalleeInfo(), &CallSite);
1960 
1961  // Mark the call as noreturn if the method is marked noreturn and the
1962  // receiver cannot be null.
1963  if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) {
1964  llvm::CallSite(CallSite).setDoesNotReturn();
1965  }
1966 
1967  return nullReturn.complete(CGF, rvalue, ResultType, CallArgs,
1968  RequiresNullCheck ? Method : nullptr);
1969 }
1970 
1972  bool pointee = false) {
1973  // Note that GC qualification applies recursively to C pointer types
1974  // that aren't otherwise decorated. This is weird, but it's probably
1975  // an intentional workaround to the unreliable placement of GC qualifiers.
1976  if (FQT.isObjCGCStrong())
1977  return Qualifiers::Strong;
1978 
1979  if (FQT.isObjCGCWeak())
1980  return Qualifiers::Weak;
1981 
1982  if (auto ownership = FQT.getObjCLifetime()) {
1983  // Ownership does not apply recursively to C pointer types.
1984  if (pointee) return Qualifiers::GCNone;
1985  switch (ownership) {
1989  case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?");
1990  case Qualifiers::OCL_None: llvm_unreachable("known nonzero");
1991  }
1992  llvm_unreachable("bad objc ownership");
1993  }
1994 
1995  // Treat unqualified retainable pointers as strong.
1996  if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
1997  return Qualifiers::Strong;
1998 
1999  // Walk into C pointer types, but only in GC.
2000  if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
2001  if (const PointerType *PT = FQT->getAs<PointerType>())
2002  return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
2003  }
2004 
2005  return Qualifiers::GCNone;
2006 }
2007 
2008 namespace {
2009  struct IvarInfo {
2010  CharUnits Offset;
2011  uint64_t SizeInWords;
2012  IvarInfo(CharUnits offset, uint64_t sizeInWords)
2013  : Offset(offset), SizeInWords(sizeInWords) {}
2014 
2015  // Allow sorting based on byte pos.
2016  bool operator<(const IvarInfo &other) const {
2017  return Offset < other.Offset;
2018  }
2019  };
2020 
2021  /// A helper class for building GC layout strings.
2022  class IvarLayoutBuilder {
2023  CodeGenModule &CGM;
2024 
2025  /// The start of the layout. Offsets will be relative to this value,
2026  /// and entries less than this value will be silently discarded.
2027  CharUnits InstanceBegin;
2028 
2029  /// The end of the layout. Offsets will never exceed this value.
2030  CharUnits InstanceEnd;
2031 
2032  /// Whether we're generating the strong layout or the weak layout.
2033  bool ForStrongLayout;
2034 
2035  /// Whether the offsets in IvarsInfo might be out-of-order.
2036  bool IsDisordered = false;
2037 
2039 
2040  public:
2041  IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2042  CharUnits instanceEnd, bool forStrongLayout)
2043  : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
2044  ForStrongLayout(forStrongLayout) {
2045  }
2046 
2047  void visitRecord(const RecordType *RT, CharUnits offset);
2048 
2049  template <class Iterator, class GetOffsetFn>
2050  void visitAggregate(Iterator begin, Iterator end,
2051  CharUnits aggrOffset,
2052  const GetOffsetFn &getOffset);
2053 
2054  void visitField(const FieldDecl *field, CharUnits offset);
2055 
2056  /// Add the layout of a block implementation.
2057  void visitBlock(const CGBlockInfo &blockInfo);
2058 
2059  /// Is there any information for an interesting bitmap?
2060  bool hasBitmapData() const { return !IvarsInfo.empty(); }
2061 
2062  llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
2064 
2065  static void dump(ArrayRef<unsigned char> buffer) {
2066  const unsigned char *s = buffer.data();
2067  for (unsigned i = 0, e = buffer.size(); i < e; i++)
2068  if (!(s[i] & 0xf0))
2069  printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2070  else
2071  printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
2072  printf("\n");
2073  }
2074  };
2075 } // end anonymous namespace
2076 
2077 llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
2078  const CGBlockInfo &blockInfo) {
2079 
2080  llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2081  if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
2082  return nullPtr;
2083 
2084  IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2085  /*for strong layout*/ true);
2086 
2087  builder.visitBlock(blockInfo);
2088 
2089  if (!builder.hasBitmapData())
2090  return nullPtr;
2091 
2093  llvm::Constant *C = builder.buildBitmap(*this, buffer);
2094  if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
2095  printf("\n block variable layout for block: ");
2096  builder.dump(buffer);
2097  }
2098 
2099  return C;
2100 }
2101 
2102 void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
2103  // __isa is the first field in block descriptor and must assume by runtime's
2104  // convention that it is GC'able.
2105  IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2106 
2107  const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2108 
2109  // Ignore the optional 'this' capture: C++ objects are not assumed
2110  // to be GC'ed.
2111 
2112  CharUnits lastFieldOffset;
2113 
2114  // Walk the captured variables.
2115  for (const auto &CI : blockDecl->captures()) {
2116  const VarDecl *variable = CI.getVariable();
2117  QualType type = variable->getType();
2118 
2119  const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2120 
2121  // Ignore constant captures.
2122  if (capture.isConstant()) continue;
2123 
2124  CharUnits fieldOffset = capture.getOffset();
2125 
2126  // Block fields are not necessarily ordered; if we detect that we're
2127  // adding them out-of-order, make sure we sort later.
2128  if (fieldOffset < lastFieldOffset)
2129  IsDisordered = true;
2130  lastFieldOffset = fieldOffset;
2131 
2132  // __block variables are passed by their descriptor address.
2133  if (CI.isByRef()) {
2134  IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2135  continue;
2136  }
2137 
2138  assert(!type->isArrayType() && "array variable should not be caught");
2139  if (const RecordType *record = type->getAs<RecordType>()) {
2140  visitRecord(record, fieldOffset);
2141  continue;
2142  }
2143 
2145 
2146  if (GCAttr == Qualifiers::Strong) {
2147  assert(CGM.getContext().getTypeSize(type)
2148  == CGM.getTarget().getPointerWidth(0));
2149  IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2150  }
2151  }
2152 }
2153 
2154 /// getBlockCaptureLifetime - This routine returns life time of the captured
2155 /// block variable for the purpose of block layout meta-data generation. FQT is
2156 /// the type of the variable captured in the block.
2157 Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2158  bool ByrefLayout) {
2159  // If it has an ownership qualifier, we're done.
2160  if (auto lifetime = FQT.getObjCLifetime())
2161  return lifetime;
2162 
2163  // If it doesn't, and this is ARC, it has no ownership.
2164  if (CGM.getLangOpts().ObjCAutoRefCount)
2165  return Qualifiers::OCL_None;
2166 
2167  // In MRC, retainable pointers are owned by non-__block variables.
2168  if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2170 
2171  return Qualifiers::OCL_None;
2172 }
2173 
2174 void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2175  Qualifiers::ObjCLifetime LifeTime,
2176  CharUnits FieldOffset,
2177  CharUnits FieldSize) {
2178  // __block variables are passed by their descriptor address.
2179  if (IsByref)
2180  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2181  FieldSize));
2182  else if (LifeTime == Qualifiers::OCL_Strong)
2183  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2184  FieldSize));
2185  else if (LifeTime == Qualifiers::OCL_Weak)
2186  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2187  FieldSize));
2188  else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2189  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2190  FieldSize));
2191  else
2192  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2193  FieldOffset,
2194  FieldSize));
2195 }
2196 
2197 void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2198  const RecordDecl *RD,
2199  ArrayRef<const FieldDecl*> RecFields,
2200  CharUnits BytePos, bool &HasUnion,
2201  bool ByrefLayout) {
2202  bool IsUnion = (RD && RD->isUnion());
2203  CharUnits MaxUnionSize = CharUnits::Zero();
2204  const FieldDecl *MaxField = nullptr;
2205  const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2206  CharUnits MaxFieldOffset = CharUnits::Zero();
2207  CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2208 
2209  if (RecFields.empty())
2210  return;
2211  unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2212 
2213  for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
2214  const FieldDecl *Field = RecFields[i];
2215  // Note that 'i' here is actually the field index inside RD of Field,
2216  // although this dependency is hidden.
2217  const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2218  CharUnits FieldOffset =
2220 
2221  // Skip over unnamed or bitfields
2222  if (!Field->getIdentifier() || Field->isBitField()) {
2223  LastFieldBitfieldOrUnnamed = Field;
2224  LastBitfieldOrUnnamedOffset = FieldOffset;
2225  continue;
2226  }
2227 
2228  LastFieldBitfieldOrUnnamed = nullptr;
2229  QualType FQT = Field->getType();
2230  if (FQT->isRecordType() || FQT->isUnionType()) {
2231  if (FQT->isUnionType())
2232  HasUnion = true;
2233 
2234  BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
2235  BytePos + FieldOffset, HasUnion);
2236  continue;
2237  }
2238 
2239  if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2240  const ConstantArrayType *CArray =
2241  dyn_cast_or_null<ConstantArrayType>(Array);
2242  uint64_t ElCount = CArray->getSize().getZExtValue();
2243  assert(CArray && "only array with known element size is supported");
2244  FQT = CArray->getElementType();
2245  while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2246  const ConstantArrayType *CArray =
2247  dyn_cast_or_null<ConstantArrayType>(Array);
2248  ElCount *= CArray->getSize().getZExtValue();
2249  FQT = CArray->getElementType();
2250  }
2251  if (FQT->isRecordType() && ElCount) {
2252  int OldIndex = RunSkipBlockVars.size() - 1;
2253  const RecordType *RT = FQT->getAs<RecordType>();
2254  BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset,
2255  HasUnion);
2256 
2257  // Replicate layout information for each array element. Note that
2258  // one element is already done.
2259  uint64_t ElIx = 1;
2260  for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2261  CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2262  for (int i = OldIndex+1; i <= FirstIndex; ++i)
2263  RunSkipBlockVars.push_back(
2264  RUN_SKIP(RunSkipBlockVars[i].opcode,
2265  RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2266  RunSkipBlockVars[i].block_var_size));
2267  }
2268  continue;
2269  }
2270  }
2271  CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2272  if (IsUnion) {
2273  CharUnits UnionIvarSize = FieldSize;
2274  if (UnionIvarSize > MaxUnionSize) {
2275  MaxUnionSize = UnionIvarSize;
2276  MaxField = Field;
2277  MaxFieldOffset = FieldOffset;
2278  }
2279  } else {
2280  UpdateRunSkipBlockVars(false,
2281  getBlockCaptureLifetime(FQT, ByrefLayout),
2282  BytePos + FieldOffset,
2283  FieldSize);
2284  }
2285  }
2286 
2287  if (LastFieldBitfieldOrUnnamed) {
2288  if (LastFieldBitfieldOrUnnamed->isBitField()) {
2289  // Last field was a bitfield. Must update the info.
2290  uint64_t BitFieldSize
2291  = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2292  unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2293  ((BitFieldSize % ByteSizeInBits) != 0);
2294  CharUnits Size = CharUnits::fromQuantity(UnsSize);
2295  Size += LastBitfieldOrUnnamedOffset;
2296  UpdateRunSkipBlockVars(false,
2297  getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2298  ByrefLayout),
2299  BytePos + LastBitfieldOrUnnamedOffset,
2300  Size);
2301  } else {
2302  assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2303  // Last field was unnamed. Must update skip info.
2304  CharUnits FieldSize
2305  = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2306  UpdateRunSkipBlockVars(false,
2307  getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2308  ByrefLayout),
2309  BytePos + LastBitfieldOrUnnamedOffset,
2310  FieldSize);
2311  }
2312  }
2313 
2314  if (MaxField)
2315  UpdateRunSkipBlockVars(false,
2316  getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2317  BytePos + MaxFieldOffset,
2318  MaxUnionSize);
2319 }
2320 
2321 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2322  CharUnits BytePos,
2323  bool &HasUnion,
2324  bool ByrefLayout) {
2325  const RecordDecl *RD = RT->getDecl();
2327  llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2328  const llvm::StructLayout *RecLayout =
2329  CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2330 
2331  BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2332 }
2333 
2334 /// InlineLayoutInstruction - This routine produce an inline instruction for the
2335 /// block variable layout if it can. If not, it returns 0. Rules are as follow:
2336 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2337 /// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2338 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2339 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2340 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2341 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2342 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2343 uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2345  uint64_t Result = 0;
2346  if (Layout.size() <= 3) {
2347  unsigned size = Layout.size();
2348  unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2349  unsigned char inst;
2350  enum BLOCK_LAYOUT_OPCODE opcode ;
2351  switch (size) {
2352  case 3:
2353  inst = Layout[0];
2354  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2355  if (opcode == BLOCK_LAYOUT_STRONG)
2356  strong_word_count = (inst & 0xF)+1;
2357  else
2358  return 0;
2359  inst = Layout[1];
2360  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2361  if (opcode == BLOCK_LAYOUT_BYREF)
2362  byref_word_count = (inst & 0xF)+1;
2363  else
2364  return 0;
2365  inst = Layout[2];
2366  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2367  if (opcode == BLOCK_LAYOUT_WEAK)
2368  weak_word_count = (inst & 0xF)+1;
2369  else
2370  return 0;
2371  break;
2372 
2373  case 2:
2374  inst = Layout[0];
2375  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2376  if (opcode == BLOCK_LAYOUT_STRONG) {
2377  strong_word_count = (inst & 0xF)+1;
2378  inst = Layout[1];
2379  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2380  if (opcode == BLOCK_LAYOUT_BYREF)
2381  byref_word_count = (inst & 0xF)+1;
2382  else if (opcode == BLOCK_LAYOUT_WEAK)
2383  weak_word_count = (inst & 0xF)+1;
2384  else
2385  return 0;
2386  }
2387  else if (opcode == BLOCK_LAYOUT_BYREF) {
2388  byref_word_count = (inst & 0xF)+1;
2389  inst = Layout[1];
2390  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2391  if (opcode == BLOCK_LAYOUT_WEAK)
2392  weak_word_count = (inst & 0xF)+1;
2393  else
2394  return 0;
2395  }
2396  else
2397  return 0;
2398  break;
2399 
2400  case 1:
2401  inst = Layout[0];
2402  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2403  if (opcode == BLOCK_LAYOUT_STRONG)
2404  strong_word_count = (inst & 0xF)+1;
2405  else if (opcode == BLOCK_LAYOUT_BYREF)
2406  byref_word_count = (inst & 0xF)+1;
2407  else if (opcode == BLOCK_LAYOUT_WEAK)
2408  weak_word_count = (inst & 0xF)+1;
2409  else
2410  return 0;
2411  break;
2412 
2413  default:
2414  return 0;
2415  }
2416 
2417  // Cannot inline when any of the word counts is 15. Because this is one less
2418  // than the actual work count (so 15 means 16 actual word counts),
2419  // and we can only display 0 thru 15 word counts.
2420  if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2421  return 0;
2422 
2423  unsigned count =
2424  (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2425 
2426  if (size == count) {
2427  if (strong_word_count)
2428  Result = strong_word_count;
2429  Result <<= 4;
2430  if (byref_word_count)
2431  Result += byref_word_count;
2432  Result <<= 4;
2433  if (weak_word_count)
2434  Result += weak_word_count;
2435  }
2436  }
2437  return Result;
2438 }
2439 
2440 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2441  llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2442  if (RunSkipBlockVars.empty())
2443  return nullPtr;
2444  unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2445  unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2446  unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2447 
2448  // Sort on byte position; captures might not be allocated in order,
2449  // and unions can do funny things.
2450  llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2452 
2453  unsigned size = RunSkipBlockVars.size();
2454  for (unsigned i = 0; i < size; i++) {
2455  enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2456  CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2457  CharUnits end_byte_pos = start_byte_pos;
2458  unsigned j = i+1;
2459  while (j < size) {
2460  if (opcode == RunSkipBlockVars[j].opcode) {
2461  end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2462  i++;
2463  }
2464  else
2465  break;
2466  }
2467  CharUnits size_in_bytes =
2468  end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2469  if (j < size) {
2470  CharUnits gap =
2471  RunSkipBlockVars[j].block_var_bytepos -
2472  RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2473  size_in_bytes += gap;
2474  }
2475  CharUnits residue_in_bytes = CharUnits::Zero();
2476  if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2477  residue_in_bytes = size_in_bytes % WordSizeInBytes;
2478  size_in_bytes -= residue_in_bytes;
2479  opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2480  }
2481 
2482  unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2483  while (size_in_words >= 16) {
2484  // Note that value in imm. is one less that the actual
2485  // value. So, 0xf means 16 words follow!
2486  unsigned char inst = (opcode << 4) | 0xf;
2487  Layout.push_back(inst);
2488  size_in_words -= 16;
2489  }
2490  if (size_in_words > 0) {
2491  // Note that value in imm. is one less that the actual
2492  // value. So, we subtract 1 away!
2493  unsigned char inst = (opcode << 4) | (size_in_words-1);
2494  Layout.push_back(inst);
2495  }
2496  if (residue_in_bytes > CharUnits::Zero()) {
2497  unsigned char inst =
2498  (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2499  Layout.push_back(inst);
2500  }
2501  }
2502 
2503  while (!Layout.empty()) {
2504  unsigned char inst = Layout.back();
2505  enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2506  if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2507  Layout.pop_back();
2508  else
2509  break;
2510  }
2511 
2512  uint64_t Result = InlineLayoutInstruction(Layout);
2513  if (Result != 0) {
2514  // Block variable layout instruction has been inlined.
2515  if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2516  if (ComputeByrefLayout)
2517  printf("\n Inline BYREF variable layout: ");
2518  else
2519  printf("\n Inline block variable layout: ");
2520  printf("0x0%" PRIx64 "", Result);
2521  if (auto numStrong = (Result & 0xF00) >> 8)
2522  printf(", BL_STRONG:%d", (int) numStrong);
2523  if (auto numByref = (Result & 0x0F0) >> 4)
2524  printf(", BL_BYREF:%d", (int) numByref);
2525  if (auto numWeak = (Result & 0x00F) >> 0)
2526  printf(", BL_WEAK:%d", (int) numWeak);
2527  printf(", BL_OPERATOR:0\n");
2528  }
2529  return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2530  }
2531 
2532  unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2533  Layout.push_back(inst);
2534  std::string BitMap;
2535  for (unsigned i = 0, e = Layout.size(); i != e; i++)
2536  BitMap += Layout[i];
2537 
2538  if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2539  if (ComputeByrefLayout)
2540  printf("\n Byref variable layout: ");
2541  else
2542  printf("\n Block variable layout: ");
2543  for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2544  unsigned char inst = BitMap[i];
2545  enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2546  unsigned delta = 1;
2547  switch (opcode) {
2548  case BLOCK_LAYOUT_OPERATOR:
2549  printf("BL_OPERATOR:");
2550  delta = 0;
2551  break;
2552  case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2553  printf("BL_NON_OBJECT_BYTES:");
2554  break;
2555  case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2556  printf("BL_NON_OBJECT_WORD:");
2557  break;
2558  case BLOCK_LAYOUT_STRONG:
2559  printf("BL_STRONG:");
2560  break;
2561  case BLOCK_LAYOUT_BYREF:
2562  printf("BL_BYREF:");
2563  break;
2564  case BLOCK_LAYOUT_WEAK:
2565  printf("BL_WEAK:");
2566  break;
2567  case BLOCK_LAYOUT_UNRETAINED:
2568  printf("BL_UNRETAINED:");
2569  break;
2570  }
2571  // Actual value of word count is one more that what is in the imm.
2572  // field of the instruction
2573  printf("%d", (inst & 0xf) + delta);
2574  if (i < e-1)
2575  printf(", ");
2576  else
2577  printf("\n");
2578  }
2579  }
2580 
2581  llvm::GlobalVariable *Entry = CreateMetadataVar(
2582  "OBJC_CLASS_NAME_",
2583  llvm::ConstantDataArray::getString(VMContext, BitMap, false),
2584  "__TEXT,__objc_classname,cstring_literals", CharUnits::One(), true);
2585  return getConstantGEP(VMContext, Entry, 0, 0);
2586 }
2587 
2588 llvm::Constant *CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2589  const CGBlockInfo &blockInfo) {
2590  assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2591 
2592  RunSkipBlockVars.clear();
2593  bool hasUnion = false;
2594 
2595  unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2596  unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2597  unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2598 
2599  const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2600 
2601  // Calculate the basic layout of the block structure.
2602  const llvm::StructLayout *layout =
2603  CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2604 
2605  // Ignore the optional 'this' capture: C++ objects are not assumed
2606  // to be GC'ed.
2607  if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2608  UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2609  blockInfo.BlockHeaderForcedGapOffset,
2610  blockInfo.BlockHeaderForcedGapSize);
2611  // Walk the captured variables.
2612  for (const auto &CI : blockDecl->captures()) {
2613  const VarDecl *variable = CI.getVariable();
2614  QualType type = variable->getType();
2615 
2616  const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2617 
2618  // Ignore constant captures.
2619  if (capture.isConstant()) continue;
2620 
2621  CharUnits fieldOffset =
2622  CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2623 
2624  assert(!type->isArrayType() && "array variable should not be caught");
2625  if (!CI.isByRef())
2626  if (const RecordType *record = type->getAs<RecordType>()) {
2627  BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2628  continue;
2629  }
2630  CharUnits fieldSize;
2631  if (CI.isByRef())
2632  fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2633  else
2634  fieldSize = CGM.getContext().getTypeSizeInChars(type);
2635  UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2636  fieldOffset, fieldSize);
2637  }
2638  return getBitmapBlockLayout(false);
2639 }
2640 
2641 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
2642  QualType T) {
2643  assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2644  assert(!T->isArrayType() && "__block array variable should not be caught");
2645  CharUnits fieldOffset;
2646  RunSkipBlockVars.clear();
2647  bool hasUnion = false;
2648  if (const RecordType *record = T->getAs<RecordType>()) {
2649  BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
2650  llvm::Constant *Result = getBitmapBlockLayout(true);
2651  if (isa<llvm::ConstantInt>(Result))
2652  Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
2653  return Result;
2654  }
2655  llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2656  return nullPtr;
2657 }
2658 
2659 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
2660  const ObjCProtocolDecl *PD) {
2661  // FIXME: I don't understand why gcc generates this, or where it is
2662  // resolved. Investigate. Its also wasteful to look this up over and over.
2663  LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2664 
2665  return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
2666  ObjCTypes.getExternalProtocolPtrTy());
2667 }
2668 
2669 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
2670  // FIXME: We shouldn't need this, the protocol decl should contain enough
2671  // information to tell us whether this was a declaration or a definition.
2672  DefinedProtocols.insert(PD->getIdentifier());
2673 
2674  // If we have generated a forward reference to this protocol, emit
2675  // it now. Otherwise do nothing, the protocol objects are lazily
2676  // emitted.
2677  if (Protocols.count(PD->getIdentifier()))
2678  GetOrEmitProtocol(PD);
2679 }
2680 
2681 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
2682  if (DefinedProtocols.count(PD->getIdentifier()))
2683  return GetOrEmitProtocol(PD);
2684 
2685  return GetOrEmitProtocolRef(PD);
2686 }
2687 
2688 llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
2689  CodeGenFunction &CGF,
2690  const ObjCInterfaceDecl *ID,
2691  ObjCCommonTypesHelper &ObjCTypes) {
2692  llvm::Constant *lookUpClassFn = ObjCTypes.getLookUpClassFn();
2693 
2694  llvm::Value *className =
2696  .getPointer();
2697  ASTContext &ctx = CGF.CGM.getContext();
2698  className =
2699  CGF.Builder.CreateBitCast(className,
2700  CGF.ConvertType(
2701  ctx.getPointerType(ctx.CharTy.withConst())));
2702  llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
2703  call->setDoesNotThrow();
2704  return call;
2705 }
2706 
2707 /*
2708 // Objective-C 1.0 extensions
2709 struct _objc_protocol {
2710 struct _objc_protocol_extension *isa;
2711 char *protocol_name;
2712 struct _objc_protocol_list *protocol_list;
2713 struct _objc__method_prototype_list *instance_methods;
2714 struct _objc__method_prototype_list *class_methods
2715 };
2716 
2717 See EmitProtocolExtension().
2718 */
2719 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
2720  llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
2721 
2722  // Early exit if a defining object has already been generated.
2723  if (Entry && Entry->hasInitializer())
2724  return Entry;
2725 
2726  // Use the protocol definition, if there is one.
2727  if (const ObjCProtocolDecl *Def = PD->getDefinition())
2728  PD = Def;
2729 
2730  // FIXME: I don't understand why gcc generates this, or where it is
2731  // resolved. Investigate. Its also wasteful to look this up over and over.
2732  LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2733 
2734  // Construct method lists.
2735  std::vector<llvm::Constant*> InstanceMethods, ClassMethods;
2736  std::vector<llvm::Constant*> OptInstanceMethods, OptClassMethods;
2737  std::vector<llvm::Constant*> MethodTypesExt, OptMethodTypesExt;
2738  for (const auto *MD : PD->instance_methods()) {
2739  llvm::Constant *C = GetMethodDescriptionConstant(MD);
2740  if (!C)
2741  return GetOrEmitProtocolRef(PD);
2742 
2743  if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
2744  OptInstanceMethods.push_back(C);
2745  OptMethodTypesExt.push_back(GetMethodVarType(MD, true));
2746  } else {
2747  InstanceMethods.push_back(C);
2748  MethodTypesExt.push_back(GetMethodVarType(MD, true));
2749  }
2750  }
2751 
2752  for (const auto *MD : PD->class_methods()) {
2753  llvm::Constant *C = GetMethodDescriptionConstant(MD);
2754  if (!C)
2755  return GetOrEmitProtocolRef(PD);
2756 
2757  if (MD->getImplementationControl() == ObjCMethodDecl::Optional) {
2758  OptClassMethods.push_back(C);
2759  OptMethodTypesExt.push_back(GetMethodVarType(MD, true));
2760  } else {
2761  ClassMethods.push_back(C);
2762  MethodTypesExt.push_back(GetMethodVarType(MD, true));
2763  }
2764  }
2765 
2766  MethodTypesExt.insert(MethodTypesExt.end(),
2767  OptMethodTypesExt.begin(), OptMethodTypesExt.end());
2768 
2769  llvm::Constant *Values[] = {
2770  EmitProtocolExtension(PD, OptInstanceMethods, OptClassMethods,
2771  MethodTypesExt),
2772  GetClassName(PD->getObjCRuntimeNameAsString()),
2773  EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
2774  PD->protocol_begin(), PD->protocol_end()),
2775  EmitMethodDescList("OBJC_PROTOCOL_INSTANCE_METHODS_" + PD->getName(),
2776  "__OBJC,__cat_inst_meth,regular,no_dead_strip",
2777  InstanceMethods),
2778  EmitMethodDescList("OBJC_PROTOCOL_CLASS_METHODS_" + PD->getName(),
2779  "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2780  ClassMethods)};
2781  llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
2782  Values);
2783 
2784  if (Entry) {
2785  // Already created, update the initializer.
2786  assert(Entry->hasPrivateLinkage());
2787  Entry->setInitializer(Init);
2788  } else {
2789  Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
2790  false, llvm::GlobalValue::PrivateLinkage,
2791  Init, "OBJC_PROTOCOL_" + PD->getName());
2792  Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
2793  // FIXME: Is this necessary? Why only for protocol?
2794  Entry->setAlignment(4);
2795 
2796  Protocols[PD->getIdentifier()] = Entry;
2797  }
2798  CGM.addCompilerUsedGlobal(Entry);
2799 
2800  return Entry;
2801 }
2802 
2803 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
2804  llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
2805 
2806  if (!Entry) {
2807  // We use the initializer as a marker of whether this is a forward
2808  // reference or not. At module finalization we add the empty
2809  // contents for protocols which were referenced but never defined.
2810  Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
2811  false, llvm::GlobalValue::PrivateLinkage,
2812  nullptr, "OBJC_PROTOCOL_" + PD->getName());
2813  Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
2814  // FIXME: Is this necessary? Why only for protocol?
2815  Entry->setAlignment(4);
2816  }
2817 
2818  return Entry;
2819 }
2820 
2821 /*
2822  struct _objc_protocol_extension {
2823  uint32_t size;
2824  struct objc_method_description_list *optional_instance_methods;
2825  struct objc_method_description_list *optional_class_methods;
2826  struct objc_property_list *instance_properties;
2827  const char ** extendedMethodTypes;
2828  struct objc_property_list *class_properties;
2829  };
2830 */
2831 llvm::Constant *
2832 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
2833  ArrayRef<llvm::Constant*> OptInstanceMethods,
2834  ArrayRef<llvm::Constant*> OptClassMethods,
2835  ArrayRef<llvm::Constant*> MethodTypesExt) {
2836  uint64_t Size =
2837  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
2838  llvm::Constant *Values[] = {
2839  llvm::ConstantInt::get(ObjCTypes.IntTy, Size),
2840  EmitMethodDescList("OBJC_PROTOCOL_INSTANCE_METHODS_OPT_" + PD->getName(),
2841  "__OBJC,__cat_inst_meth,regular,no_dead_strip",
2842  OptInstanceMethods),
2843  EmitMethodDescList("OBJC_PROTOCOL_CLASS_METHODS_OPT_" + PD->getName(),
2844  "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2845  OptClassMethods),
2846  EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
2847  ObjCTypes, false),
2848  EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
2849  MethodTypesExt, ObjCTypes),
2850  EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
2851  PD, ObjCTypes, true)};
2852 
2853  // Return null if no extension bits are used.
2854  if (Values[1]->isNullValue() && Values[2]->isNullValue() &&
2855  Values[3]->isNullValue() && Values[4]->isNullValue() &&
2856  Values[5]->isNullValue())
2857  return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
2858 
2859  llvm::Constant *Init =
2860  llvm::ConstantStruct::get(ObjCTypes.ProtocolExtensionTy, Values);
2861 
2862  // No special section, but goes in llvm.used
2863  return CreateMetadataVar("\01l_OBJC_PROTOCOLEXT_" + PD->getName(), Init,
2864  StringRef(), CGM.getPointerAlign(), true);
2865 }
2866 
2867 /*
2868  struct objc_protocol_list {
2869  struct objc_protocol_list *next;
2870  long count;
2871  Protocol *list[];
2872  };
2873 */
2874 llvm::Constant *
2875 CGObjCMac::EmitProtocolList(Twine Name,
2878  SmallVector<llvm::Constant *, 16> ProtocolRefs;
2879 
2880  for (; begin != end; ++begin)
2881  ProtocolRefs.push_back(GetProtocolRef(*begin));
2882 
2883  // Just return null for empty protocol lists
2884  if (ProtocolRefs.empty())
2885  return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
2886 
2887  // This list is null terminated.
2888  ProtocolRefs.push_back(llvm::Constant::getNullValue(ObjCTypes.ProtocolPtrTy));
2889 
2890  llvm::Constant *Values[3];
2891  // This field is only used by the runtime.
2892  Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
2893  Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy,
2894  ProtocolRefs.size() - 1);
2895  Values[2] =
2896  llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.ProtocolPtrTy,
2897  ProtocolRefs.size()),
2898  ProtocolRefs);
2899 
2900  llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
2901  llvm::GlobalVariable *GV =
2902  CreateMetadataVar(Name, Init, "__OBJC,__cat_cls_meth,regular,no_dead_strip",
2903  CGM.getPointerAlign(), false);
2904  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
2905 }
2906 
2907 void CGObjCCommonMac::
2908 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
2910  const Decl *Container,
2911  const ObjCProtocolDecl *Proto,
2912  const ObjCCommonTypesHelper &ObjCTypes,
2913  bool IsClassProperty) {
2914  for (const auto *P : Proto->protocols())
2915  PushProtocolProperties(PropertySet, Properties, Container, P, ObjCTypes,
2916  IsClassProperty);
2917 
2918  for (const auto *PD : Proto->properties()) {
2919  if (IsClassProperty != PD->isClassProperty())
2920  continue;
2921  if (!PropertySet.insert(PD->getIdentifier()).second)
2922  continue;
2923  llvm::Constant *Prop[] = {
2924  GetPropertyName(PD->getIdentifier()),
2925  GetPropertyTypeString(PD, Container)
2926  };
2927  Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy, Prop));
2928  }
2929 }
2930 
2931 /*
2932  struct _objc_property {
2933  const char * const name;
2934  const char * const attributes;
2935  };
2936 
2937  struct _objc_property_list {
2938  uint32_t entsize; // sizeof (struct _objc_property)
2939  uint32_t prop_count;
2940  struct _objc_property[prop_count];
2941  };
2942 */
2943 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
2944  const Decl *Container,
2945  const ObjCContainerDecl *OCD,
2946  const ObjCCommonTypesHelper &ObjCTypes,
2947  bool IsClassProperty) {
2948  if (IsClassProperty) {
2949  // Make this entry NULL for OS X with deployment target < 10.11, for iOS
2950  // with deployment target < 9.0.
2951  const llvm::Triple &Triple = CGM.getTarget().getTriple();
2952  if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
2953  (Triple.isiOS() && Triple.isOSVersionLT(9)))
2954  return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
2955  }
2956 
2958  llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
2959 
2960  auto AddProperty = [&](const ObjCPropertyDecl *PD) {
2961  llvm::Constant *Prop[] = {GetPropertyName(PD->getIdentifier()),
2962  GetPropertyTypeString(PD, Container)};
2963  Properties.push_back(llvm::ConstantStruct::get(ObjCTypes.PropertyTy, Prop));
2964  };
2965  if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
2966  for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
2967  for (auto *PD : ClassExt->properties()) {
2968  if (IsClassProperty != PD->isClassProperty())
2969  continue;
2970  PropertySet.insert(PD->getIdentifier());
2971  AddProperty(PD);
2972  }
2973 
2974  for (const auto *PD : OCD->properties()) {
2975  if (IsClassProperty != PD->isClassProperty())
2976  continue;
2977  // Don't emit duplicate metadata for properties that were already in a
2978  // class extension.
2979  if (!PropertySet.insert(PD->getIdentifier()).second)
2980  continue;
2981  AddProperty(PD);
2982  }
2983 
2984  if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
2985  for (const auto *P : OID->all_referenced_protocols())
2986  PushProtocolProperties(PropertySet, Properties, Container, P, ObjCTypes,
2987  IsClassProperty);
2988  }
2989  else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
2990  for (const auto *P : CD->protocols())
2991  PushProtocolProperties(PropertySet, Properties, Container, P, ObjCTypes,
2992  IsClassProperty);
2993  }
2994 
2995  // Return null for empty list.
2996  if (Properties.empty())
2997  return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
2998 
2999  unsigned PropertySize =
3000  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3001  llvm::Constant *Values[3];
3002  Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, PropertySize);
3003  Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Properties.size());
3004  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.PropertyTy,
3005  Properties.size());
3006  Values[2] = llvm::ConstantArray::get(AT, Properties);
3007  llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
3008 
3009  llvm::GlobalVariable *GV =
3010  CreateMetadataVar(Name, Init,
3011  (ObjCABI == 2) ? "__DATA, __objc_const" :
3012  "__OBJC,__property,regular,no_dead_strip",
3013  CGM.getPointerAlign(),
3014  true);
3015  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3016 }
3017 
3018 llvm::Constant *
3019 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3020  ArrayRef<llvm::Constant*> MethodTypes,
3021  const ObjCCommonTypesHelper &ObjCTypes) {
3022  // Return null for empty list.
3023  if (MethodTypes.empty())
3024  return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3025 
3026  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3027  MethodTypes.size());
3028  llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3029 
3030  llvm::GlobalVariable *GV = CreateMetadataVar(
3031  Name, Init, (ObjCABI == 2) ? "__DATA, __objc_const" : StringRef(),
3032  CGM.getPointerAlign(), true);
3033  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3034 }
3035 
3036 /*
3037  struct objc_method_description_list {
3038  int count;
3039  struct objc_method_description list[];
3040  };
3041 */
3042 llvm::Constant *
3043 CGObjCMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
3044  llvm::Constant *Desc[] = {
3045  llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
3046  ObjCTypes.SelectorPtrTy),
3047  GetMethodVarType(MD)
3048  };
3049  if (!Desc[1])
3050  return nullptr;
3051 
3052  return llvm::ConstantStruct::get(ObjCTypes.MethodDescriptionTy,
3053  Desc);
3054 }
3055 
3056 llvm::Constant *
3057 CGObjCMac::EmitMethodDescList(Twine Name, StringRef Section,
3058  ArrayRef<llvm::Constant *> Methods) {
3059  // Return null for empty list.
3060  if (Methods.empty())
3061  return llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
3062 
3063  llvm::Constant *Values[2];
3064  Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
3065  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodDescriptionTy,
3066  Methods.size());
3067  Values[1] = llvm::ConstantArray::get(AT, Methods);
3068  llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
3069 
3070  llvm::GlobalVariable *GV =
3071  CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3072  return llvm::ConstantExpr::getBitCast(GV,
3073  ObjCTypes.MethodDescriptionListPtrTy);
3074 }
3075 
3076 /*
3077  struct _objc_category {
3078  char *category_name;
3079  char *class_name;
3080  struct _objc_method_list *instance_methods;
3081  struct _objc_method_list *class_methods;
3082  struct _objc_protocol_list *protocols;
3083  uint32_t size; // <rdar://4585769>
3084  struct _objc_property_list *instance_properties;
3085  struct _objc_property_list *class_properties;
3086  };
3087 */
3088 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3089  unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3090 
3091  // FIXME: This is poor design, the OCD should have a pointer to the category
3092  // decl. Additionally, note that Category can be null for the @implementation
3093  // w/o an @interface case. Sema should just create one for us as it does for
3094  // @implementation so everyone else can live life under a clear blue sky.
3095  const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3096  const ObjCCategoryDecl *Category =
3097  Interface->FindCategoryDeclaration(OCD->getIdentifier());
3098 
3099  SmallString<256> ExtName;
3100  llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3101  << OCD->getName();
3102 
3103  SmallVector<llvm::Constant *, 16> InstanceMethods, ClassMethods;
3104  for (const auto *I : OCD->instance_methods())
3105  // Instance methods should always be defined.
3106  InstanceMethods.push_back(GetMethodConstant(I));
3107 
3108  for (const auto *I : OCD->class_methods())
3109  // Class methods should always be defined.
3110  ClassMethods.push_back(GetMethodConstant(I));
3111 
3112  llvm::Constant *Values[8];
3113  Values[0] = GetClassName(OCD->getName());
3114  Values[1] = GetClassName(Interface->getObjCRuntimeNameAsString());
3115  LazySymbols.insert(Interface->getIdentifier());
3116  Values[2] = EmitMethodList("OBJC_CATEGORY_INSTANCE_METHODS_" + ExtName.str(),
3117  "__OBJC,__cat_inst_meth,regular,no_dead_strip",
3118  InstanceMethods);
3119  Values[3] = EmitMethodList("OBJC_CATEGORY_CLASS_METHODS_" + ExtName.str(),
3120  "__OBJC,__cat_cls_meth,regular,no_dead_strip",
3121  ClassMethods);
3122  if (Category) {
3123  Values[4] =
3124  EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3125  Category->protocol_begin(), Category->protocol_end());
3126  } else {
3127  Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3128  }
3129  Values[5] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
3130 
3131  // If there is no category @interface then there can be no properties.
3132  if (Category) {
3133  Values[6] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ExtName.str(),
3134  OCD, Category, ObjCTypes, false);
3135  Values[7] = EmitPropertyList("\01l_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3136  OCD, Category, ObjCTypes, true);
3137  } else {
3138  Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3139  Values[7] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3140  }
3141 
3142  llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.CategoryTy,
3143  Values);
3144 
3145  llvm::GlobalVariable *GV =
3146  CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Init,
3147  "__OBJC,__category,regular,no_dead_strip",
3148  CGM.getPointerAlign(), true);
3149  DefinedCategories.push_back(GV);
3150  DefinedCategoryNames.insert(ExtName.str());
3151  // method definition entries must be clear for next implementation.
3152  MethodDefinitions.clear();
3153 }
3154 
3156  /// Apparently: is not a meta-class.
3158 
3159  /// Is a meta-class.
3161 
3162  /// Has a non-trivial constructor or destructor.
3164 
3165  /// Has hidden visibility.
3167 
3168  /// Class implementation was compiled under ARC.
3170 
3171  /// Class implementation was compiled under MRC and has MRC weak ivars.
3172  /// Exclusive with CompiledByARC.
3174 };
3175 
3177  /// Is a meta-class.
3179 
3180  /// Is a root class.
3182 
3183  /// Has a non-trivial constructor or destructor.
3185 
3186  /// Has hidden visibility.
3188 
3189  /// Has the exception attribute.
3191 
3192  /// (Obsolete) ARC-specific: this class has a .release_ivars method
3194 
3195  /// Class implementation was compiled under ARC.
3197 
3198  /// Class has non-trivial destructors, but zero-initialization is okay.
3200 
3201  /// Class implementation was compiled under MRC and has MRC weak ivars.
3202  /// Exclusive with CompiledByARC.
3204 };
3205 
3207  if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3208  return true;
3209  }
3210 
3211  if (auto recType = type->getAs<RecordType>()) {
3212  for (auto field : recType->getDecl()->fields()) {
3213  if (hasWeakMember(field->getType()))
3214  return true;
3215  }
3216  }
3217 
3218  return false;
3219 }
3220 
3221 /// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3222 /// (and actually fill in a layout string) if we really do have any
3223 /// __weak ivars.
3225  const ObjCImplementationDecl *ID) {
3226  if (!CGM.getLangOpts().ObjCWeak) return false;
3227  assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3228 
3229  for (const ObjCIvarDecl *ivar =
3231  ivar; ivar = ivar->getNextIvar()) {
3232  if (hasWeakMember(ivar->getType()))
3233  return true;
3234  }
3235 
3236  return false;
3237 }
3238 
3239 /*
3240  struct _objc_class {
3241  Class isa;
3242  Class super_class;
3243  const char *name;
3244  long version;
3245  long info;
3246  long instance_size;
3247  struct _objc_ivar_list *ivars;
3248  struct _objc_method_list *methods;
3249  struct _objc_cache *cache;
3250  struct _objc_protocol_list *protocols;
3251  // Objective-C 1.0 extensions (<rdr://4585769>)
3252  const char *ivar_layout;
3253  struct _objc_class_ext *ext;
3254  };
3255 
3256  See EmitClassExtension();
3257 */
3258 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3259  DefinedSymbols.insert(ID->getIdentifier());
3260 
3261  std::string ClassName = ID->getNameAsString();
3262  // FIXME: Gross
3263  ObjCInterfaceDecl *Interface =
3264  const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3265  llvm::Constant *Protocols =
3266  EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3267  Interface->all_referenced_protocol_begin(),
3268  Interface->all_referenced_protocol_end());
3269  unsigned Flags = FragileABI_Class_Factory;
3270  if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3272 
3273  bool hasMRCWeak = false;
3274 
3275  if (CGM.getLangOpts().ObjCAutoRefCount)
3277  else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3279 
3280  CharUnits Size =
3282 
3283  // FIXME: Set CXX-structors flag.
3285  Flags |= FragileABI_Class_Hidden;
3286 
3287  SmallVector<llvm::Constant *, 16> InstanceMethods, ClassMethods;
3288  for (const auto *I : ID->instance_methods())
3289  // Instance methods should always be defined.
3290  InstanceMethods.push_back(GetMethodConstant(I));
3291 
3292  for (const auto *I : ID->class_methods())
3293  // Class methods should always be defined.
3294  ClassMethods.push_back(GetMethodConstant(I));
3295 
3296  for (const auto *PID : ID->property_impls()) {
3297  if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3298  ObjCPropertyDecl *PD = PID->getPropertyDecl();
3299 
3300  if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
3301  if (llvm::Constant *C = GetMethodConstant(MD))
3302  InstanceMethods.push_back(C);
3303  if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
3304  if (llvm::Constant *C = GetMethodConstant(MD))
3305  InstanceMethods.push_back(C);
3306  }
3307  }
3308 
3309  llvm::Constant *Values[12];
3310  Values[ 0] = EmitMetaClass(ID, Protocols, ClassMethods);
3311  if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3312  // Record a reference to the super class.
3313  LazySymbols.insert(Super->getIdentifier());
3314 
3315  Values[ 1] =
3316  llvm::ConstantExpr::getBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3317  ObjCTypes.ClassPtrTy);
3318  } else {
3319  Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
3320  }
3321  Values[ 2] = GetClassName(ID->getObjCRuntimeNameAsString());
3322  // Version is always 0.
3323  Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
3324  Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
3325  Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size.getQuantity());
3326  Values[ 6] = EmitIvarList(ID, false);
3327  Values[7] = EmitMethodList("OBJC_INSTANCE_METHODS_" + ID->getName(),
3328  "__OBJC,__inst_meth,regular,no_dead_strip",
3329  InstanceMethods);
3330  // cache is always NULL.
3331  Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
3332  Values[ 9] = Protocols;
3333  Values[10] = BuildStrongIvarLayout(ID, CharUnits::Zero(), Size);
3334  Values[11] = EmitClassExtension(ID, Size, hasMRCWeak,
3335  false/*isClassProperty*/);
3336  llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
3337  Values);
3338  std::string Name("OBJC_CLASS_");
3339  Name += ClassName;
3340  const char *Section = "__OBJC,__class,regular,no_dead_strip";
3341  // Check for a forward reference.
3342  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3343  if (GV) {
3344  assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3345  "Forward metaclass reference has incorrect type.");
3346  GV->setInitializer(Init);
3347  GV->setSection(Section);
3348  GV->setAlignment(CGM.getPointerAlign().getQuantity());
3349  CGM.addCompilerUsedGlobal(GV);
3350  } else
3351  GV = CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3352  DefinedClasses.push_back(GV);
3353  ImplementedClasses.push_back(Interface);
3354  // method definition entries must be clear for next implementation.
3355  MethodDefinitions.clear();
3356 }
3357 
3358 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3359  llvm::Constant *Protocols,
3360  ArrayRef<llvm::Constant*> Methods) {
3361  unsigned Flags = FragileABI_Class_Meta;
3362  unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3363 
3365  Flags |= FragileABI_Class_Hidden;
3366 
3367  llvm::Constant *Values[12];
3368  // The isa for the metaclass is the root of the hierarchy.
3369  const ObjCInterfaceDecl *Root = ID->getClassInterface();
3370  while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3371  Root = Super;
3372  Values[ 0] =
3373  llvm::ConstantExpr::getBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3374  ObjCTypes.ClassPtrTy);
3375  // The super class for the metaclass is emitted as the name of the
3376  // super class. The runtime fixes this up to point to the
3377  // *metaclass* for the super class.
3378  if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3379  Values[ 1] =
3380  llvm::ConstantExpr::getBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3381  ObjCTypes.ClassPtrTy);
3382  } else {
3383  Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
3384  }
3385  Values[ 2] = GetClassName(ID->getObjCRuntimeNameAsString());
3386  // Version is always 0.
3387  Values[ 3] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
3388  Values[ 4] = llvm::ConstantInt::get(ObjCTypes.LongTy, Flags);
3389  Values[ 5] = llvm::ConstantInt::get(ObjCTypes.LongTy, Size);
3390  Values[ 6] = EmitIvarList(ID, true);
3391  Values[7] =
3392  EmitMethodList("OBJC_CLASS_METHODS_" + ID->getNameAsString(),
3393  "__OBJC,__cls_meth,regular,no_dead_strip", Methods);
3394  // cache is always NULL.
3395  Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
3396  Values[ 9] = Protocols;
3397  // ivar_layout for metaclass is always NULL.
3398  Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
3399  // The class extension is used to store class properties for metaclasses.
3400  Values[11] = EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3401  true/*isClassProperty*/);
3402  llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
3403  Values);
3404 
3405  std::string Name("OBJC_METACLASS_");
3406  Name += ID->getName();
3407 
3408  // Check for a forward reference.
3409  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3410  if (GV) {
3411  assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3412  "Forward metaclass reference has incorrect type.");
3413  GV->setInitializer(Init);
3414  } else {
3415  GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3416  llvm::GlobalValue::PrivateLinkage,
3417  Init, Name);
3418  }
3419  GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3420  GV->setAlignment(4);
3421  CGM.addCompilerUsedGlobal(GV);
3422 
3423  return GV;
3424 }
3425 
3426 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3427  std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3428 
3429  // FIXME: Should we look these up somewhere other than the module. Its a bit
3430  // silly since we only generate these while processing an implementation, so
3431  // exactly one pointer would work if know when we entered/exitted an
3432  // implementation block.
3433 
3434  // Check for an existing forward reference.
3435  // Previously, metaclass with internal linkage may have been defined.
3436  // pass 'true' as 2nd argument so it is returned.
3437  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3438  if (!GV)
3439  GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3440  llvm::GlobalValue::PrivateLinkage, nullptr,
3441  Name);
3442 
3443  assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3444  "Forward metaclass reference has incorrect type.");
3445  return GV;
3446 }
3447 
3448 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3449  std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3450  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3451 
3452  if (!GV)
3453  GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3454  llvm::GlobalValue::PrivateLinkage, nullptr,
3455  Name);
3456 
3457  assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3458  "Forward class metadata reference has incorrect type.");
3459  return GV;
3460 }
3461 
3462 /*
3463  Emit a "class extension", which in this specific context means extra
3464  data that doesn't fit in the normal fragile-ABI class structure, and
3465  has nothing to do with the language concept of a class extension.
3466 
3467  struct objc_class_ext {
3468  uint32_t size;
3469  const char *weak_ivar_layout;
3470  struct _objc_property_list *properties;
3471  };
3472 */
3473 llvm::Constant *
3474 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3475  CharUnits InstanceSize, bool hasMRCWeakIvars,
3476  bool isClassProperty) {
3477  uint64_t Size =
3478  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3479 
3480  llvm::Constant *Values[3];
3481  Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
3482  if (isClassProperty) {
3483  llvm::Type *PtrTy = CGM.Int8PtrTy;
3484  Values[1] = llvm::Constant::getNullValue(PtrTy);
3485  } else
3486  Values[1] = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3487  hasMRCWeakIvars);
3488  if (isClassProperty)
3489  Values[2] = EmitPropertyList("\01l_OBJC_$_CLASS_PROP_LIST_" + ID->getName(),
3490  ID, ID->getClassInterface(), ObjCTypes, true);
3491  else
3492  Values[2] = EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getName(),
3493  ID, ID->getClassInterface(), ObjCTypes, false);
3494 
3495  // Return null if no extension bits are used.
3496  if ((!Values[1] || Values[1]->isNullValue()) && Values[2]->isNullValue())
3497  return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3498 
3499  llvm::Constant *Init =
3500  llvm::ConstantStruct::get(ObjCTypes.ClassExtensionTy, Values);
3501  return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), Init,
3502  "__OBJC,__class_ext,regular,no_dead_strip",
3503  CGM.getPointerAlign(), true);
3504 }
3505 
3506 /*
3507  struct objc_ivar {
3508  char *ivar_name;
3509  char *ivar_type;
3510  int ivar_offset;
3511  };
3512 
3513  struct objc_ivar_list {
3514  int ivar_count;
3515  struct objc_ivar list[count];
3516  };
3517 */
3518 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3519  bool ForClass) {
3520  std::vector<llvm::Constant*> Ivars;
3521 
3522  // When emitting the root class GCC emits ivar entries for the
3523  // actual class structure. It is not clear if we need to follow this
3524  // behavior; for now lets try and get away with not doing it. If so,
3525  // the cleanest solution would be to make up an ObjCInterfaceDecl
3526  // for the class.
3527  if (ForClass)
3528  return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3529 
3530  const ObjCInterfaceDecl *OID = ID->getClassInterface();
3531 
3532  for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3533  IVD; IVD = IVD->getNextIvar()) {
3534  // Ignore unnamed bit-fields.
3535  if (!IVD->getDeclName())
3536  continue;
3537  llvm::Constant *Ivar[] = {
3538  GetMethodVarName(IVD->getIdentifier()),
3539  GetMethodVarType(IVD),
3540  llvm::ConstantInt::get(ObjCTypes.IntTy,
3541  ComputeIvarBaseOffset(CGM, OID, IVD))
3542  };
3543  Ivars.push_back(llvm::ConstantStruct::get(ObjCTypes.IvarTy, Ivar));
3544  }
3545 
3546  // Return null for empty list.
3547  if (Ivars.empty())
3548  return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3549 
3550  llvm::Constant *Values[2];
3551  Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
3552  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.IvarTy,
3553  Ivars.size());
3554  Values[1] = llvm::ConstantArray::get(AT, Ivars);
3555  llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
3556 
3557  llvm::GlobalVariable *GV;
3558  if (ForClass)
3559  GV =
3560  CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), Init,
3561  "__OBJC,__class_vars,regular,no_dead_strip",
3562  CGM.getPointerAlign(), true);
3563  else
3564  GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), Init,
3565  "__OBJC,__instance_vars,regular,no_dead_strip",
3566  CGM.getPointerAlign(), true);
3567  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3568 }
3569 
3570 /*
3571  struct objc_method {
3572  SEL method_name;
3573  char *method_types;
3574  void *method;
3575  };
3576 
3577  struct objc_method_list {
3578  struct objc_method_list *obsolete;
3579  int count;
3580  struct objc_method methods_list[count];
3581  };
3582 */
3583 
3584 /// GetMethodConstant - Return a struct objc_method constant for the
3585 /// given method if it has been defined. The result is null if the
3586 /// method has not been defined. The return value has type MethodPtrTy.
3587 llvm::Constant *CGObjCMac::GetMethodConstant(const ObjCMethodDecl *MD) {
3588  llvm::Function *Fn = GetMethodDefinition(MD);
3589  if (!Fn)
3590  return nullptr;
3591 
3592  llvm::Constant *Method[] = {
3593  llvm::ConstantExpr::getBitCast(GetMethodVarName(MD->getSelector()),
3594  ObjCTypes.SelectorPtrTy),
3595  GetMethodVarType(MD),
3596  llvm::ConstantExpr::getBitCast(Fn, ObjCTypes.Int8PtrTy)
3597  };
3598  return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Method);
3599 }
3600 
3601 llvm::Constant *CGObjCMac::EmitMethodList(Twine Name, StringRef Section,
3602  ArrayRef<llvm::Constant *> Methods) {
3603  // Return null for empty list.
3604  if (Methods.empty())
3605  return llvm::Constant::getNullValue(ObjCTypes.MethodListPtrTy);
3606 
3607  llvm::Constant *Values[3];
3608  Values[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
3609  Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
3610  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
3611  Methods.size());
3612  Values[2] = llvm::ConstantArray::get(AT, Methods);
3613  llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
3614 
3615  llvm::GlobalVariable *GV =
3616  CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3617  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
3618 }
3619 
3620 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
3621  const ObjCContainerDecl *CD) {
3622  SmallString<256> Name;
3623  GetNameForMethod(OMD, CD, Name);
3624 
3625  CodeGenTypes &Types = CGM.getTypes();
3626  llvm::FunctionType *MethodTy =
3628  llvm::Function *Method =
3629  llvm::Function::Create(MethodTy,
3631  Name.str(),
3632  &CGM.getModule());
3633  MethodDefinitions.insert(std::make_pair(OMD, Method));
3634 
3635  return Method;
3636 }
3637 
3638 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3639  llvm::Constant *Init,
3640  StringRef Section,
3641  CharUnits Align,
3642  bool AddToUsed) {
3643  llvm::Type *Ty = Init->getType();
3644  llvm::GlobalVariable *GV =
3645  new llvm::GlobalVariable(CGM.getModule(), Ty, false,
3646  llvm::GlobalValue::PrivateLinkage, Init, Name);
3647  if (!Section.empty())
3648  GV->setSection(Section);
3649  GV->setAlignment(Align.getQuantity());
3650  if (AddToUsed)
3651  CGM.addCompilerUsedGlobal(GV);
3652  return GV;
3653 }
3654 
3655 llvm::Function *CGObjCMac::ModuleInitFunction() {
3656  // Abuse this interface function as a place to finalize.
3657  FinishModule();
3658  return nullptr;
3659 }
3660 
3661 llvm::Constant *CGObjCMac::GetPropertyGetFunction() {
3662  return ObjCTypes.getGetPropertyFn();
3663 }
3664 
3665 llvm::Constant *CGObjCMac::GetPropertySetFunction() {
3666  return ObjCTypes.getSetPropertyFn();
3667 }
3668 
3669 llvm::Constant *CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
3670  bool copy) {
3671  return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
3672 }
3673 
3674 llvm::Constant *CGObjCMac::GetGetStructFunction() {
3675  return ObjCTypes.getCopyStructFn();
3676 }
3677 
3678 llvm::Constant *CGObjCMac::GetSetStructFunction() {
3679  return ObjCTypes.getCopyStructFn();
3680 }
3681 
3682 llvm::Constant *CGObjCMac::GetCppAtomicObjectGetFunction() {
3683  return ObjCTypes.getCppAtomicObjectFunction();
3684 }
3685 
3686 llvm::Constant *CGObjCMac::GetCppAtomicObjectSetFunction() {
3687  return ObjCTypes.getCppAtomicObjectFunction();
3688 }
3689 
3690 llvm::Constant *CGObjCMac::EnumerationMutationFunction() {
3691  return ObjCTypes.getEnumerationMutationFn();
3692 }
3693 
3694 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
3695  return EmitTryOrSynchronizedStmt(CGF, S);
3696 }
3697 
3698 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
3699  const ObjCAtSynchronizedStmt &S) {
3700  return EmitTryOrSynchronizedStmt(CGF, S);
3701 }
3702 
3703 namespace {
3704  struct PerformFragileFinally final : EHScopeStack::Cleanup {
3705  const Stmt &S;
3706  Address SyncArgSlot;
3707  Address CallTryExitVar;
3708  Address ExceptionData;
3709  ObjCTypesHelper &ObjCTypes;
3710  PerformFragileFinally(const Stmt *S,
3711  Address SyncArgSlot,
3712  Address CallTryExitVar,
3713  Address ExceptionData,
3714  ObjCTypesHelper *ObjCTypes)
3715  : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
3716  ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
3717 
3718  void Emit(CodeGenFunction &CGF, Flags flags) override {
3719  // Check whether we need to call objc_exception_try_exit.
3720  // In optimized code, this branch will always be folded.
3721  llvm::BasicBlock *FinallyCallExit =
3722  CGF.createBasicBlock("finally.call_exit");
3723  llvm::BasicBlock *FinallyNoCallExit =
3724  CGF.createBasicBlock("finally.no_call_exit");
3725  CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
3726  FinallyCallExit, FinallyNoCallExit);
3727 
3728  CGF.EmitBlock(FinallyCallExit);
3729  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
3730  ExceptionData.getPointer());
3731 
3732  CGF.EmitBlock(FinallyNoCallExit);
3733 
3734  if (isa<ObjCAtTryStmt>(S)) {
3735  if (const ObjCAtFinallyStmt* FinallyStmt =
3736  cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
3737  // Don't try to do the @finally if this is an EH cleanup.
3738  if (flags.isForEHCleanup()) return;
3739 
3740  // Save the current cleanup destination in case there's
3741  // control flow inside the finally statement.
3742  llvm::Value *CurCleanupDest =
3744 
3745  CGF.EmitStmt(FinallyStmt->getFinallyBody());
3746 
3747  if (CGF.HaveInsertPoint()) {
3748  CGF.Builder.CreateStore(CurCleanupDest,
3749  CGF.getNormalCleanupDestSlot());
3750  } else {
3751  // Currently, the end of the cleanup must always exist.
3752  CGF.EnsureInsertPoint();
3753  }
3754  }
3755  } else {
3756  // Emit objc_sync_exit(expr); as finally's sole statement for
3757  // @synchronized.
3758  llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
3759  CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
3760  }
3761  }
3762  };
3763 
3764  class FragileHazards {
3765  CodeGenFunction &CGF;
3767  llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
3768 
3769  llvm::InlineAsm *ReadHazard;
3770  llvm::InlineAsm *WriteHazard;
3771 
3772  llvm::FunctionType *GetAsmFnType();
3773 
3774  void collectLocals();
3775  void emitReadHazard(CGBuilderTy &Builder);
3776 
3777  public:
3778  FragileHazards(CodeGenFunction &CGF);
3779 
3780  void emitWriteHazard();
3781  void emitHazardsInNewBlocks();
3782  };
3783 } // end anonymous namespace
3784 
3785 /// Create the fragile-ABI read and write hazards based on the current
3786 /// state of the function, which is presumed to be immediately prior
3787 /// to a @try block. These hazards are used to maintain correct
3788 /// semantics in the face of optimization and the fragile ABI's
3789 /// cavalier use of setjmp/longjmp.
3790 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
3791  collectLocals();
3792 
3793  if (Locals.empty()) return;
3794 
3795  // Collect all the blocks in the function.
3796  for (llvm::Function::iterator
3797  I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
3798  BlocksBeforeTry.insert(&*I);
3799 
3800  llvm::FunctionType *AsmFnTy = GetAsmFnType();
3801 
3802  // Create a read hazard for the allocas. This inhibits dead-store
3803  // optimizations and forces the values to memory. This hazard is
3804  // inserted before any 'throwing' calls in the protected scope to
3805  // reflect the possibility that the variables might be read from the
3806  // catch block if the call throws.
3807  {
3808  std::string Constraint;
3809  for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
3810  if (I) Constraint += ',';
3811  Constraint += "*m";
3812  }
3813 
3814  ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
3815  }
3816 
3817  // Create a write hazard for the allocas. This inhibits folding
3818  // loads across the hazard. This hazard is inserted at the
3819  // beginning of the catch path to reflect the possibility that the
3820  // variables might have been written within the protected scope.
3821  {
3822  std::string Constraint;
3823  for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
3824  if (I) Constraint += ',';
3825  Constraint += "=*m";
3826  }
3827 
3828  WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
3829  }
3830 }
3831 
3832 /// Emit a write hazard at the current location.
3833 void FragileHazards::emitWriteHazard() {
3834  if (Locals.empty()) return;
3835 
3836  CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
3837 }
3838 
3839 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
3840  assert(!Locals.empty());
3841  llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
3842  call->setDoesNotThrow();
3843  call->setCallingConv(CGF.getRuntimeCC());
3844 }
3845 
3846 /// Emit read hazards in all the protected blocks, i.e. all the blocks
3847 /// which have been inserted since the beginning of the try.
3848 void FragileHazards::emitHazardsInNewBlocks() {
3849  if (Locals.empty()) return;
3850 
3851  CGBuilderTy Builder(CGF, CGF.getLLVMContext());
3852 
3853  // Iterate through all blocks, skipping those prior to the try.
3854  for (llvm::Function::iterator
3855  FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
3856  llvm::BasicBlock &BB = *FI;
3857  if (BlocksBeforeTry.count(&BB)) continue;
3858 
3859  // Walk through all the calls in the block.
3860  for (llvm::BasicBlock::iterator
3861  BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
3862  llvm::Instruction &I = *BI;
3863 
3864  // Ignore instructions that aren't non-intrinsic calls.
3865  // These are the only calls that can possibly call longjmp.
3866  if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I)) continue;
3867  if (isa<llvm::IntrinsicInst>(I))
3868  continue;
3869 
3870  // Ignore call sites marked nounwind. This may be questionable,
3871  // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
3872  llvm::CallSite CS(&I);
3873  if (CS.doesNotThrow()) continue;
3874 
3875  // Insert a read hazard before the call. This will ensure that
3876  // any writes to the locals are performed before making the
3877  // call. If the call throws, then this is sufficient to
3878  // guarantee correctness as long as it doesn't also write to any
3879  // locals.
3880  Builder.SetInsertPoint(&BB, BI);
3881  emitReadHazard(Builder);
3882  }
3883  }
3884 }
3885 
3887  if (V) S.insert(V);
3888 }
3889 
3891  if (V.isValid()) S.insert(V.getPointer());
3892 }
3893 
3894 void FragileHazards::collectLocals() {
3895  // Compute a set of allocas to ignore.
3896  llvm::DenseSet<llvm::Value*> AllocasToIgnore;
3897  addIfPresent(AllocasToIgnore, CGF.ReturnValue);
3898  addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
3899 
3900  // Collect all the allocas currently in the function. This is
3901  // probably way too aggressive.
3902  llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
3903  for (llvm::BasicBlock::iterator
3904  I = Entry.begin(), E = Entry.end(); I != E; ++I)
3905  if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
3906  Locals.push_back(&*I);
3907 }
3908 
3909 llvm::FunctionType *FragileHazards::GetAsmFnType() {
3910  SmallVector<llvm::Type *, 16> tys(Locals.size());
3911  for (unsigned i = 0, e = Locals.size(); i != e; ++i)
3912  tys[i] = Locals[i]->getType();
3913  return llvm::FunctionType::get(CGF.VoidTy, tys, false);
3914 }
3915 
3916 /*
3917 
3918  Objective-C setjmp-longjmp (sjlj) Exception Handling
3919  --
3920 
3921  A catch buffer is a setjmp buffer plus:
3922  - a pointer to the exception that was caught
3923  - a pointer to the previous exception data buffer
3924  - two pointers of reserved storage
3925  Therefore catch buffers form a stack, with a pointer to the top
3926  of the stack kept in thread-local storage.
3927 
3928  objc_exception_try_enter pushes a catch buffer onto the EH stack.
3929  objc_exception_try_exit pops the given catch buffer, which is
3930  required to be the top of the EH stack.
3931  objc_exception_throw pops the top of the EH stack, writes the
3932  thrown exception into the appropriate field, and longjmps
3933  to the setjmp buffer. It crashes the process (with a printf
3934  and an abort()) if there are no catch buffers on the stack.
3935  objc_exception_extract just reads the exception pointer out of the
3936  catch buffer.
3937 
3938  There's no reason an implementation couldn't use a light-weight
3939  setjmp here --- something like __builtin_setjmp, but API-compatible
3940  with the heavyweight setjmp. This will be more important if we ever
3941  want to implement correct ObjC/C++ exception interactions for the
3942  fragile ABI.
3943 
3944  Note that for this use of setjmp/longjmp to be correct, we may need
3945  to mark some local variables volatile: if a non-volatile local
3946  variable is modified between the setjmp and the longjmp, it has
3947  indeterminate value. For the purposes of LLVM IR, it may be
3948  sufficient to make loads and stores within the @try (to variables
3949  declared outside the @try) volatile. This is necessary for
3950  optimized correctness, but is not currently being done; this is
3951  being tracked as rdar://problem/8160285
3952 
3953  The basic framework for a @try-catch-finally is as follows:
3954  {
3955  objc_exception_data d;
3956  id _rethrow = null;
3957  bool _call_try_exit = true;
3958 
3959  objc_exception_try_enter(&d);
3960  if (!setjmp(d.jmp_buf)) {
3961  ... try body ...
3962  } else {
3963  // exception path
3964  id _caught = objc_exception_extract(&d);
3965 
3966  // enter new try scope for handlers
3967  if (!setjmp(d.jmp_buf)) {
3968  ... match exception and execute catch blocks ...
3969 
3970  // fell off end, rethrow.
3971  _rethrow = _caught;
3972  ... jump-through-finally to finally_rethrow ...
3973  } else {
3974  // exception in catch block
3975  _rethrow = objc_exception_extract(&d);
3976  _call_try_exit = false;
3977  ... jump-through-finally to finally_rethrow ...
3978  }
3979  }
3980  ... jump-through-finally to finally_end ...
3981 
3982  finally:
3983  if (_call_try_exit)
3984  objc_exception_try_exit(&d);
3985 
3986  ... finally block ....
3987  ... dispatch to finally destination ...
3988 
3989  finally_rethrow:
3990  objc_exception_throw(_rethrow);
3991 
3992  finally_end:
3993  }
3994 
3995  This framework differs slightly from the one gcc uses, in that gcc
3996  uses _rethrow to determine if objc_exception_try_exit should be called
3997  and if the object should be rethrown. This breaks in the face of
3998  throwing nil and introduces unnecessary branches.
3999 
4000  We specialize this framework for a few particular circumstances:
4001 
4002  - If there are no catch blocks, then we avoid emitting the second
4003  exception handling context.
4004 
4005  - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4006  e)) we avoid emitting the code to rethrow an uncaught exception.
4007 
4008  - FIXME: If there is no @finally block we can do a few more
4009  simplifications.
4010 
4011  Rethrows and Jumps-Through-Finally
4012  --
4013 
4014  '@throw;' is supported by pushing the currently-caught exception
4015  onto ObjCEHStack while the @catch blocks are emitted.
4016 
4017  Branches through the @finally block are handled with an ordinary
4018  normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
4019  exceptions are not compatible with C++ exceptions, and this is
4020  hardly the only place where this will go wrong.
4021 
4022  @synchronized(expr) { stmt; } is emitted as if it were:
4023  id synch_value = expr;
4024  objc_sync_enter(synch_value);
4025  @try { stmt; } @finally { objc_sync_exit(synch_value); }
4026 */
4027 
4028 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4029  const Stmt &S) {
4030  bool isTry = isa<ObjCAtTryStmt>(S);
4031 
4032  // A destination for the fall-through edges of the catch handlers to
4033  // jump to.
4034  CodeGenFunction::JumpDest FinallyEnd =
4035  CGF.getJumpDestInCurrentScope("finally.end");
4036 
4037  // A destination for the rethrow edge of the catch handlers to jump
4038  // to.
4039  CodeGenFunction::JumpDest FinallyRethrow =
4040  CGF.getJumpDestInCurrentScope("finally.rethrow");
4041 
4042  // For @synchronized, call objc_sync_enter(sync.expr). The
4043  // evaluation of the expression must occur before we enter the
4044  // @synchronized. We can't avoid a temp here because we need the
4045  // value to be preserved. If the backend ever does liveness
4046  // correctly after setjmp, this will be unnecessary.
4047  Address SyncArgSlot = Address::invalid();
4048  if (!isTry) {
4049  llvm::Value *SyncArg =
4050  CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4051  SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4052  CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4053 
4054  SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4055  CGF.getPointerAlign(), "sync.arg");
4056  CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4057  }
4058 
4059  // Allocate memory for the setjmp buffer. This needs to be kept
4060  // live throughout the try and catch blocks.
4061  Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4062  CGF.getPointerAlign(),
4063  "exceptiondata.ptr");
4064 
4065  // Create the fragile hazards. Note that this will not capture any
4066  // of the allocas required for exception processing, but will
4067  // capture the current basic block (which extends all the way to the
4068  // setjmp call) as "before the @try".
4069  FragileHazards Hazards(CGF);
4070 
4071  // Create a flag indicating whether the cleanup needs to call
4072  // objc_exception_try_exit. This is true except when
4073  // - no catches match and we're branching through the cleanup
4074  // just to rethrow the exception, or
4075  // - a catch matched and we're falling out of the catch handler.
4076  // The setjmp-safety rule here is that we should always store to this
4077  // variable in a place that dominates the branch through the cleanup
4078  // without passing through any setjmps.
4079  Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4080  CharUnits::One(),
4081  "_call_try_exit");
4082 
4083  // A slot containing the exception to rethrow. Only needed when we
4084  // have both a @catch and a @finally.
4085  Address PropagatingExnVar = Address::invalid();
4086 
4087  // Push a normal cleanup to leave the try scope.
4088  CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4089  SyncArgSlot,
4090  CallTryExitVar,
4091  ExceptionData,
4092  &ObjCTypes);
4093 
4094  // Enter a try block:
4095  // - Call objc_exception_try_enter to push ExceptionData on top of
4096  // the EH stack.
4097  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4098  ExceptionData.getPointer());
4099 
4100  // - Call setjmp on the exception data buffer.
4101  llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4102  llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4103  llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4104  ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4105  "setjmp_buffer");
4106  llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4107  ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4108  SetJmpResult->setCanReturnTwice();
4109 
4110  // If setjmp returned 0, enter the protected block; otherwise,
4111  // branch to the handler.
4112  llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4113  llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4114  llvm::Value *DidCatch =
4115  CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4116  CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4117 
4118  // Emit the protected block.
4119  CGF.EmitBlock(TryBlock);
4120  CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4121  CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4122  : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4123 
4124  CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4125 
4126  // Emit the exception handler block.
4127  CGF.EmitBlock(TryHandler);
4128 
4129  // Don't optimize loads of the in-scope locals across this point.
4130  Hazards.emitWriteHazard();
4131 
4132  // For a @synchronized (or a @try with no catches), just branch
4133  // through the cleanup to the rethrow block.
4134  if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4135  // Tell the cleanup not to re-pop the exit.
4136  CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4137  CGF.EmitBranchThroughCleanup(FinallyRethrow);
4138 
4139  // Otherwise, we have to match against the caught exceptions.
4140  } else {
4141  // Retrieve the exception object. We may emit multiple blocks but
4142  // nothing can cross this so the value is already in SSA form.
4143  llvm::CallInst *Caught =
4144  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4145  ExceptionData.getPointer(), "caught");
4146 
4147  // Push the exception to rethrow onto the EH value stack for the
4148  // benefit of any @throws in the handlers.
4149  CGF.ObjCEHValueStack.push_back(Caught);
4150 
4151  const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4152 
4153  bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4154 
4155  llvm::BasicBlock *CatchBlock = nullptr;
4156  llvm::BasicBlock *CatchHandler = nullptr;
4157  if (HasFinally) {
4158  // Save the currently-propagating exception before
4159  // objc_exception_try_enter clears the exception slot.
4160  PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4161  CGF.getPointerAlign(),
4162  "propagating_exception");
4163  CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4164 
4165  // Enter a new exception try block (in case a @catch block
4166  // throws an exception).
4167  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4168  ExceptionData.getPointer());
4169 
4170  llvm::CallInst *SetJmpResult =
4171  CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4172  SetJmpBuffer, "setjmp.result");
4173  SetJmpResult->setCanReturnTwice();
4174 
4175  llvm::Value *Threw =
4176  CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4177 
4178  CatchBlock = CGF.createBasicBlock("catch");
4179  CatchHandler = CGF.createBasicBlock("catch_for_catch");
4180  CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4181 
4182  CGF.EmitBlock(CatchBlock);
4183  }
4184 
4185  CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4186 
4187  // Handle catch list. As a special case we check if everything is
4188  // matched and avoid generating code for falling off the end if
4189  // so.
4190  bool AllMatched = false;
4191  for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
4192  const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4193 
4194  const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4195  const ObjCObjectPointerType *OPT = nullptr;
4196 
4197  // catch(...) always matches.
4198  if (!CatchParam) {
4199  AllMatched = true;
4200  } else {
4201  OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4202 
4203  // catch(id e) always matches under this ABI, since only
4204  // ObjC exceptions end up here in the first place.
4205  // FIXME: For the time being we also match id<X>; this should
4206  // be rejected by Sema instead.
4207  if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4208  AllMatched = true;
4209  }
4210 
4211  // If this is a catch-all, we don't need to test anything.
4212  if (AllMatched) {
4213  CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4214 
4215  if (CatchParam) {
4216  CGF.EmitAutoVarDecl(*CatchParam);
4217  assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4218 
4219  // These types work out because ConvertType(id) == i8*.
4220  EmitInitOfCatchParam(CGF, Caught, CatchParam);
4221  }
4222 
4223  CGF.EmitStmt(CatchStmt->getCatchBody());
4224 
4225  // The scope of the catch variable ends right here.
4226  CatchVarCleanups.ForceCleanup();
4227 
4228  CGF.EmitBranchThroughCleanup(FinallyEnd);
4229  break;
4230  }
4231 
4232  assert(OPT && "Unexpected non-object pointer type in @catch");
4233  const ObjCObjectType *ObjTy = OPT->getObjectType();
4234 
4235  // FIXME: @catch (Class c) ?
4236  ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4237  assert(IDecl && "Catch parameter must have Objective-C type!");
4238 
4239  // Check if the @catch block matches the exception object.
4240  llvm::Value *Class = EmitClassRef(CGF, IDecl);
4241 
4242  llvm::Value *matchArgs[] = { Class, Caught };
4243  llvm::CallInst *Match =
4244  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4245  matchArgs, "match");
4246 
4247  llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4248  llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4249 
4250  CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4251  MatchedBlock, NextCatchBlock);
4252 
4253  // Emit the @catch block.
4254  CGF.EmitBlock(MatchedBlock);
4255 
4256  // Collect any cleanups for the catch variable. The scope lasts until
4257  // the end of the catch body.
4258  CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4259 
4260  CGF.EmitAutoVarDecl(*CatchParam);
4261  assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4262 
4263  // Initialize the catch variable.
4264  llvm::Value *Tmp =
4265  CGF.Builder.CreateBitCast(Caught,
4266  CGF.ConvertType(CatchParam->getType()));
4267  EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4268 
4269  CGF.EmitStmt(CatchStmt->getCatchBody());
4270 
4271  // We're done with the catch variable.
4272  CatchVarCleanups.ForceCleanup();
4273 
4274  CGF.EmitBranchThroughCleanup(FinallyEnd);
4275 
4276  CGF.EmitBlock(NextCatchBlock);
4277  }
4278 
4279  CGF.ObjCEHValueStack.pop_back();
4280 
4281  // If nothing wanted anything to do with the caught exception,
4282  // kill the extract call.
4283  if (Caught->use_empty())
4284  Caught->eraseFromParent();
4285 
4286  if (!AllMatched)
4287  CGF.EmitBranchThroughCleanup(FinallyRethrow);
4288 
4289  if (HasFinally) {
4290  // Emit the exception handler for the @catch blocks.
4291  CGF.EmitBlock(CatchHandler);
4292 
4293  // In theory we might now need a write hazard, but actually it's
4294  // unnecessary because there's no local-accessing code between
4295  // the try's write hazard and here.
4296  //Hazards.emitWriteHazard();
4297 
4298  // Extract the new exception and save it to the
4299  // propagating-exception slot.
4300  assert(PropagatingExnVar.isValid());
4301  llvm::CallInst *NewCaught =
4302  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4303  ExceptionData.getPointer(), "caught");
4304  CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4305 
4306  // Don't pop the catch handler; the throw already did.
4307  CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4308  CGF.EmitBranchThroughCleanup(FinallyRethrow);
4309  }
4310  }
4311 
4312  // Insert read hazards as required in the new blocks.
4313  Hazards.emitHazardsInNewBlocks();
4314 
4315  // Pop the cleanup.
4316  CGF.Builder.restoreIP(TryFallthroughIP);
4317  if (CGF.HaveInsertPoint())
4318  CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4319  CGF.PopCleanupBlock();
4320  CGF.EmitBlock(FinallyEnd.getBlock(), true);
4321 
4322  // Emit the rethrow block.
4323  CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4324  CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4325  if (CGF.HaveInsertPoint()) {
4326  // If we have a propagating-exception variable, check it.
4327  llvm::Value *PropagatingExn;
4328  if (PropagatingExnVar.isValid()) {
4329  PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4330 
4331  // Otherwise, just look in the buffer for the exception to throw.
4332  } else {
4333  llvm::CallInst *Caught =
4334  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4335  ExceptionData.getPointer());
4336  PropagatingExn = Caught;
4337  }
4338 
4339  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4340  PropagatingExn);
4341  CGF.Builder.CreateUnreachable();
4342  }
4343 
4344  CGF.Builder.restoreIP(SavedIP);
4345 }
4346 
4347 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4348  const ObjCAtThrowStmt &S,
4349  bool ClearInsertionPoint) {
4350  llvm::Value *ExceptionAsObject;
4351 
4352  if (const Expr *ThrowExpr = S.getThrowExpr()) {
4353  llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4354  ExceptionAsObject =
4355  CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4356  } else {
4357  assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4358  "Unexpected rethrow outside @catch block.");
4359  ExceptionAsObject = CGF.ObjCEHValueStack.back();
4360  }
4361 
4362  CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4363  ->setDoesNotReturn();
4364  CGF.Builder.CreateUnreachable();
4365 
4366  // Clear the insertion point to indicate we are in unreachable code.
4367  if (ClearInsertionPoint)
4368  CGF.Builder.ClearInsertionPoint();
4369 }
4370 
4371 /// EmitObjCWeakRead - Code gen for loading value of a __weak
4372 /// object: objc_read_weak (id *src)
4373 ///
4374 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4375  Address AddrWeakObj) {
4376  llvm::Type* DestTy = AddrWeakObj.getElementType();
4377  AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4378  ObjCTypes.PtrObjectPtrTy);
4379  llvm::Value *read_weak =
4380  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4381  AddrWeakObj.getPointer(), "weakread");
4382  read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4383  return read_weak;
4384 }
4385 
4386 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4387 /// objc_assign_weak (id src, id *dst)
4388 ///
4389 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4390  llvm::Value *src, Address dst) {
4391  llvm::Type * SrcTy = src->getType();
4392  if (!isa<llvm::PointerType>(SrcTy)) {
4393  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4394  assert(Size <= 8 && "does not support size > 8");
4395  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4396  : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4397  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4398  }
4399  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4400  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4401  llvm::Value *args[] = { src, dst.getPointer() };
4402  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4403  args, "weakassign");
4404 }
4405 
4406 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4407 /// objc_assign_global (id src, id *dst)
4408 ///
4409 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4410  llvm::Value *src, Address dst,
4411  bool threadlocal) {
4412  llvm::Type * SrcTy = src->getType();
4413  if (!isa<llvm::PointerType>(SrcTy)) {
4414  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4415  assert(Size <= 8 && "does not support size > 8");
4416  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4417  : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4418  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4419  }
4420  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4421  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4422  llvm::Value *args[] = { src, dst.getPointer() };
4423  if (!threadlocal)
4424  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4425  args, "globalassign");
4426  else
4427  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4428  args, "threadlocalassign");
4429 }
4430 
4431 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4432 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4433 ///
4434 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4435  llvm::Value *src, Address dst,
4436  llvm::Value *ivarOffset) {
4437  assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
4438  llvm::Type * SrcTy = src->getType();
4439  if (!isa<llvm::PointerType>(SrcTy)) {
4440  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4441  assert(Size <= 8 && "does not support size > 8");
4442  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4443  : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4444  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4445  }
4446  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4447  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4448  llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
4449  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
4450 }
4451 
4452 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
4453 /// objc_assign_strongCast (id src, id *dst)
4454 ///
4455 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
4456  llvm::Value *src, Address dst) {
4457  llvm::Type * SrcTy = src->getType();
4458  if (!isa<llvm::PointerType>(SrcTy)) {
4459  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4460  assert(Size <= 8 && "does not support size > 8");
4461  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
4462  : CGF.Builder.CreateBitCast(src, ObjCTypes.LongLongTy);
4463  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4464  }
4465  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4466  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4467  llvm::Value *args[] = { src, dst.getPointer() };
4468  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
4469  args, "strongassign");
4470 }
4471 
4472 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
4473  Address DestPtr,
4474  Address SrcPtr,
4475  llvm::Value *size) {
4476  SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
4477  DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
4478  llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
4479  CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
4480 }
4481 
4482 /// EmitObjCValueForIvar - Code Gen for ivar reference.
4483 ///
4484 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
4485  QualType ObjectTy,
4486  llvm::Value *BaseValue,
4487  const ObjCIvarDecl *Ivar,
4488  unsigned CVRQualifiers) {
4489  const ObjCInterfaceDecl *ID =
4490  ObjectTy->getAs<ObjCObjectType>()->getInterface();
4491  return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
4492  EmitIvarOffset(CGF, ID, Ivar));
4493 }
4494 
4495 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
4496  const ObjCInterfaceDecl *Interface,
4497  const ObjCIvarDecl *Ivar) {
4498  uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
4499  return llvm::ConstantInt::get(
4500  CGM.getTypes().ConvertType(CGM.getContext().LongTy),
4501  Offset);
4502 }
4503 
4504 /* *** Private Interface *** */
4505 
4506 /// EmitImageInfo - Emit the image info marker used to encode some module
4507 /// level information.
4508 ///
4509 /// See: <rdr://4810609&4810587&4810587>
4510 /// struct IMAGE_INFO {
4511 /// unsigned version;
4512 /// unsigned flags;
4513 /// };
4514 enum ImageInfoFlags {
4515  eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang.
4516  eImageInfo_GarbageCollected = (1 << 1),
4517  eImageInfo_GCOnly = (1 << 2),
4518  eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache.
4519 
4520  // A flag indicating that the module has no instances of a @synthesize of a
4521  // superclass variable. <rdar://problem/6803242>
4522  eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
4523  eImageInfo_ImageIsSimulated = (1 << 5),
4524  eImageInfo_ClassProperties = (1 << 6)
4525 };
4526 
4527 void CGObjCCommonMac::EmitImageInfo() {
4528  unsigned version = 0; // Version is unused?
4529  const char *Section = (ObjCABI == 1) ?
4530  "__OBJC, __image_info,regular" :
4531  "__DATA, __objc_imageinfo, regular, no_dead_strip";
4532 
4533  // Generate module-level named metadata to convey this information to the
4534  // linker and code-gen.
4535  llvm::Module &Mod = CGM.getModule();
4536 
4537  // Add the ObjC ABI version to the module flags.
4538  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
4539  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
4540  version);
4541  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
4542  llvm::MDString::get(VMContext,Section));
4543 
4544  if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
4545  // Non-GC overrides those files which specify GC.
4546  Mod.addModuleFlag(llvm::Module::Override,
4547  "Objective-C Garbage Collection", (uint32_t)0);
4548  } else {
4549  // Add the ObjC garbage collection value.
4550  Mod.addModuleFlag(llvm::Module::Error,
4551  "Objective-C Garbage Collection",
4552  eImageInfo_GarbageCollected);
4553 
4554  if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
4555  // Add the ObjC GC Only value.
4556  Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
4557  eImageInfo_GCOnly);
4558 
4559  // Require that GC be specified and set to eImageInfo_GarbageCollected.
4560  llvm::Metadata *Ops[2] = {
4561  llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
4562  llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
4563  llvm::Type::getInt32Ty(VMContext), eImageInfo_GarbageCollected))};
4564  Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
4565  llvm::MDNode::get(VMContext, Ops));
4566  }
4567  }
4568 
4569  // Indicate whether we're compiling this to run on a simulator.
4570  const llvm::Triple &Triple = CGM.getTarget().getTriple();
4571  if ((Triple.isiOS() || Triple.isWatchOS()) &&
4572  (Triple.getArch() == llvm::Triple::x86 ||
4573  Triple.getArch() == llvm::Triple::x86_64))
4574  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
4575  eImageInfo_ImageIsSimulated);
4576 
4577  // Indicate whether we are generating class properties.
4578  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
4579  eImageInfo_ClassProperties);
4580 }
4581 
4582 // struct objc_module {
4583 // unsigned long version;
4584 // unsigned long size;
4585 // const char *name;
4586 // Symtab symtab;
4587 // };
4588 
4589 // FIXME: Get from somewhere
4590 static const int ModuleVersion = 7;
4591 
4592 void CGObjCMac::EmitModuleInfo() {
4593  uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
4594 
4595  llvm::Constant *Values[] = {
4596  llvm::ConstantInt::get(ObjCTypes.LongTy, ModuleVersion),
4597  llvm::ConstantInt::get(ObjCTypes.LongTy, Size),
4598  // This used to be the filename, now it is unused. <rdr://4327263>
4599  GetClassName(StringRef("")),
4600  EmitModuleSymbols()
4601  };
4602  CreateMetadataVar("OBJC_MODULES",
4603  llvm::ConstantStruct::get(ObjCTypes.ModuleTy, Values),
4604  "__OBJC,__module_info,regular,no_dead_strip",
4605  CGM.getPointerAlign(), true);
4606 }
4607 
4608 llvm::Constant *CGObjCMac::EmitModuleSymbols() {
4609  unsigned NumClasses = DefinedClasses.size();
4610  unsigned NumCategories = DefinedCategories.size();
4611 
4612  // Return null if no symbols were defined.
4613  if (!NumClasses && !NumCategories)
4614  return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
4615 
4616  llvm::Constant *Values[5];
4617  Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
4618  Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy);
4619  Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses);
4620  Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories);
4621 
4622  // The runtime expects exactly the list of defined classes followed
4623  // by the list of defined categories, in a single array.
4624  SmallVector<llvm::Constant*, 8> Symbols(NumClasses + NumCategories);
4625  for (unsigned i=0; i<NumClasses; i++) {
4626  const ObjCInterfaceDecl *ID = ImplementedClasses[i];
4627  assert(ID);
4628  if (ObjCImplementationDecl *IMP = ID->getImplementation())
4629  // We are implementing a weak imported interface. Give it external linkage
4630  if (ID->isWeakImported() && !IMP->isWeakImported())
4631  DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
4632 
4633  Symbols[i] = llvm::ConstantExpr::getBitCast(DefinedClasses[i],
4634  ObjCTypes.Int8PtrTy);
4635  }
4636  for (unsigned i=0; i<NumCategories; i++)
4637  Symbols[NumClasses + i] =
4638  llvm::ConstantExpr::getBitCast(DefinedCategories[i],
4639  ObjCTypes.Int8PtrTy);
4640 
4641  Values[4] =
4642  llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
4643  Symbols.size()),
4644  Symbols);
4645 
4646  llvm::Constant *Init = llvm::ConstantStruct::getAnon(Values);
4647 
4648  llvm::GlobalVariable *GV = CreateMetadataVar(
4649  "OBJC_SYMBOLS", Init, "__OBJC,__symbols,regular,no_dead_strip",
4650  CGM.getPointerAlign(), true);
4651  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
4652 }
4653 
4654 llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
4655  IdentifierInfo *II) {
4656  LazySymbols.insert(II);
4657 
4658  llvm::GlobalVariable *&Entry = ClassReferences[II];
4659 
4660  if (!Entry) {
4661  llvm::Constant *Casted =
4662  llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
4663  ObjCTypes.ClassPtrTy);
4664  Entry = CreateMetadataVar(
4665  "OBJC_CLASS_REFERENCES_", Casted,
4666  "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
4667  CGM.getPointerAlign(), true);
4668  }
4669 
4670  return CGF.Builder.CreateAlignedLoad(Entry, CGF.getPointerAlign());
4671 }
4672 
4673 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
4674  const ObjCInterfaceDecl *ID) {
4675  // If the class has the objc_runtime_visible attribute, we need to
4676  // use the Objective-C runtime to get the class.
4677  if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
4678  return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
4679 
4680  return EmitClassRefFromId(CGF, ID->getIdentifier());
4681 }
4682 
4683 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
4684  IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
4685  return EmitClassRefFromId(CGF, II);
4686 }
4687 
4688 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
4689  return CGF.Builder.CreateLoad(EmitSelectorAddr(CGF, Sel));
4690 }
4691 
4692 Address CGObjCMac::EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel) {
4693  CharUnits Align = CGF.getPointerAlign();
4694 
4695  llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
4696  if (!Entry) {
4697  llvm::Constant *Casted =
4698  llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
4699  ObjCTypes.SelectorPtrTy);
4700  Entry = CreateMetadataVar(
4701  "OBJC_SELECTOR_REFERENCES_", Casted,
4702  "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
4703  Entry->setExternallyInitialized(true);
4704  }
4705 
4706  return Address(Entry, Align);
4707 }
4708 
4709 llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
4710  llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
4711  if (!Entry)
4712  Entry = CreateMetadataVar(
4713  "OBJC_CLASS_NAME_",
4714  llvm::ConstantDataArray::getString(VMContext, RuntimeName),
4715  ((ObjCABI == 2) ? "__TEXT,__objc_classname,cstring_literals"
4716  : "__TEXT,__cstring,cstring_literals"),
4717  CharUnits::One(), true);
4718  return getConstantGEP(VMContext, Entry, 0, 0);
4719 }
4720 
4721 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
4722  llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
4723  I = MethodDefinitions.find(MD);
4724  if (I != MethodDefinitions.end())
4725  return I->second;
4726 
4727  return nullptr;
4728 }
4729 
4730 /// GetIvarLayoutName - Returns a unique constant for the given
4731 /// ivar layout bitmap.
4732 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
4733  const ObjCCommonTypesHelper &ObjCTypes) {
4734  return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
4735 }
4736 
4737 void IvarLayoutBuilder::visitRecord(const RecordType *RT,
4738  CharUnits offset) {
4739  const RecordDecl *RD = RT->getDecl();
4740 
4741  // If this is a union, remember that we had one, because it might mess
4742  // up the ordering of layout entries.
4743  if (RD->isUnion())
4744  IsDisordered = true;
4745 
4746  const ASTRecordLayout *recLayout = nullptr;
4747  visitAggregate(RD->field_begin(), RD->field_end(), offset,
4748  [&](const FieldDecl *field) -> CharUnits {
4749  if (!recLayout)
4750  recLayout = &CGM.getContext().getASTRecordLayout(RD);
4751  auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
4752  return CGM.getContext().toCharUnitsFromBits(offsetInBits);
4753  });
4754 }
4755 
4756 template <class Iterator, class GetOffsetFn>
4757 void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
4758  CharUnits aggregateOffset,
4759  const GetOffsetFn &getOffset) {
4760  for (; begin != end; ++begin) {
4761  auto field = *begin;
4762 
4763  // Skip over bitfields.
4764  if (field->isBitField()) {
4765  continue;
4766  }
4767 
4768  // Compute the offset of the field within the aggregate.
4769  CharUnits fieldOffset = aggregateOffset + getOffset(field);
4770 
4771  visitField(field, fieldOffset);
4772  }
4773 }
4774 
4775 /// Collect layout information for the given fields into IvarsInfo.
4776 void IvarLayoutBuilder::visitField(const FieldDecl *field,
4777  CharUnits fieldOffset) {
4778  QualType fieldType = field->getType();
4779 
4780  // Drill down into arrays.
4781  uint64_t numElts = 1;
4782  while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
4783  numElts *= arrayType->getSize().getZExtValue();
4784  fieldType = arrayType->getElementType();
4785  }
4786 
4787  assert(!fieldType->isArrayType() && "ivar of non-constant array type?");
4788 
4789  // If we ended up with a zero-sized array, we've done what we can do within
4790  // the limits of this layout encoding.
4791  if (numElts == 0) return;
4792 
4793  // Recurse if the base element type is a record type.
4794  if (auto recType = fieldType->getAs<RecordType>()) {
4795  size_t oldEnd = IvarsInfo.size();
4796 
4797  visitRecord(recType, fieldOffset);
4798 
4799  // If we have an array, replicate the first entry's layout information.
4800  auto numEltEntries = IvarsInfo.size() - oldEnd;
4801  if (numElts != 1 && numEltEntries != 0) {
4802  CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
4803  for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
4804  // Copy the last numEltEntries onto the end of the array, adjusting
4805  // each for the element size.
4806  for (size_t i = 0; i != numEltEntries; ++i) {
4807  auto firstEntry = IvarsInfo[oldEnd + i];
4808  IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
4809  firstEntry.SizeInWords));
4810  }
4811  }
4812  }
4813 
4814  return;
4815  }
4816 
4817  // Classify the element type.
4818  Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
4819 
4820  // If it matches what we're looking for, add an entry.
4821  if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
4822  || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
4823  assert(CGM.getContext().getTypeSizeInChars(fieldType)
4824  == CGM.getPointerSize());
4825  IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
4826  }
4827 }
4828 
4829 /// buildBitmap - This routine does the horsework of taking the offsets of
4830 /// strong/weak references and creating a bitmap. The bitmap is also
4831 /// returned in the given buffer, suitable for being passed to \c dump().
4832 llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
4833  llvm::SmallVectorImpl<unsigned char> &buffer) {
4834  // The bitmap is a series of skip/scan instructions, aligned to word
4835  // boundaries. The skip is performed first.
4836  const unsigned char MaxNibble = 0xF;
4837  const unsigned char SkipMask = 0xF0, SkipShift = 4;
4838  const unsigned char ScanMask = 0x0F, ScanShift = 0;
4839 
4840  assert(!IvarsInfo.empty() && "generating bitmap for no data");
4841 
4842  // Sort the ivar info on byte position in case we encounterred a
4843  // union nested in the ivar list.
4844  if (IsDisordered) {
4845  // This isn't a stable sort, but our algorithm should handle it fine.
4846  llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
4847  } else {
4848  assert(std::is_sorted(IvarsInfo.begin(), IvarsInfo.end()));
4849  }
4850  assert(IvarsInfo.back().Offset < InstanceEnd);
4851 
4852  assert(buffer.empty());
4853 
4854  // Skip the next N words.
4855  auto skip = [&](unsigned numWords) {
4856  assert(numWords > 0);
4857 
4858  // Try to merge into the previous byte. Since scans happen second, we
4859  // can't do this if it includes a scan.
4860  if (!buffer.empty() && !(buffer.back() & ScanMask)) {
4861  unsigned lastSkip = buffer.back() >> SkipShift;
4862  if (lastSkip < MaxNibble) {
4863  unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
4864  numWords -= claimed;
4865  lastSkip += claimed;
4866  buffer.back() = (lastSkip << SkipShift);
4867  }
4868  }
4869 
4870  while (numWords >= MaxNibble) {
4871  buffer.push_back(MaxNibble << SkipShift);
4872  numWords -= MaxNibble;
4873  }
4874  if (numWords) {
4875  buffer.push_back(numWords << SkipShift);
4876  }
4877  };
4878 
4879  // Scan the next N words.
4880  auto scan = [&](unsigned numWords) {
4881  assert(numWords > 0);
4882 
4883  // Try to merge into the previous byte. Since scans happen second, we can
4884  // do this even if it includes a skip.
4885  if (!buffer.empty()) {
4886  unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
4887  if (lastScan < MaxNibble) {
4888  unsigned claimed = std::min(MaxNibble - lastScan, numWords);
4889  numWords -= claimed;
4890  lastScan += claimed;
4891  buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
4892  }
4893  }
4894 
4895  while (numWords >= MaxNibble) {
4896  buffer.push_back(MaxNibble << ScanShift);
4897  numWords -= MaxNibble;
4898  }
4899  if (numWords) {
4900  buffer.push_back(numWords << ScanShift);
4901  }
4902  };
4903 
4904  // One past the end of the last scan.
4905  unsigned endOfLastScanInWords = 0;
4906  const CharUnits WordSize = CGM.getPointerSize();
4907 
4908  // Consider all the scan requests.
4909  for (auto &request : IvarsInfo) {
4910  CharUnits beginOfScan = request.Offset - InstanceBegin;
4911 
4912  // Ignore scan requests that don't start at an even multiple of the
4913  // word size. We can't encode them.
4914  if ((beginOfScan % WordSize) != 0) continue;
4915 
4916  // Ignore scan requests that start before the instance start.
4917  // This assumes that scans never span that boundary. The boundary
4918  // isn't the true start of the ivars, because in the fragile-ARC case
4919  // it's rounded up to word alignment, but the test above should leave
4920  // us ignoring that possibility.
4921  if (beginOfScan.isNegative()) {
4922  assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin);
4923  continue;
4924  }
4925 
4926  unsigned beginOfScanInWords = beginOfScan / WordSize;
4927  unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
4928 
4929  // If the scan starts some number of words after the last one ended,
4930  // skip forward.
4931  if (beginOfScanInWords > endOfLastScanInWords) {
4932  skip(beginOfScanInWords - endOfLastScanInWords);
4933 
4934  // Otherwise, start scanning where the last left off.
4935  } else {
4936  beginOfScanInWords = endOfLastScanInWords;
4937 
4938  // If that leaves us with nothing to scan, ignore this request.
4939  if (beginOfScanInWords >= endOfScanInWords) continue;
4940  }
4941 
4942  // Scan to the end of the request.
4943  assert(beginOfScanInWords < endOfScanInWords);
4944  scan(endOfScanInWords - beginOfScanInWords);
4945  endOfLastScanInWords = endOfScanInWords;
4946  }
4947 
4948  if (buffer.empty())
4949  return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
4950 
4951  // For GC layouts, emit a skip to the end of the allocation so that we
4952  // have precise information about the entire thing. This isn't useful
4953  // or necessary for the ARC-style layout strings.
4954  if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
4955  unsigned lastOffsetInWords =
4956  (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
4957  if (lastOffsetInWords > endOfLastScanInWords) {
4958  skip(lastOffsetInWords - endOfLastScanInWords);
4959  }
4960  }
4961 
4962  // Null terminate the string.
4963  buffer.push_back(0);
4964 
4965  bool isNonFragileABI = CGObjC.isNonFragileABI();
4966 
4967  llvm::GlobalVariable *Entry = CGObjC.CreateMetadataVar(
4968  "OBJC_CLASS_NAME_",
4969  llvm::ConstantDataArray::get(CGM.getLLVMContext(), buffer),
4970  (isNonFragileABI ? "__TEXT,__objc_classname,cstring_literals"
4971  : "__TEXT,__cstring,cstring_literals"),
4972  CharUnits::One(), true);
4973  return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
4974 }
4975 
4976 /// BuildIvarLayout - Builds ivar layout bitmap for the class
4977 /// implementation for the __strong or __weak case.
4978 /// The layout map displays which words in ivar list must be skipped
4979 /// and which must be scanned by GC (see below). String is built of bytes.
4980 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
4981 /// of words to skip and right nibble is count of words to scan. So, each
4982 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is
4983 /// represented by a 0x00 byte which also ends the string.
4984 /// 1. when ForStrongLayout is true, following ivars are scanned:
4985 /// - id, Class
4986 /// - object *
4987 /// - __strong anything
4988 ///
4989 /// 2. When ForStrongLayout is false, following ivars are scanned:
4990 /// - __weak anything
4991 ///
4992 llvm::Constant *
4993 CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
4994  CharUnits beginOffset, CharUnits endOffset,
4995  bool ForStrongLayout, bool HasMRCWeakIvars) {
4996  // If this is MRC, and we're either building a strong layout or there
4997  // are no weak ivars, bail out early.
4998  llvm::Type *PtrTy = CGM.Int8PtrTy;
4999  if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5000  !CGM.getLangOpts().ObjCAutoRefCount &&
5001  (ForStrongLayout || !HasMRCWeakIvars))
5002  return llvm::Constant::getNullValue(PtrTy);
5003 
5004  const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5005  SmallVector<const ObjCIvarDecl*, 32> ivars;
5006 
5007  // GC layout strings include the complete object layout, possibly
5008  // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5009  // up.
5010  //
5011  // ARC layout strings only include the class's ivars. In non-fragile
5012  // runtimes, that means starting at InstanceStart, rounded up to word
5013  // alignment. In fragile runtimes, there's no InstanceStart, so it means
5014  // starting at the offset of the first ivar, rounded up to word alignment.
5015  //
5016  // MRC weak layout strings follow the ARC style.
5017  CharUnits baseOffset;
5018  if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5019  for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5020  IVD; IVD = IVD->getNextIvar())
5021  ivars.push_back(IVD);
5022 
5023  if (isNonFragileABI()) {
5024  baseOffset = beginOffset; // InstanceStart
5025  } else if (!ivars.empty()) {
5026  baseOffset =
5027  CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5028  } else {
5029  baseOffset = CharUnits::Zero();
5030  }
5031 
5032  baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5033  }
5034  else {
5035  CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5036 
5037  baseOffset = CharUnits::Zero();
5038  }
5039 
5040  if (ivars.empty())
5041  return llvm::Constant::getNullValue(PtrTy);
5042 
5043  IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5044 
5045  builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5046  [&](const ObjCIvarDecl *ivar) -> CharUnits {
5047  return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5048  });
5049 
5050  if (!builder.hasBitmapData())
5051  return llvm::Constant::getNullValue(PtrTy);
5052 
5053  llvm::SmallVector<unsigned char, 4> buffer;
5054  llvm::Constant *C = builder.buildBitmap(*this, buffer);
5055 
5056  if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5057  printf("\n%s ivar layout for class '%s': ",
5058  ForStrongLayout ? "strong" : "weak",
5059  OMD->getClassInterface()->getName().str().c_str());
5060  builder.dump(buffer);
5061  }
5062  return C;
5063 }
5064 
5065 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5066  llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5067 
5068  // FIXME: Avoid std::string in "Sel.getAsString()"
5069  if (!Entry)
5070  Entry = CreateMetadataVar(
5071  "OBJC_METH_VAR_NAME_",
5072  llvm::ConstantDataArray::getString(VMContext, Sel.getAsString()),
5073  ((ObjCABI == 2) ? "__TEXT,__objc_methname,cstring_literals"
5074  : "__TEXT,__cstring,cstring_literals"),
5075  CharUnits::One(), true);
5076 
5077  return getConstantGEP(VMContext, Entry, 0, 0);
5078 }
5079 
5080 // FIXME: Merge into a single cstring creation function.
5081 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5082  return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5083 }
5084 
5085 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5086  std::string TypeStr;
5087  CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5088 
5089  llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5090 
5091  if (!Entry)
5092  Entry = CreateMetadataVar(
5093  "OBJC_METH_VAR_TYPE_",
5094  llvm::ConstantDataArray::getString(VMContext, TypeStr),
5095  ((ObjCABI == 2) ? "__TEXT,__objc_methtype,cstring_literals"
5096  : "__TEXT,__cstring,cstring_literals"),
5097  CharUnits::One(), true);
5098 
5099  return getConstantGEP(VMContext, Entry, 0, 0);
5100 }
5101 
5102 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5103  bool Extended) {
5104  std::string TypeStr;
5105  if (CGM.getContext().getObjCEncodingForMethodDecl(D, TypeStr, Extended))
5106  return nullptr;
5107 
5108  llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5109 
5110  if (!Entry)
5111  Entry = CreateMetadataVar(
5112  "OBJC_METH_VAR_TYPE_",
5113  llvm::ConstantDataArray::getString(VMContext, TypeStr),
5114  ((ObjCABI == 2) ? "__TEXT,__objc_methtype,cstring_literals"
5115  : "__TEXT,__cstring,cstring_literals"),
5116  CharUnits::One(), true);
5117 
5118  return getConstantGEP(VMContext, Entry, 0, 0);
5119 }
5120 
5121 // FIXME: Merge into a single cstring creation function.
5122 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5123  llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5124 
5125  if (!Entry)
5126  Entry = CreateMetadataVar(
5127  "OBJC_PROP_NAME_ATTR_",
5128  llvm::ConstantDataArray::getString(VMContext, Ident->getName()),
5129  "__TEXT,__cstring,cstring_literals", CharUnits::One(), true);
5130 
5131  return getConstantGEP(VMContext, Entry, 0, 0);
5132 }
5133 
5134 // FIXME: Merge into a single cstring creation function.
5135 // FIXME: This Decl should be more precise.
5136 llvm::Constant *
5137 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5138  const Decl *Container) {
5139  std::string TypeStr;
5140  CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container, TypeStr);
5141  return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5142 }
5143 
5144 void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
5145  const ObjCContainerDecl *CD,
5146  SmallVectorImpl<char> &Name) {
5147  llvm::raw_svector_ostream OS(Name);
5148  assert (CD && "Missing container decl in GetNameForMethod");
5149  OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
5150  << '[' << CD->getName();
5151  if (const ObjCCategoryImplDecl *CID =
5152  dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
5153  OS << '(' << *CID << ')';
5154  OS << ' ' << D->getSelector().getAsString() << ']';
5155 }
5156 
5157 void CGObjCMac::FinishModule() {
5158  EmitModuleInfo();
5159 
5160  // Emit the dummy bodies for any protocols which were referenced but
5161  // never defined.
5162  for (llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*>::iterator
5163  I = Protocols.begin(), e = Protocols.end(); I != e; ++I) {
5164  if (I->second->hasInitializer())
5165  continue;
5166 
5167  llvm::Constant *Values[5];
5168  Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
5169  Values[1] = GetClassName(I->first->getName());
5170  Values[2] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
5171  Values[3] = Values[4] =
5172  llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
5173  I->second->setInitializer(llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
5174  Values));
5175  CGM.addCompilerUsedGlobal(I->second);
5176  }
5177 
5178  // Add assembler directives to add lazy undefined symbol references
5179  // for classes which are referenced but not defined. This is
5180  // important for correct linker interaction.
5181  //
5182  // FIXME: It would be nice if we had an LLVM construct for this.
5183  if (!LazySymbols.empty() || !DefinedSymbols.empty()) {
5184  SmallString<256> Asm;
5185  Asm += CGM.getModule().getModuleInlineAsm();
5186  if (!Asm.empty() && Asm.back() != '\n')
5187  Asm += '\n';
5188 
5189  llvm::raw_svector_ostream OS(Asm);
5190  for (llvm::SetVector<IdentifierInfo*>::iterator I = DefinedSymbols.begin(),
5191  e = DefinedSymbols.end(); I != e; ++I)
5192  OS << "\t.objc_class_name_" << (*I)->getName() << "=0\n"
5193  << "\t.globl .objc_class_name_" << (*I)->getName() << "\n";
5194  for (llvm::SetVector<IdentifierInfo*>::iterator I = LazySymbols.begin(),
5195  e = LazySymbols.end(); I != e; ++I) {
5196  OS << "\t.lazy_reference .objc_class_name_" << (*I)->getName() << "\n";
5197  }
5198 
5199  for (size_t i = 0, e = DefinedCategoryNames.size(); i < e; ++i) {
5200  OS << "\t.objc_category_name_" << DefinedCategoryNames[i] << "=0\n"
5201  << "\t.globl .objc_category_name_" << DefinedCategoryNames[i] << "\n";
5202  }
5203 
5204  CGM.getModule().setModuleInlineAsm(OS.str());
5205  }
5206 }
5207 
5208 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5209  : CGObjCCommonMac(cgm),
5210  ObjCTypes(cgm) {
5211  ObjCEmptyCacheVar = ObjCEmptyVtableVar = nullptr;
5212  ObjCABI = 2;
5213 }
5214 
5215 /* *** */
5216 
5217 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5218  : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5219 {
5220  CodeGen::CodeGenTypes &Types = CGM.getTypes();
5221  ASTContext &Ctx = CGM.getContext();
5222 
5223  ShortTy = Types.ConvertType(Ctx.ShortTy);
5224  IntTy = Types.ConvertType(Ctx.IntTy);
5225  LongTy = Types.ConvertType(Ctx.LongTy);
5226  LongLongTy = Types.ConvertType(Ctx.LongLongTy);
5227  Int8PtrTy = CGM.Int8PtrTy;
5228  Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5229 
5230  // arm64 targets use "int" ivar offset variables. All others,
5231  // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5232  if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5233  IvarOffsetVarTy = IntTy;
5234  else
5235  IvarOffsetVarTy = LongTy;
5236 
5237  ObjectPtrTy = Types.ConvertType(Ctx.getObjCIdType());
5238  PtrObjectPtrTy = llvm::PointerType::getUnqual(ObjectPtrTy);
5239  SelectorPtrTy = Types.ConvertType(Ctx.getObjCSelType());
5240 
5241  // I'm not sure I like this. The implicit coordination is a bit
5242  // gross. We should solve this in a reasonable fashion because this
5243  // is a pretty common task (match some runtime data structure with
5244  // an LLVM data structure).
5245 
5246  // FIXME: This is leaked.
5247  // FIXME: Merge with rewriter code?
5248 
5249  // struct _objc_super {
5250  // id self;
5251  // Class cls;
5252  // }
5253  RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5254  Ctx.getTranslationUnitDecl(),
5255  SourceLocation(), SourceLocation(),
5256  &Ctx.Idents.get("_objc_super"));
5257  RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5258  nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5259  false, ICIS_NoInit));
5260  RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5261  nullptr, Ctx.getObjCClassType(), nullptr,
5262  nullptr, false, ICIS_NoInit));
5263  RD->completeDefinition();
5264 
5265  SuperCTy = Ctx.getTagDeclType(RD);
5266  SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5267 
5268  SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5269  SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5270 
5271  // struct _prop_t {
5272  // char *name;
5273  // char *attributes;
5274  // }
5275  PropertyTy = llvm::StructType::create("struct._prop_t",
5276  Int8PtrTy, Int8PtrTy, nullptr);
5277 
5278  // struct _prop_list_t {
5279  // uint32_t entsize; // sizeof(struct _prop_t)
5280  // uint32_t count_of_properties;
5281  // struct _prop_t prop_list[count_of_properties];
5282  // }
5283  PropertyListTy =
5284  llvm::StructType::create("struct._prop_list_t", IntTy, IntTy,
5285  llvm::ArrayType::get(PropertyTy, 0), nullptr);
5286  // struct _prop_list_t *
5287  PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5288 
5289  // struct _objc_method {
5290  // SEL _cmd;
5291  // char *method_type;
5292  // char *_imp;
5293  // }
5294  MethodTy = llvm::StructType::create("struct._objc_method",
5295  SelectorPtrTy, Int8PtrTy, Int8PtrTy,
5296  nullptr);
5297 
5298  // struct _objc_cache *
5299  CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5300  CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5301 }
5302 
5303 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5304  : ObjCCommonTypesHelper(cgm) {
5305  // struct _objc_method_description {
5306  // SEL name;
5307  // char *types;
5308  // }
5309  MethodDescriptionTy =
5310  llvm::StructType::create("struct._objc_method_description",
5311  SelectorPtrTy, Int8PtrTy, nullptr);
5312 
5313  // struct _objc_method_description_list {
5314  // int count;
5315  // struct _objc_method_description[1];
5316  // }
5317  MethodDescriptionListTy = llvm::StructType::create(
5318  "struct._objc_method_description_list", IntTy,
5319  llvm::ArrayType::get(MethodDescriptionTy, 0), nullptr);
5320 
5321  // struct _objc_method_description_list *
5322  MethodDescriptionListPtrTy =
5323  llvm::PointerType::getUnqual(MethodDescriptionListTy);
5324 
5325  // Protocol description structures
5326 
5327  // struct _objc_protocol_extension {
5328  // uint32_t size; // sizeof(struct _objc_protocol_extension)
5329  // struct _objc_method_description_list *optional_instance_methods;
5330  // struct _objc_method_description_list *optional_class_methods;
5331  // struct _objc_property_list *instance_properties;
5332  // const char ** extendedMethodTypes;
5333  // struct _objc_property_list *class_properties;
5334  // }
5335  ProtocolExtensionTy =
5336  llvm::StructType::create("struct._objc_protocol_extension",
5337  IntTy, MethodDescriptionListPtrTy,
5338  MethodDescriptionListPtrTy, PropertyListPtrTy,
5339  Int8PtrPtrTy, PropertyListPtrTy, nullptr);
5340 
5341  // struct _objc_protocol_extension *
5342  ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5343 
5344  // Handle recursive construction of Protocol and ProtocolList types
5345 
5346  ProtocolTy =
5347  llvm::StructType::create(VMContext, "struct._objc_protocol");
5348 
5349  ProtocolListTy =
5350  llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5351  ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy),
5352  LongTy,
5353  llvm::ArrayType::get(ProtocolTy, 0),
5354  nullptr);
5355 
5356  // struct _objc_protocol {
5357  // struct _objc_protocol_extension *isa;
5358  // char *protocol_name;
5359  // struct _objc_protocol **_objc_protocol_list;
5360  // struct _objc_method_description_list *instance_methods;
5361  // struct _objc_method_description_list *class_methods;
5362  // }
5363  ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5364  llvm::PointerType::getUnqual(ProtocolListTy),
5365  MethodDescriptionListPtrTy,
5366  MethodDescriptionListPtrTy,
5367  nullptr);
5368 
5369  // struct _objc_protocol_list *
5370  ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5371 
5372  ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5373 
5374  // Class description structures
5375 
5376  // struct _objc_ivar {
5377  // char *ivar_name;
5378  // char *ivar_type;
5379  // int ivar_offset;
5380  // }
5381  IvarTy = llvm::StructType::create("struct._objc_ivar",
5382  Int8PtrTy, Int8PtrTy, IntTy, nullptr);
5383 
5384  // struct _objc_ivar_list *
5385  IvarListTy =
5386  llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5387  IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5388 
5389  // struct _objc_method_list *
5390  MethodListTy =
5391  llvm::StructType::create(VMContext, "struct._objc_method_list");
5392  MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5393 
5394  // struct _objc_class_extension *
5395  ClassExtensionTy =
5396  llvm::StructType::create("struct._objc_class_extension",
5397  IntTy, Int8PtrTy, PropertyListPtrTy, nullptr);
5398  ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5399 
5400  ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5401 
5402  // struct _objc_class {
5403  // Class isa;
5404  // Class super_class;
5405  // char *name;
5406  // long version;
5407  // long info;
5408  // long instance_size;
5409  // struct _objc_ivar_list *ivars;
5410  // struct _objc_method_list *methods;
5411  // struct _objc_cache *cache;
5412  // struct _objc_protocol_list *protocols;
5413  // char *ivar_layout;
5414  // struct _objc_class_ext *ext;
5415  // };
5416  ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5417  llvm::PointerType::getUnqual(ClassTy),
5418  Int8PtrTy,
5419  LongTy,
5420  LongTy,
5421  LongTy,
5422  IvarListPtrTy,
5423  MethodListPtrTy,
5424  CachePtrTy,
5425  ProtocolListPtrTy,
5426  Int8PtrTy,
5427  ClassExtensionPtrTy,
5428  nullptr);
5429 
5430  ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5431 
5432  // struct _objc_category {
5433  // char *category_name;
5434  // char *class_name;
5435  // struct _objc_method_list *instance_method;
5436  // struct _objc_method_list *class_method;
5437  // struct _objc_protocol_list *protocols;
5438  // uint32_t size; // sizeof(struct _objc_category)
5439  // struct _objc_property_list *instance_properties;// category's @property
5440  // struct _objc_property_list *class_properties;
5441  // }
5442  CategoryTy =
5443  llvm::StructType::create("struct._objc_category",
5444  Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5445  MethodListPtrTy, ProtocolListPtrTy,
5446  IntTy, PropertyListPtrTy, PropertyListPtrTy,
5447  nullptr);
5448 
5449  // Global metadata structures
5450 
5451  // struct _objc_symtab {
5452  // long sel_ref_cnt;
5453  // SEL *refs;
5454  // short cls_def_cnt;
5455  // short cat_def_cnt;
5456  // char *defs[cls_def_cnt + cat_def_cnt];
5457  // }
5458  SymtabTy =
5459  llvm::StructType::create("struct._objc_symtab",
5460  LongTy, SelectorPtrTy, ShortTy, ShortTy,
5461  llvm::ArrayType::get(Int8PtrTy, 0), nullptr);
5462  SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
5463 
5464  // struct _objc_module {
5465  // long version;
5466  // long size; // sizeof(struct _objc_module)
5467  // char *name;
5468  // struct _objc_symtab* symtab;
5469  // }
5470  ModuleTy =
5471  llvm::StructType::create("struct._objc_module",
5472  LongTy, LongTy, Int8PtrTy, SymtabPtrTy, nullptr);
5473 
5474 
5475  // FIXME: This is the size of the setjmp buffer and should be target
5476  // specific. 18 is what's used on 32-bit X86.
5477  uint64_t SetJmpBufferSize = 18;
5478 
5479  // Exceptions
5480  llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
5481 
5482  ExceptionDataTy =
5483  llvm::StructType::create("struct._objc_exception_data",
5484  llvm::ArrayType::get(CGM.Int32Ty,SetJmpBufferSize),
5485  StackPtrTy, nullptr);
5486 }
5487 
5488 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
5489  : ObjCCommonTypesHelper(cgm) {
5490  // struct _method_list_t {
5491  // uint32_t entsize; // sizeof(struct _objc_method)
5492  // uint32_t method_count;
5493  // struct _objc_method method_list[method_count];
5494  // }
5495  MethodListnfABITy =
5496  llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
5497  llvm::ArrayType::get(MethodTy, 0), nullptr);
5498  // struct method_list_t *
5499  MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
5500 
5501  // struct _protocol_t {
5502  // id isa; // NULL
5503  // const char * const protocol_name;
5504  // const struct _protocol_list_t * protocol_list; // super protocols
5505  // const struct method_list_t * const instance_methods;
5506  // const struct method_list_t * const class_methods;
5507  // const struct method_list_t *optionalInstanceMethods;
5508  // const struct method_list_t *optionalClassMethods;
5509  // const struct _prop_list_t * properties;
5510  // const uint32_t size; // sizeof(struct _protocol_t)
5511  // const uint32_t flags; // = 0
5512  // const char ** extendedMethodTypes;
5513  // const char *demangledName;
5514  // const struct _prop_list_t * class_properties;
5515  // }
5516 
5517  // Holder for struct _protocol_list_t *
5518  ProtocolListnfABITy =
5519  llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5520 
5521  ProtocolnfABITy =
5522  llvm::StructType::create("struct._protocol_t", ObjectPtrTy, Int8PtrTy,
5523  llvm::PointerType::getUnqual(ProtocolListnfABITy),
5524  MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5525  MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5526  PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy,
5527  Int8PtrTy, PropertyListPtrTy,
5528  nullptr);
5529 
5530  // struct _protocol_t*
5531  ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
5532 
5533  // struct _protocol_list_t {
5534  // long protocol_count; // Note, this is 32/64 bit
5535  // struct _protocol_t *[protocol_count];
5536  // }
5537  ProtocolListnfABITy->setBody(LongTy,
5538  llvm::ArrayType::get(ProtocolnfABIPtrTy, 0),
5539  nullptr);
5540 
5541  // struct _objc_protocol_list*
5542  ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
5543 
5544  // struct _ivar_t {
5545  // unsigned [long] int *offset; // pointer to ivar offset location
5546  // char *name;
5547  // char *type;
5548  // uint32_t alignment;
5549  // uint32_t size;
5550  // }
5551  IvarnfABITy = llvm::StructType::create(
5552  "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
5553  Int8PtrTy, Int8PtrTy, IntTy, IntTy, nullptr);
5554 
5555  // struct _ivar_list_t {
5556  // uint32 entsize; // sizeof(struct _ivar_t)
5557  // uint32 count;
5558  // struct _iver_t list[count];
5559  // }
5560  IvarListnfABITy =
5561  llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
5562  llvm::ArrayType::get(IvarnfABITy, 0), nullptr);
5563 
5564  IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
5565 
5566  // struct _class_ro_t {
5567  // uint32_t const flags;
5568  // uint32_t const instanceStart;
5569  // uint32_t const instanceSize;
5570  // uint32_t const reserved; // only when building for 64bit targets
5571  // const uint8_t * const ivarLayout;
5572  // const char *const name;
5573  // const struct _method_list_t * const baseMethods;
5574  // const struct _objc_protocol_list *const baseProtocols;
5575  // const struct _ivar_list_t *const ivars;
5576  // const uint8_t * const weakIvarLayout;
5577  // const struct _prop_list_t * const properties;
5578  // }
5579 
5580  // FIXME. Add 'reserved' field in 64bit abi mode!
5581  ClassRonfABITy = llvm::StructType::create("struct._class_ro_t",
5582  IntTy, IntTy, IntTy, Int8PtrTy,
5583  Int8PtrTy, MethodListnfABIPtrTy,
5584  ProtocolListnfABIPtrTy,
5585  IvarListnfABIPtrTy,
5586  Int8PtrTy, PropertyListPtrTy,
5587  nullptr);
5588 
5589  // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
5590  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
5591  ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
5592  ->getPointerTo();
5593 
5594  // struct _class_t {
5595  // struct _class_t *isa;
5596  // struct _class_t * const superclass;
5597  // void *cache;
5598  // IMP *vtable;
5599  // struct class_ro_t *ro;
5600  // }
5601 
5602  ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
5603  ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
5604  llvm::PointerType::getUnqual(ClassnfABITy),
5605  CachePtrTy,
5606  llvm::PointerType::getUnqual(ImpnfABITy),
5607  llvm::PointerType::getUnqual(ClassRonfABITy),
5608  nullptr);
5609 
5610  // LLVM for struct _class_t *
5611  ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
5612 
5613  // struct _category_t {
5614  // const char * const name;
5615  // struct _class_t *const cls;
5616  // const struct _method_list_t * const instance_methods;
5617  // const struct _method_list_t * const class_methods;
5618  // const struct _protocol_list_t * const protocols;
5619  // const struct _prop_list_t * const properties;
5620  // const struct _prop_list_t * const class_properties;
5621  // const uint32_t size;
5622  // }
5623  CategorynfABITy = llvm::StructType::create("struct._category_t",
5624  Int8PtrTy, ClassnfABIPtrTy,
5625  MethodListnfABIPtrTy,
5626  MethodListnfABIPtrTy,
5627  ProtocolListnfABIPtrTy,
5628  PropertyListPtrTy,
5629  PropertyListPtrTy,
5630  IntTy,
5631  nullptr);
5632 
5633  // New types for nonfragile abi messaging.
5634  CodeGen::CodeGenTypes &Types = CGM.getTypes();
5635  ASTContext &Ctx = CGM.getContext();
5636 
5637  // MessageRefTy - LLVM for:
5638  // struct _message_ref_t {
5639  // IMP messenger;
5640  // SEL name;
5641  // };
5642 
5643  // First the clang type for struct _message_ref_t
5644  RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5645  Ctx.getTranslationUnitDecl(),
5646  SourceLocation(), SourceLocation(),
5647  &Ctx.Idents.get("_message_ref_t"));
5648  RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5649  nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
5650  ICIS_NoInit));
5651  RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5652  nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
5653  false, ICIS_NoInit));
5654  RD->completeDefinition();
5655 
5656  MessageRefCTy = Ctx.getTagDeclType(RD);
5657  MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
5658  MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
5659 
5660  // MessageRefPtrTy - LLVM for struct _message_ref_t*
5661  MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
5662 
5663  // SuperMessageRefTy - LLVM for:
5664  // struct _super_message_ref_t {
5665  // SUPER_IMP messenger;
5666  // SEL name;
5667  // };
5668  SuperMessageRefTy =
5669  llvm::StructType::create("struct._super_message_ref_t",
5670  ImpnfABITy, SelectorPtrTy, nullptr);
5671 
5672  // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
5673  SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
5674 
5675 
5676  // struct objc_typeinfo {
5677  // const void** vtable; // objc_ehtype_vtable + 2
5678  // const char* name; // c++ typeinfo string
5679  // Class cls;
5680  // };
5681  EHTypeTy =
5682  llvm::StructType::create("struct._objc_typeinfo",
5683  llvm::PointerType::getUnqual(Int8PtrTy),
5684  Int8PtrTy, ClassnfABIPtrTy, nullptr);
5685  EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
5686 }
5687 
5688 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
5689  FinishNonFragileABIModule();
5690 
5691  return nullptr;
5692 }
5693 
5694 void CGObjCNonFragileABIMac::AddModuleClassList(
5695  ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName,
5696  StringRef SectionName) {
5697  unsigned NumClasses = Container.size();
5698 
5699  if (!NumClasses)
5700  return;
5701 
5702  SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
5703  for (unsigned i=0; i<NumClasses; i++)
5704  Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
5705  ObjCTypes.Int8PtrTy);
5706  llvm::Constant *Init =
5707  llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
5708  Symbols.size()),
5709  Symbols);
5710 
5711  llvm::GlobalVariable *GV =
5712  new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
5713  llvm::GlobalValue::PrivateLinkage,
5714  Init,
5715  SymbolName);
5716  GV->setAlignment(CGM.getDataLayout().getABITypeAlignment(Init->getType()));
5717  GV->setSection(SectionName);
5718  CGM.addCompilerUsedGlobal(GV);
5719 }
5720 
5721 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
5722  // nonfragile abi has no module definition.
5723 
5724  // Build list of all implemented class addresses in array
5725  // L_OBJC_LABEL_CLASS_$.
5726 
5727  for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
5728  const ObjCInterfaceDecl *ID = ImplementedClasses[i];
5729  assert(ID);
5730  if (ObjCImplementationDecl *IMP = ID->getImplementation())
5731  // We are implementing a weak imported interface. Give it external linkage
5732  if (ID->isWeakImported() && !IMP->isWeakImported()) {
5733  DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5734  DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5735  }
5736  }
5737 
5738  AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
5739  "__DATA, __objc_classlist, regular, no_dead_strip");
5740 
5741  AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$",
5742  "__DATA, __objc_nlclslist, regular, no_dead_strip");
5743 
5744  // Build list of all implemented category addresses in array
5745  // L_OBJC_LABEL_CATEGORY_$.
5746  AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$",
5747  "__DATA, __objc_catlist, regular, no_dead_strip");
5748  AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$",
5749  "__DATA, __objc_nlcatlist, regular, no_dead_strip");
5750 
5751  EmitImageInfo();
5752 }
5753 
5754 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of
5755 /// VTableDispatchMethods; false otherwise. What this means is that
5756 /// except for the 19 selectors in the list, we generate 32bit-style
5757 /// message dispatch call for all the rest.
5758 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
5759  // At various points we've experimented with using vtable-based
5760  // dispatch for all methods.
5761  switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
5762  case CodeGenOptions::Legacy:
5763  return false;
5764  case CodeGenOptions::NonLegacy:
5765  return true;
5766  case CodeGenOptions::Mixed:
5767  break;
5768  }
5769 
5770  // If so, see whether this selector is in the white-list of things which must
5771  // use the new dispatch convention. We lazily build a dense set for this.
5772  if (VTableDispatchMethods.empty()) {
5773  VTableDispatchMethods.insert(GetNullarySelector("alloc"));
5774  VTableDispatchMethods.insert(GetNullarySelector("class"));
5775  VTableDispatchMethods.insert(GetNullarySelector("self"));
5776  VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
5777  VTableDispatchMethods.insert(GetNullarySelector("length"));
5778  VTableDispatchMethods.insert(GetNullarySelector("count"));
5779 
5780  // These are vtable-based if GC is disabled.
5781  // Optimistically use vtable dispatch for hybrid compiles.
5782  if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
5783  VTableDispatchMethods.insert(GetNullarySelector("retain"));
5784  VTableDispatchMethods.insert(GetNullarySelector("release"));
5785  VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
5786  }
5787 
5788  VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
5789  VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
5790  VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
5791  VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
5792  VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
5793  VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
5794  VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
5795 
5796  // These are vtable-based if GC is enabled.
5797  // Optimistically use vtable dispatch for hybrid compiles.
5798  if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5799  VTableDispatchMethods.insert(GetNullarySelector("hash"));
5800  VTableDispatchMethods.insert(GetUnarySelector("addObject"));
5801 
5802  // "countByEnumeratingWithState:objects:count"
5803  IdentifierInfo *KeyIdents[] = {
5804  &CGM.getContext().Idents.get("countByEnumeratingWithState"),
5805  &CGM.getContext().Idents.get("objects"),
5806  &CGM.getContext().Idents.get("count")
5807  };
5808  VTableDispatchMethods.insert(
5809  CGM.getContext().Selectors.getSelector(3, KeyIdents));
5810  }
5811  }
5812 
5813  return VTableDispatchMethods.count(Sel);
5814 }
5815 
5816 /// BuildClassRoTInitializer - generate meta-data for:
5817 /// struct _class_ro_t {
5818 /// uint32_t const flags;
5819 /// uint32_t const instanceStart;
5820 /// uint32_t const instanceSize;
5821 /// uint32_t const reserved; // only when building for 64bit targets
5822 /// const uint8_t * const ivarLayout;
5823 /// const char *const name;
5824 /// const struct _method_list_t * const baseMethods;
5825 /// const struct _protocol_list_t *const baseProtocols;
5826 /// const struct _ivar_list_t *const ivars;
5827 /// const uint8_t * const weakIvarLayout;
5828 /// const struct _prop_list_t * const properties;
5829 /// }
5830 ///
5831 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
5832  unsigned flags,
5833  unsigned InstanceStart,
5834  unsigned InstanceSize,
5835  const ObjCImplementationDecl *ID) {
5836  std::string ClassName = ID->getObjCRuntimeNameAsString();
5837  llvm::Constant *Values[10]; // 11 for 64bit targets!
5838 
5839  CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
5840  CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
5841 
5842  bool hasMRCWeak = false;
5843  if (CGM.getLangOpts().ObjCAutoRefCount)
5844  flags |= NonFragileABI_Class_CompiledByARC;
5845  else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
5846  flags |= NonFragileABI_Class_HasMRCWeakIvars;
5847 
5848  Values[ 0] = llvm::ConstantInt::get(ObjCTypes.IntTy, flags);
5849  Values[ 1] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceStart);
5850  Values[ 2] = llvm::ConstantInt::get(ObjCTypes.IntTy, InstanceSize);
5851  // FIXME. For 64bit targets add 0 here.
5852  Values[ 3] = (flags & NonFragileABI_Class_Meta)
5853  ? GetIvarLayoutName(nullptr, ObjCTypes)
5854  : BuildStrongIvarLayout(ID, beginInstance, endInstance);
5855  Values[ 4] = GetClassName(ID->getObjCRuntimeNameAsString());
5856  // const struct _method_list_t * const baseMethods;
5857  std::vector<llvm::Constant*> Methods;
5858  std::string MethodListName("\01l_OBJC_$_");
5859  if (flags & NonFragileABI_Class_Meta) {
5860  MethodListName += "CLASS_METHODS_";
5861  MethodListName += ID->getObjCRuntimeNameAsString();
5862  for (const auto *I : ID->class_methods())
5863  // Class methods should always be defined.
5864  Methods.push_back(GetMethodConstant(I));
5865  } else {
5866  MethodListName += "INSTANCE_METHODS_";
5867  MethodListName += ID->getObjCRuntimeNameAsString();
5868  for (const auto *I : ID->instance_methods())
5869  // Instance methods should always be defined.
5870  Methods.push_back(GetMethodConstant(I));
5871 
5872  for (const auto *PID : ID->property_impls()) {
5873  if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
5874  ObjCPropertyDecl *PD = PID->getPropertyDecl();
5875 
5876  if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
5877  if (llvm::Constant *C = GetMethodConstant(MD))
5878  Methods.push_back(C);
5879  if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
5880  if (llvm::Constant *C = GetMethodConstant(MD))
5881  Methods.push_back(C);
5882  }
5883  }
5884  }
5885  Values[ 5] = EmitMethodList(MethodListName,
5886  "__DATA, __objc_const", Methods);
5887 
5888  const ObjCInterfaceDecl *OID = ID->getClassInterface();
5889  assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
5890  Values[ 6] = EmitProtocolList("\01l_OBJC_CLASS_PROTOCOLS_$_"
5891  + OID->getObjCRuntimeNameAsString(),
5892  OID->all_referenced_protocol_begin(),
5893  OID->all_referenced_protocol_end());
5894 
5895  if (flags & NonFragileABI_Class_Meta) {
5896  Values[ 7] = llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
5897  Values[ 8] = GetIvarLayoutName(nullptr, ObjCTypes);
5898  Values[ 9] = EmitPropertyList(
5899  "\01l_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
5900  ID, ID->getClassInterface(), ObjCTypes, true);
5901  } else {
5902  Values[ 7] = EmitIvarList(ID);
5903  Values[ 8] = BuildWeakIvarLayout(ID, beginInstance, endInstance,
5904  hasMRCWeak);
5905  Values[ 9] = EmitPropertyList(
5906  "\01l_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
5907  ID, ID->getClassInterface(), ObjCTypes, false);
5908  }
5909  llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassRonfABITy,
5910  Values);
5911  llvm::GlobalVariable *CLASS_RO_GV =
5912  new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassRonfABITy, false,
5913  llvm::GlobalValue::PrivateLinkage,
5914  Init,
5915  (flags & NonFragileABI_Class_Meta) ?
5916  std::string("\01l_OBJC_METACLASS_RO_$_")+ClassName :
5917  std::string("\01l_OBJC_CLASS_RO_$_")+ClassName);
5918  CLASS_RO_GV->setAlignment(
5919  CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassRonfABITy));
5920  CLASS_RO_GV->setSection("__DATA, __objc_const");
5921  return CLASS_RO_GV;
5922 
5923 }
5924 
5925 /// BuildClassMetaData - This routine defines that to-level meta-data
5926 /// for the given ClassName for:
5927 /// struct _class_t {
5928 /// struct _class_t *isa;
5929 /// struct _class_t * const superclass;
5930 /// void *cache;
5931 /// IMP *vtable;
5932 /// struct class_ro_t *ro;
5933 /// }
5934 ///
5935 llvm::GlobalVariable *CGObjCNonFragileABIMac::BuildClassMetaData(
5936  const std::string &ClassName, llvm::Constant *IsAGV, llvm::Constant *SuperClassGV,
5937  llvm::Constant *ClassRoGV, bool HiddenVisibility, bool Weak) {
5938  llvm::Constant *Values[] = {
5939  IsAGV,
5940  SuperClassGV,
5941  ObjCEmptyCacheVar, // &ObjCEmptyCacheVar
5942  ObjCEmptyVtableVar, // &ObjCEmptyVtableVar
5943  ClassRoGV // &CLASS_RO_GV
5944  };
5945  if (!Values[1])
5946  Values[1] = llvm::Constant::getNullValue(ObjCTypes.ClassnfABIPtrTy);
5947  if (!Values[3])
5948  Values[3] = llvm::Constant::getNullValue(
5949  llvm::PointerType::getUnqual(ObjCTypes.ImpnfABITy));
5950  llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassnfABITy,
5951  Values);
5952  llvm::GlobalVariable *GV = GetClassGlobal(ClassName, Weak);
5953  GV->setInitializer(Init);
5954  GV->setSection("__DATA, __objc_data");
5955  GV->setAlignment(
5956  CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy));
5957  if (HiddenVisibility)
5958  GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
5959  return GV;
5960 }
5961 
5962 bool
5963 CGObjCNonFragileABIMac::ImplementationIsNonLazy(const ObjCImplDecl *OD) const {
5964  return OD->getClassMethod(GetNullarySelector("load")) != nullptr;
5965 }
5966 
5967 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
5968  uint32_t &InstanceStart,
5969  uint32_t &InstanceSize) {
5970  const ASTRecordLayout &RL =
5971  CGM.getContext().getASTObjCImplementationLayout(OID);
5972 
5973  // InstanceSize is really instance end.
5974  InstanceSize = RL.getDataSize().getQuantity();
5975 
5976  // If there are no fields, the start is the same as the end.
5977  if (!RL.getFieldCount())
5978  InstanceStart = InstanceSize;
5979  else
5980  InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
5981 }
5982 
5983 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
5984  std::string ClassName = ID->getObjCRuntimeNameAsString();
5985  if (!ObjCEmptyCacheVar) {
5986  ObjCEmptyCacheVar = new llvm::GlobalVariable(
5987  CGM.getModule(),
5988  ObjCTypes.CacheTy,
5989  false,
5990  llvm::GlobalValue::ExternalLinkage,
5991  nullptr,
5992  "_objc_empty_cache");
5993 
5994  // Make this entry NULL for any iOS device target, any iOS simulator target,
5995  // OS X with deployment target 10.9 or later.
5996  const llvm::Triple &Triple = CGM.getTarget().getTriple();
5997  if (Triple.isiOS() || Triple.isWatchOS() ||
5998  (Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 9)))
5999  // This entry will be null.
6000  ObjCEmptyVtableVar = nullptr;
6001  else
6002  ObjCEmptyVtableVar = new llvm::GlobalVariable(
6003  CGM.getModule(),
6004  ObjCTypes.ImpnfABITy,
6005  false,
6006  llvm::GlobalValue::ExternalLinkage,
6007  nullptr,
6008  "_objc_empty_vtable");
6009  }
6010  assert(ID->getClassInterface() &&
6011  "CGObjCNonFragileABIMac::GenerateClass - class is 0");
6012  // FIXME: Is this correct (that meta class size is never computed)?
6013  uint32_t InstanceStart =
6014  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
6015  uint32_t InstanceSize = InstanceStart;
6016  uint32_t flags = NonFragileABI_Class_Meta;
6017  llvm::SmallString<64> ObjCMetaClassName(getMetaclassSymbolPrefix());
6018  llvm::SmallString<64> ObjCClassName(getClassSymbolPrefix());
6019  llvm::SmallString<64> TClassName;
6020 
6021  llvm::GlobalVariable *SuperClassGV, *IsAGV;
6022 
6023  // Build the flags for the metaclass.
6024  bool classIsHidden =
6026  if (classIsHidden)
6027  flags |= NonFragileABI_Class_Hidden;
6028 
6029  // FIXME: why is this flag set on the metaclass?
6030  // ObjC metaclasses have no fields and don't really get constructed.
6031  if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6033  if (!ID->hasNonZeroConstructors())
6035  }
6036 
6037  if (!ID->getClassInterface()->getSuperClass()) {
6038  // class is root
6039  flags |= NonFragileABI_Class_Root;
6040  TClassName = ObjCClassName;
6041  TClassName += ClassName;
6042  SuperClassGV = GetClassGlobal(TClassName.str(),
6043  ID->getClassInterface()->isWeakImported());
6044  TClassName = ObjCMetaClassName;
6045  TClassName += ClassName;
6046  IsAGV = GetClassGlobal(TClassName.str(),
6047  ID->getClassInterface()->isWeakImported());
6048  } else {
6049  // Has a root. Current class is not a root.
6050  const ObjCInterfaceDecl *Root = ID->getClassInterface();
6051  while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
6052  Root = Super;
6053  TClassName = ObjCMetaClassName ;
6054  TClassName += Root->getObjCRuntimeNameAsString();
6055  IsAGV = GetClassGlobal(TClassName.str(),
6056  Root->isWeakImported());
6057 
6058  // work on super class metadata symbol.
6059  TClassName = ObjCMetaClassName;
6061  SuperClassGV = GetClassGlobal(
6062  TClassName.str(),
6063  ID->getClassInterface()->getSuperClass()->isWeakImported());
6064  }
6065  llvm::GlobalVariable *CLASS_RO_GV = BuildClassRoTInitializer(flags,
6066  InstanceStart,
6067  InstanceSize,ID);
6068  TClassName = ObjCMetaClassName;
6069  TClassName += ClassName;
6070  llvm::GlobalVariable *MetaTClass = BuildClassMetaData(
6071  TClassName.str(), IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden,
6072  ID->getCla