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