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