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