xref: /freebsd/contrib/llvm-project/clang/lib/CodeGen/CGObjCMac.cpp (revision c1d255d3ffdbe447de3ab875bf4e7d7accc5bfc5)
1 //===------- CGObjCMac.cpp - Interface to Apple Objective-C Runtime -------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This provides Objective-C code generation targeting the Apple runtime.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "CGBlocks.h"
14 #include "CGCleanup.h"
15 #include "CGObjCRuntime.h"
16 #include "CGRecordLayout.h"
17 #include "CodeGenFunction.h"
18 #include "CodeGenModule.h"
19 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/Attr.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/Mangle.h"
24 #include "clang/AST/RecordLayout.h"
25 #include "clang/AST/StmtObjC.h"
26 #include "clang/Basic/CodeGenOptions.h"
27 #include "clang/Basic/LangOptions.h"
28 #include "clang/CodeGen/CGFunctionInfo.h"
29 #include "clang/CodeGen/ConstantInitBuilder.h"
30 #include "llvm/ADT/CachedHashString.h"
31 #include "llvm/ADT/DenseSet.h"
32 #include "llvm/ADT/SetVector.h"
33 #include "llvm/ADT/SmallPtrSet.h"
34 #include "llvm/ADT/SmallString.h"
35 #include "llvm/ADT/UniqueVector.h"
36 #include "llvm/IR/DataLayout.h"
37 #include "llvm/IR/InlineAsm.h"
38 #include "llvm/IR/IntrinsicInst.h"
39 #include "llvm/IR/LLVMContext.h"
40 #include "llvm/IR/Module.h"
41 #include "llvm/Support/ScopedPrinter.h"
42 #include "llvm/Support/raw_ostream.h"
43 #include <cstdio>
44 
45 using namespace clang;
46 using namespace CodeGen;
47 
48 namespace {
49 
50 // FIXME: We should find a nicer way to make the labels for metadata, string
51 // concatenation is lame.
52 
53 class ObjCCommonTypesHelper {
54 protected:
55   llvm::LLVMContext &VMContext;
56 
57 private:
58   // The types of these functions don't really matter because we
59   // should always bitcast before calling them.
60 
61   /// id objc_msgSend (id, SEL, ...)
62   ///
63   /// The default messenger, used for sends whose ABI is unchanged from
64   /// the all-integer/pointer case.
65   llvm::FunctionCallee getMessageSendFn() const {
66     // Add the non-lazy-bind attribute, since objc_msgSend is likely to
67     // be called a lot.
68     llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
69     return CGM.CreateRuntimeFunction(
70         llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend",
71         llvm::AttributeList::get(CGM.getLLVMContext(),
72                                  llvm::AttributeList::FunctionIndex,
73                                  llvm::Attribute::NonLazyBind));
74   }
75 
76   /// void objc_msgSend_stret (id, SEL, ...)
77   ///
78   /// The messenger used when the return value is an aggregate returned
79   /// by indirect reference in the first argument, and therefore the
80   /// self and selector parameters are shifted over by one.
81   llvm::FunctionCallee getMessageSendStretFn() const {
82     llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
83     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
84                                                              params, true),
85                                      "objc_msgSend_stret");
86   }
87 
88   /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
89   ///
90   /// The messenger used when the return value is returned on the x87
91   /// floating-point stack; without a special entrypoint, the nil case
92   /// would be unbalanced.
93   llvm::FunctionCallee getMessageSendFpretFn() const {
94     llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
95     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
96                                                              params, true),
97                                      "objc_msgSend_fpret");
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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee getMessageSendSuperFpretFn() const {
162     // There is no objc_msgSendSuper_fpret? How can that work?
163     return getMessageSendSuperFn();
164   }
165 
166   llvm::FunctionCallee getMessageSendSuperFpretFn2() const {
167     // There is no objc_msgSendSuper_fpret? How can that work?
168     return getMessageSendSuperFn2();
169   }
170 
171 protected:
172   CodeGen::CodeGenModule &CGM;
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::FunctionCallee 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,
243         Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(), Ctx.BoolTy};
244     llvm::FunctionType *FTy =
245         Types.GetFunctionType(
246           Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
247     return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
248   }
249 
250   llvm::FunctionCallee 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,
259         Ctx.getPointerDiffType()->getCanonicalTypeUnqualified(),
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::FunctionCallee 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 
281     SmallVector<CanQualType,4> Params;
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::FunctionCallee getCopyStructFn() {
305     CodeGen::CodeGenTypes &Types = CGM.getTypes();
306     ASTContext &Ctx = CGM.getContext();
307     // void objc_copyStruct (void *, const void *, size_t, bool, bool)
308     SmallVector<CanQualType,5> Params;
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::FunctionCallee getCppAtomicObjectFunction() {
325     CodeGen::CodeGenTypes &Types = CGM.getTypes();
326     ASTContext &Ctx = CGM.getContext();
327     /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
328     SmallVector<CanQualType,3> Params;
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::FunctionCallee getEnumerationMutationFn() {
339     CodeGen::CodeGenTypes &Types = CGM.getTypes();
340     ASTContext &Ctx = CGM.getContext();
341     // void objc_enumerationMutation (id)
342     SmallVector<CanQualType,1> Params;
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::FunctionCallee getLookUpClassFn() {
351     CodeGen::CodeGenTypes &Types = CGM.getTypes();
352     ASTContext &Ctx = CGM.getContext();
353     // Class objc_lookUpClass (const char *)
354     SmallVector<CanQualType,1> Params;
355     Params.push_back(
356       Ctx.getCanonicalType(Ctx.getPointerType(Ctx.CharTy.withConst())));
357     llvm::FunctionType *FTy =
358         Types.GetFunctionType(Types.arrangeBuiltinFunctionDeclaration(
359                                 Ctx.getCanonicalType(Ctx.getObjCClassType()),
360                                 Params));
361     return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass");
362   }
363 
364   /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
365   llvm::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee getSendFn(bool IsSuper) const {
462     return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
463   }
464 
465   llvm::FunctionCallee getSendFn2(bool IsSuper) const {
466     return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
467   }
468 
469   llvm::FunctionCallee getSendStretFn(bool IsSuper) const {
470     return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
471   }
472 
473   llvm::FunctionCallee getSendStretFn2(bool IsSuper) const {
474     return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
475   }
476 
477   llvm::FunctionCallee getSendFpretFn(bool IsSuper) const {
478     return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
479   }
480 
481   llvm::FunctionCallee getSendFpretFn2(bool IsSuper) const {
482     return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
483   }
484 
485   llvm::FunctionCallee getSendFp2retFn(bool IsSuper) const {
486     return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
487   }
488 
489   llvm::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee 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::FunctionCallee getObjCEndCatchFn() {
716     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
717                                      "objc_end_catch");
718   }
719 
720   llvm::FunctionCallee getObjCBeginCatchFn() {
721     llvm::Type *params[] = { Int8PtrTy };
722     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
723                                                              params, false),
724                                      "objc_begin_catch");
725   }
726 
727   /// Class objc_loadClassref (void *)
728   ///
729   /// Loads from a classref. For Objective-C stub classes, this invokes the
730   /// initialization callback stored inside the stub. For all other classes
731   /// this simply dereferences the pointer.
732   llvm::FunctionCallee getLoadClassrefFn() const {
733     // Add the non-lazy-bind attribute, since objc_loadClassref is likely to
734     // be called a lot.
735     //
736     // Also it is safe to make it readnone, since we never load or store the
737     // classref except by calling this function.
738     llvm::Type *params[] = { Int8PtrPtrTy };
739     llvm::FunctionCallee F = CGM.CreateRuntimeFunction(
740         llvm::FunctionType::get(ClassnfABIPtrTy, params, false),
741         "objc_loadClassref",
742         llvm::AttributeList::get(CGM.getLLVMContext(),
743                                  llvm::AttributeList::FunctionIndex,
744                                  {llvm::Attribute::NonLazyBind,
745                                   llvm::Attribute::ReadNone,
746                                   llvm::Attribute::NoUnwind}));
747     if (!CGM.getTriple().isOSBinFormatCOFF())
748       cast<llvm::Function>(F.getCallee())->setLinkage(
749         llvm::Function::ExternalWeakLinkage);
750 
751     return F;
752   }
753 
754   llvm::StructType *EHTypeTy;
755   llvm::Type *EHTypePtrTy;
756 
757   ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
758 };
759 
760 enum class ObjCLabelType {
761   ClassName,
762   MethodVarName,
763   MethodVarType,
764   PropertyName,
765 };
766 
767 class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
768 public:
769   class SKIP_SCAN {
770   public:
771     unsigned skip;
772     unsigned scan;
773     SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
774       : skip(_skip), scan(_scan) {}
775   };
776 
777   /// opcode for captured block variables layout 'instructions'.
778   /// In the following descriptions, 'I' is the value of the immediate field.
779   /// (field following the opcode).
780   ///
781   enum BLOCK_LAYOUT_OPCODE {
782     /// An operator which affects how the following layout should be
783     /// interpreted.
784     ///   I == 0: Halt interpretation and treat everything else as
785     ///           a non-pointer.  Note that this instruction is equal
786     ///           to '\0'.
787     ///   I != 0: Currently unused.
788     BLOCK_LAYOUT_OPERATOR            = 0,
789 
790     /// The next I+1 bytes do not contain a value of object pointer type.
791     /// Note that this can leave the stream unaligned, meaning that
792     /// subsequent word-size instructions do not begin at a multiple of
793     /// the pointer size.
794     BLOCK_LAYOUT_NON_OBJECT_BYTES    = 1,
795 
796     /// The next I+1 words do not contain a value of object pointer type.
797     /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
798     /// when the required skip quantity is a multiple of the pointer size.
799     BLOCK_LAYOUT_NON_OBJECT_WORDS    = 2,
800 
801     /// The next I+1 words are __strong pointers to Objective-C
802     /// objects or blocks.
803     BLOCK_LAYOUT_STRONG              = 3,
804 
805     /// The next I+1 words are pointers to __block variables.
806     BLOCK_LAYOUT_BYREF               = 4,
807 
808     /// The next I+1 words are __weak pointers to Objective-C
809     /// objects or blocks.
810     BLOCK_LAYOUT_WEAK                = 5,
811 
812     /// The next I+1 words are __unsafe_unretained pointers to
813     /// Objective-C objects or blocks.
814     BLOCK_LAYOUT_UNRETAINED          = 6
815 
816     /// The next I+1 words are block or object pointers with some
817     /// as-yet-unspecified ownership semantics.  If we add more
818     /// flavors of ownership semantics, values will be taken from
819     /// this range.
820     ///
821     /// This is included so that older tools can at least continue
822     /// processing the layout past such things.
823     //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
824 
825     /// All other opcodes are reserved.  Halt interpretation and
826     /// treat everything else as opaque.
827   };
828 
829   class RUN_SKIP {
830   public:
831     enum BLOCK_LAYOUT_OPCODE opcode;
832     CharUnits block_var_bytepos;
833     CharUnits block_var_size;
834     RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
835              CharUnits BytePos = CharUnits::Zero(),
836              CharUnits Size = CharUnits::Zero())
837     : opcode(Opcode), block_var_bytepos(BytePos),  block_var_size(Size) {}
838 
839     // Allow sorting based on byte pos.
840     bool operator<(const RUN_SKIP &b) const {
841       return block_var_bytepos < b.block_var_bytepos;
842     }
843   };
844 
845 protected:
846   llvm::LLVMContext &VMContext;
847   // FIXME! May not be needing this after all.
848   unsigned ObjCABI;
849 
850   // arc/mrr layout of captured block literal variables.
851   SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
852 
853   /// LazySymbols - Symbols to generate a lazy reference for. See
854   /// DefinedSymbols and FinishModule().
855   llvm::SetVector<IdentifierInfo*> LazySymbols;
856 
857   /// DefinedSymbols - External symbols which are defined by this
858   /// module. The symbols in this list and LazySymbols are used to add
859   /// special linker symbols which ensure that Objective-C modules are
860   /// linked properly.
861   llvm::SetVector<IdentifierInfo*> DefinedSymbols;
862 
863   /// ClassNames - uniqued class names.
864   llvm::StringMap<llvm::GlobalVariable*> ClassNames;
865 
866   /// MethodVarNames - uniqued method variable names.
867   llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
868 
869   /// DefinedCategoryNames - list of category names in form Class_Category.
870   llvm::SmallSetVector<llvm::CachedHashString, 16> DefinedCategoryNames;
871 
872   /// MethodVarTypes - uniqued method type signatures. We have to use
873   /// a StringMap here because have no other unique reference.
874   llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
875 
876   /// MethodDefinitions - map of methods which have been defined in
877   /// this translation unit.
878   llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
879 
880   /// DirectMethodDefinitions - map of direct methods which have been defined in
881   /// this translation unit.
882   llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> DirectMethodDefinitions;
883 
884   /// PropertyNames - uniqued method variable names.
885   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
886 
887   /// ClassReferences - uniqued class references.
888   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
889 
890   /// SelectorReferences - uniqued selector references.
891   llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
892 
893   /// Protocols - Protocols for which an objc_protocol structure has
894   /// been emitted. Forward declarations are handled by creating an
895   /// empty structure whose initializer is filled in when/if defined.
896   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
897 
898   /// DefinedProtocols - Protocols which have actually been
899   /// defined. We should not need this, see FIXME in GenerateProtocol.
900   llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
901 
902   /// DefinedClasses - List of defined classes.
903   SmallVector<llvm::GlobalValue*, 16> DefinedClasses;
904 
905   /// ImplementedClasses - List of @implemented classes.
906   SmallVector<const ObjCInterfaceDecl*, 16> ImplementedClasses;
907 
908   /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
909   SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
910 
911   /// DefinedCategories - List of defined categories.
912   SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
913 
914   /// DefinedStubCategories - List of defined categories on class stubs.
915   SmallVector<llvm::GlobalValue*, 16> DefinedStubCategories;
916 
917   /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
918   SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
919 
920   /// Cached reference to the class for constant strings. This value has type
921   /// int * but is actually an Obj-C class pointer.
922   llvm::WeakTrackingVH ConstantStringClassRef;
923 
924   /// The LLVM type corresponding to NSConstantString.
925   llvm::StructType *NSConstantStringType = nullptr;
926 
927   llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap;
928 
929   /// GetMethodVarName - Return a unique constant for the given
930   /// selector's name. The return value has type char *.
931   llvm::Constant *GetMethodVarName(Selector Sel);
932   llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
933 
934   /// GetMethodVarType - Return a unique constant for the given
935   /// method's type encoding string. The return value has type char *.
936 
937   // FIXME: This is a horrible name.
938   llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
939                                    bool Extended = false);
940   llvm::Constant *GetMethodVarType(const FieldDecl *D);
941 
942   /// GetPropertyName - Return a unique constant for the given
943   /// name. The return value has type char *.
944   llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
945 
946   // FIXME: This can be dropped once string functions are unified.
947   llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
948                                         const Decl *Container);
949 
950   /// GetClassName - Return a unique constant for the given selector's
951   /// runtime name (which may change via use of objc_runtime_name attribute on
952   /// class or protocol definition. The return value has type char *.
953   llvm::Constant *GetClassName(StringRef RuntimeName);
954 
955   llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
956 
957   /// BuildIvarLayout - Builds ivar layout bitmap for the class
958   /// implementation for the __strong or __weak case.
959   ///
960   /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there
961   ///   are any weak ivars defined directly in the class.  Meaningless unless
962   ///   building a weak layout.  Does not guarantee that the layout will
963   ///   actually have any entries, because the ivar might be under-aligned.
964   llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
965                                   CharUnits beginOffset,
966                                   CharUnits endOffset,
967                                   bool forStrongLayout,
968                                   bool hasMRCWeakIvars);
969 
970   llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,
971                                         CharUnits beginOffset,
972                                         CharUnits endOffset) {
973     return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
974   }
975 
976   llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
977                                       CharUnits beginOffset,
978                                       CharUnits endOffset,
979                                       bool hasMRCWeakIvars) {
980     return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
981   }
982 
983   Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
984 
985   void UpdateRunSkipBlockVars(bool IsByref,
986                               Qualifiers::ObjCLifetime LifeTime,
987                               CharUnits FieldOffset,
988                               CharUnits FieldSize);
989 
990   void BuildRCBlockVarRecordLayout(const RecordType *RT,
991                                    CharUnits BytePos, bool &HasUnion,
992                                    bool ByrefLayout=false);
993 
994   void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
995                            const RecordDecl *RD,
996                            ArrayRef<const FieldDecl*> RecFields,
997                            CharUnits BytePos, bool &HasUnion,
998                            bool ByrefLayout);
999 
1000   uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
1001 
1002   llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
1003 
1004   /// GetIvarLayoutName - Returns a unique constant for the given
1005   /// ivar layout bitmap.
1006   llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
1007                                     const ObjCCommonTypesHelper &ObjCTypes);
1008 
1009   /// EmitPropertyList - Emit the given property list. The return
1010   /// value has type PropertyListPtrTy.
1011   llvm::Constant *EmitPropertyList(Twine Name,
1012                                    const Decl *Container,
1013                                    const ObjCContainerDecl *OCD,
1014                                    const ObjCCommonTypesHelper &ObjCTypes,
1015                                    bool IsClassProperty);
1016 
1017   /// EmitProtocolMethodTypes - Generate the array of extended method type
1018   /// strings. The return value has type Int8PtrPtrTy.
1019   llvm::Constant *EmitProtocolMethodTypes(Twine Name,
1020                                           ArrayRef<llvm::Constant*> MethodTypes,
1021                                        const ObjCCommonTypesHelper &ObjCTypes);
1022 
1023   /// GetProtocolRef - Return a reference to the internal protocol
1024   /// description, creating an empty one if it has not been
1025   /// defined. The return value has type ProtocolPtrTy.
1026   llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
1027 
1028   /// Return a reference to the given Class using runtime calls rather than
1029   /// by a symbol reference.
1030   llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,
1031                                       const ObjCInterfaceDecl *ID,
1032                                       ObjCCommonTypesHelper &ObjCTypes);
1033 
1034   std::string GetSectionName(StringRef Section, StringRef MachOAttributes);
1035 
1036 public:
1037   /// CreateMetadataVar - Create a global variable with internal
1038   /// linkage for use by the Objective-C runtime.
1039   ///
1040   /// This is a convenience wrapper which not only creates the
1041   /// variable, but also sets the section and alignment and adds the
1042   /// global to the "llvm.used" list.
1043   ///
1044   /// \param Name - The variable name.
1045   /// \param Init - The variable initializer; this is also used to
1046   ///   define the type of the variable.
1047   /// \param Section - The section the variable should go into, or empty.
1048   /// \param Align - The alignment for the variable, or 0.
1049   /// \param AddToUsed - Whether the variable should be added to
1050   ///   "llvm.used".
1051   llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1052                                           ConstantStructBuilder &Init,
1053                                           StringRef Section, CharUnits Align,
1054                                           bool AddToUsed);
1055   llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1056                                           llvm::Constant *Init,
1057                                           StringRef Section, CharUnits Align,
1058                                           bool AddToUsed);
1059 
1060   llvm::GlobalVariable *CreateCStringLiteral(StringRef Name,
1061                                              ObjCLabelType LabelType,
1062                                              bool ForceNonFragileABI = false,
1063                                              bool NullTerminate = true);
1064 
1065 protected:
1066   CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1067                                   ReturnValueSlot Return,
1068                                   QualType ResultType,
1069                                   Selector Sel,
1070                                   llvm::Value *Arg0,
1071                                   QualType Arg0Ty,
1072                                   bool IsSuper,
1073                                   const CallArgList &CallArgs,
1074                                   const ObjCMethodDecl *OMD,
1075                                   const ObjCInterfaceDecl *ClassReceiver,
1076                                   const ObjCCommonTypesHelper &ObjCTypes);
1077 
1078   /// EmitImageInfo - Emit the image info marker used to encode some module
1079   /// level information.
1080   void EmitImageInfo();
1081 
1082 public:
1083   CGObjCCommonMac(CodeGen::CodeGenModule &cgm)
1084       : CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) {}
1085 
1086   bool isNonFragileABI() const {
1087     return ObjCABI == 2;
1088   }
1089 
1090   ConstantAddress GenerateConstantString(const StringLiteral *SL) override;
1091   ConstantAddress GenerateConstantNSString(const StringLiteral *SL);
1092 
1093   llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1094                                  const ObjCContainerDecl *CD=nullptr) override;
1095 
1096   llvm::Function *GenerateDirectMethod(const ObjCMethodDecl *OMD,
1097                                        const ObjCContainerDecl *CD);
1098 
1099   void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn,
1100                                     const ObjCMethodDecl *OMD,
1101                                     const ObjCContainerDecl *CD) override;
1102 
1103   void GenerateProtocol(const ObjCProtocolDecl *PD) override;
1104 
1105   /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1106   /// object for the given declaration, emitting it if needed. These
1107   /// forward references will be filled in with empty bodies if no
1108   /// definition is seen. The return value has type ProtocolPtrTy.
1109   virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1110 
1111   virtual llvm::Constant *getNSConstantStringClassRef() = 0;
1112 
1113   llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1114                                      const CGBlockInfo &blockInfo) override;
1115   llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1116                                      const CGBlockInfo &blockInfo) override;
1117   std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM,
1118                                   const CGBlockInfo &blockInfo) override;
1119 
1120   llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1121                                    QualType T) override;
1122 
1123 private:
1124   void fillRunSkipBlockVars(CodeGenModule &CGM, const CGBlockInfo &blockInfo);
1125 };
1126 
1127 namespace {
1128 
1129 enum class MethodListType {
1130   CategoryInstanceMethods,
1131   CategoryClassMethods,
1132   InstanceMethods,
1133   ClassMethods,
1134   ProtocolInstanceMethods,
1135   ProtocolClassMethods,
1136   OptionalProtocolInstanceMethods,
1137   OptionalProtocolClassMethods,
1138 };
1139 
1140 /// A convenience class for splitting the methods of a protocol into
1141 /// the four interesting groups.
1142 class ProtocolMethodLists {
1143 public:
1144   enum Kind {
1145     RequiredInstanceMethods,
1146     RequiredClassMethods,
1147     OptionalInstanceMethods,
1148     OptionalClassMethods
1149   };
1150   enum {
1151     NumProtocolMethodLists = 4
1152   };
1153 
1154   static MethodListType getMethodListKind(Kind kind) {
1155     switch (kind) {
1156     case RequiredInstanceMethods:
1157       return MethodListType::ProtocolInstanceMethods;
1158     case RequiredClassMethods:
1159       return MethodListType::ProtocolClassMethods;
1160     case OptionalInstanceMethods:
1161       return MethodListType::OptionalProtocolInstanceMethods;
1162     case OptionalClassMethods:
1163       return MethodListType::OptionalProtocolClassMethods;
1164     }
1165     llvm_unreachable("bad kind");
1166   }
1167 
1168   SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists];
1169 
1170   static ProtocolMethodLists get(const ObjCProtocolDecl *PD) {
1171     ProtocolMethodLists result;
1172 
1173     for (auto MD : PD->methods()) {
1174       size_t index = (2 * size_t(MD->isOptional()))
1175                    + (size_t(MD->isClassMethod()));
1176       result.Methods[index].push_back(MD);
1177     }
1178 
1179     return result;
1180   }
1181 
1182   template <class Self>
1183   SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const {
1184     // In both ABIs, the method types list is parallel with the
1185     // concatenation of the methods arrays in the following order:
1186     //   instance methods
1187     //   class methods
1188     //   optional instance methods
1189     //   optional class methods
1190     SmallVector<llvm::Constant*, 8> result;
1191 
1192     // Methods is already in the correct order for both ABIs.
1193     for (auto &list : Methods) {
1194       for (auto MD : list) {
1195         result.push_back(self->GetMethodVarType(MD, true));
1196       }
1197     }
1198 
1199     return result;
1200   }
1201 
1202   template <class Self>
1203   llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD,
1204                                  Kind kind) const {
1205     return self->emitMethodList(PD->getObjCRuntimeNameAsString(),
1206                                 getMethodListKind(kind), Methods[kind]);
1207   }
1208 };
1209 
1210 } // end anonymous namespace
1211 
1212 class CGObjCMac : public CGObjCCommonMac {
1213 private:
1214   friend ProtocolMethodLists;
1215 
1216   ObjCTypesHelper ObjCTypes;
1217 
1218   /// EmitModuleInfo - Another marker encoding module level
1219   /// information.
1220   void EmitModuleInfo();
1221 
1222   /// EmitModuleSymols - Emit module symbols, the list of defined
1223   /// classes and categories. The result has type SymtabPtrTy.
1224   llvm::Constant *EmitModuleSymbols();
1225 
1226   /// FinishModule - Write out global data structures at the end of
1227   /// processing a translation unit.
1228   void FinishModule();
1229 
1230   /// EmitClassExtension - Generate the class extension structure used
1231   /// to store the weak ivar layout and properties. The return value
1232   /// has type ClassExtensionPtrTy.
1233   llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID,
1234                                      CharUnits instanceSize,
1235                                      bool hasMRCWeakIvars,
1236                                      bool isMetaclass);
1237 
1238   /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1239   /// for the given class.
1240   llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1241                             const ObjCInterfaceDecl *ID);
1242 
1243   llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1244                                   IdentifierInfo *II);
1245 
1246   llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1247 
1248   /// EmitSuperClassRef - Emits reference to class's main metadata class.
1249   llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1250 
1251   /// EmitIvarList - Emit the ivar list for the given
1252   /// implementation. If ForClass is true the list of class ivars
1253   /// (i.e. metaclass ivars) is emitted, otherwise the list of
1254   /// interface ivars will be emitted. The return value has type
1255   /// IvarListPtrTy.
1256   llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1257                                bool ForClass);
1258 
1259   /// EmitMetaClass - Emit a forward reference to the class structure
1260   /// for the metaclass of the given interface. The return value has
1261   /// type ClassPtrTy.
1262   llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1263 
1264   /// EmitMetaClass - Emit a class structure for the metaclass of the
1265   /// given implementation. The return value has type ClassPtrTy.
1266   llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1267                                 llvm::Constant *Protocols,
1268                                 ArrayRef<const ObjCMethodDecl *> Methods);
1269 
1270   void emitMethodConstant(ConstantArrayBuilder &builder,
1271                           const ObjCMethodDecl *MD);
1272 
1273   void emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
1274                                      const ObjCMethodDecl *MD);
1275 
1276   /// EmitMethodList - Emit the method list for the given
1277   /// implementation. The return value has type MethodListPtrTy.
1278   llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1279                                  ArrayRef<const ObjCMethodDecl *> Methods);
1280 
1281   /// GetOrEmitProtocol - Get the protocol object for the given
1282   /// declaration, emitting it if necessary. The return value has type
1283   /// ProtocolPtrTy.
1284   llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1285 
1286   /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1287   /// object for the given declaration, emitting it if needed. These
1288   /// forward references will be filled in with empty bodies if no
1289   /// definition is seen. The return value has type ProtocolPtrTy.
1290   llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1291 
1292   /// EmitProtocolExtension - Generate the protocol extension
1293   /// structure used to store optional instance and class methods, and
1294   /// protocol properties. The return value has type
1295   /// ProtocolExtensionPtrTy.
1296   llvm::Constant *
1297   EmitProtocolExtension(const ObjCProtocolDecl *PD,
1298                         const ProtocolMethodLists &methodLists);
1299 
1300   /// EmitProtocolList - Generate the list of referenced
1301   /// protocols. The return value has type ProtocolListPtrTy.
1302   llvm::Constant *EmitProtocolList(Twine Name,
1303                                    ObjCProtocolDecl::protocol_iterator begin,
1304                                    ObjCProtocolDecl::protocol_iterator end);
1305 
1306   /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1307   /// for the given selector.
1308   llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1309   Address EmitSelectorAddr(Selector Sel);
1310 
1311 public:
1312   CGObjCMac(CodeGen::CodeGenModule &cgm);
1313 
1314   llvm::Constant *getNSConstantStringClassRef() override;
1315 
1316   llvm::Function *ModuleInitFunction() override;
1317 
1318   CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1319                                       ReturnValueSlot Return,
1320                                       QualType ResultType,
1321                                       Selector Sel, llvm::Value *Receiver,
1322                                       const CallArgList &CallArgs,
1323                                       const ObjCInterfaceDecl *Class,
1324                                       const ObjCMethodDecl *Method) override;
1325 
1326   CodeGen::RValue
1327   GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1328                            ReturnValueSlot Return, QualType ResultType,
1329                            Selector Sel, const ObjCInterfaceDecl *Class,
1330                            bool isCategoryImpl, llvm::Value *Receiver,
1331                            bool IsClassMessage, const CallArgList &CallArgs,
1332                            const ObjCMethodDecl *Method) override;
1333 
1334   llvm::Value *GetClass(CodeGenFunction &CGF,
1335                         const ObjCInterfaceDecl *ID) override;
1336 
1337   llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
1338   Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
1339 
1340   /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1341   /// untyped one.
1342   llvm::Value *GetSelector(CodeGenFunction &CGF,
1343                            const ObjCMethodDecl *Method) override;
1344 
1345   llvm::Constant *GetEHType(QualType T) override;
1346 
1347   void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1348 
1349   void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1350 
1351   void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1352 
1353   llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1354                                    const ObjCProtocolDecl *PD) override;
1355 
1356   llvm::FunctionCallee GetPropertyGetFunction() override;
1357   llvm::FunctionCallee GetPropertySetFunction() override;
1358   llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
1359                                                        bool copy) override;
1360   llvm::FunctionCallee GetGetStructFunction() override;
1361   llvm::FunctionCallee GetSetStructFunction() override;
1362   llvm::FunctionCallee GetCppAtomicObjectGetFunction() override;
1363   llvm::FunctionCallee GetCppAtomicObjectSetFunction() override;
1364   llvm::FunctionCallee EnumerationMutationFunction() override;
1365 
1366   void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1367                    const ObjCAtTryStmt &S) override;
1368   void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1369                             const ObjCAtSynchronizedStmt &S) override;
1370   void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1371   void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1372                      bool ClearInsertionPoint=true) override;
1373   llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1374                                  Address AddrWeakObj) override;
1375   void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1376                           llvm::Value *src, Address dst) override;
1377   void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1378                             llvm::Value *src, Address dest,
1379                             bool threadlocal = false) override;
1380   void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1381                           llvm::Value *src, Address dest,
1382                           llvm::Value *ivarOffset) override;
1383   void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1384                                 llvm::Value *src, Address dest) override;
1385   void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1386                                 Address dest, Address src,
1387                                 llvm::Value *size) override;
1388 
1389   LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1390                               llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1391                               unsigned CVRQualifiers) override;
1392   llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1393                               const ObjCInterfaceDecl *Interface,
1394                               const ObjCIvarDecl *Ivar) override;
1395 };
1396 
1397 class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1398 private:
1399   friend ProtocolMethodLists;
1400   ObjCNonFragileABITypesHelper ObjCTypes;
1401   llvm::GlobalVariable* ObjCEmptyCacheVar;
1402   llvm::Constant* ObjCEmptyVtableVar;
1403 
1404   /// SuperClassReferences - uniqued super class references.
1405   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1406 
1407   /// MetaClassReferences - uniqued meta class references.
1408   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1409 
1410   /// EHTypeReferences - uniqued class ehtype references.
1411   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1412 
1413   /// VTableDispatchMethods - List of methods for which we generate
1414   /// vtable-based message dispatch.
1415   llvm::DenseSet<Selector> VTableDispatchMethods;
1416 
1417   /// DefinedMetaClasses - List of defined meta-classes.
1418   std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1419 
1420   /// isVTableDispatchedSelector - Returns true if SEL is a
1421   /// vtable-based selector.
1422   bool isVTableDispatchedSelector(Selector Sel);
1423 
1424   /// FinishNonFragileABIModule - Write out global data structures at the end of
1425   /// processing a translation unit.
1426   void FinishNonFragileABIModule();
1427 
1428   /// AddModuleClassList - Add the given list of class pointers to the
1429   /// module with the provided symbol and section names.
1430   void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container,
1431                           StringRef SymbolName, StringRef SectionName);
1432 
1433   llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1434                                               unsigned InstanceStart,
1435                                               unsigned InstanceSize,
1436                                               const ObjCImplementationDecl *ID);
1437   llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI,
1438                                          bool isMetaclass,
1439                                          llvm::Constant *IsAGV,
1440                                          llvm::Constant *SuperClassGV,
1441                                          llvm::Constant *ClassRoGV,
1442                                          bool HiddenVisibility);
1443 
1444   void emitMethodConstant(ConstantArrayBuilder &builder,
1445                             const ObjCMethodDecl *MD,
1446                             bool forProtocol);
1447 
1448   /// Emit the method list for the given implementation. The return value
1449   /// has type MethodListnfABITy.
1450   llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1451                                  ArrayRef<const ObjCMethodDecl *> Methods);
1452 
1453   /// EmitIvarList - Emit the ivar list for the given
1454   /// implementation. If ForClass is true the list of class ivars
1455   /// (i.e. metaclass ivars) is emitted, otherwise the list of
1456   /// interface ivars will be emitted. The return value has type
1457   /// IvarListnfABIPtrTy.
1458   llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
1459 
1460   llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1461                                     const ObjCIvarDecl *Ivar,
1462                                     unsigned long int offset);
1463 
1464   /// GetOrEmitProtocol - Get the protocol object for the given
1465   /// declaration, emitting it if necessary. The return value has type
1466   /// ProtocolPtrTy.
1467   llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1468 
1469   /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1470   /// object for the given declaration, emitting it if needed. These
1471   /// forward references will be filled in with empty bodies if no
1472   /// definition is seen. The return value has type ProtocolPtrTy.
1473   llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1474 
1475   /// EmitProtocolList - Generate the list of referenced
1476   /// protocols. The return value has type ProtocolListPtrTy.
1477   llvm::Constant *EmitProtocolList(Twine Name,
1478                                    ObjCProtocolDecl::protocol_iterator begin,
1479                                    ObjCProtocolDecl::protocol_iterator end);
1480 
1481   CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1482                                         ReturnValueSlot Return,
1483                                         QualType ResultType,
1484                                         Selector Sel,
1485                                         llvm::Value *Receiver,
1486                                         QualType Arg0Ty,
1487                                         bool IsSuper,
1488                                         const CallArgList &CallArgs,
1489                                         const ObjCMethodDecl *Method);
1490 
1491   /// GetClassGlobal - Return the global variable for the Objective-C
1492   /// class of the given name.
1493   llvm::Constant *GetClassGlobal(StringRef Name,
1494                                  ForDefinition_t IsForDefinition,
1495                                  bool Weak = false, bool DLLImport = false);
1496   llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID,
1497                                  bool isMetaclass,
1498                                  ForDefinition_t isForDefinition);
1499 
1500   llvm::Constant *GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID);
1501 
1502   llvm::Value *EmitLoadOfClassRef(CodeGenFunction &CGF,
1503                                   const ObjCInterfaceDecl *ID,
1504                                   llvm::GlobalVariable *Entry);
1505 
1506   /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1507   /// for the given class reference.
1508   llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1509                             const ObjCInterfaceDecl *ID);
1510 
1511   llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1512                                   IdentifierInfo *II,
1513                                   const ObjCInterfaceDecl *ID);
1514 
1515   llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1516 
1517   /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1518   /// for the given super class reference.
1519   llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1520                                  const ObjCInterfaceDecl *ID);
1521 
1522   /// EmitMetaClassRef - Return a Value * of the address of _class_t
1523   /// meta-data
1524   llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1525                                 const ObjCInterfaceDecl *ID, bool Weak);
1526 
1527   /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1528   /// the given ivar.
1529   ///
1530   llvm::GlobalVariable * ObjCIvarOffsetVariable(
1531     const ObjCInterfaceDecl *ID,
1532     const ObjCIvarDecl *Ivar);
1533 
1534   /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1535   /// for the given selector.
1536   llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1537   Address EmitSelectorAddr(Selector Sel);
1538 
1539   /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1540   /// interface. The return value has type EHTypePtrTy.
1541   llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1542                                      ForDefinition_t IsForDefinition);
1543 
1544   StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }
1545 
1546   StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; }
1547 
1548   void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1549                         uint32_t &InstanceStart,
1550                         uint32_t &InstanceSize);
1551 
1552   // Shamelessly stolen from Analysis/CFRefCount.cpp
1553   Selector GetNullarySelector(const char* name) const {
1554     IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1555     return CGM.getContext().Selectors.getSelector(0, &II);
1556   }
1557 
1558   Selector GetUnarySelector(const char* name) const {
1559     IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1560     return CGM.getContext().Selectors.getSelector(1, &II);
1561   }
1562 
1563   /// ImplementationIsNonLazy - Check whether the given category or
1564   /// class implementation is "non-lazy".
1565   bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1566 
1567   bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1568                                    const ObjCIvarDecl *IV) {
1569     // Annotate the load as an invariant load iff inside an instance method
1570     // and ivar belongs to instance method's class and one of its super class.
1571     // This check is needed because the ivar offset is a lazily
1572     // initialised value that may depend on objc_msgSend to perform a fixup on
1573     // the first message dispatch.
1574     //
1575     // An additional opportunity to mark the load as invariant arises when the
1576     // base of the ivar access is a parameter to an Objective C method.
1577     // However, because the parameters are not available in the current
1578     // interface, we cannot perform this check.
1579     //
1580     // Note that for direct methods, because objc_msgSend is skipped,
1581     // and that the method may be inlined, this optimization actually
1582     // can't be performed.
1583     if (const ObjCMethodDecl *MD =
1584           dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1585       if (MD->isInstanceMethod() && !MD->isDirectMethod())
1586         if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1587           return IV->getContainingInterface()->isSuperClassOf(ID);
1588     return false;
1589   }
1590 
1591   bool isClassLayoutKnownStatically(const ObjCInterfaceDecl *ID) {
1592     // NSObject is a fixed size. If we can see the @implementation of a class
1593     // which inherits from NSObject then we know that all it's offsets also must
1594     // be fixed. FIXME: Can we do this if see a chain of super classes with
1595     // implementations leading to NSObject?
1596     return ID->getImplementation() && ID->getSuperClass() &&
1597            ID->getSuperClass()->getName() == "NSObject";
1598   }
1599 
1600 public:
1601   CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1602 
1603   llvm::Constant *getNSConstantStringClassRef() override;
1604 
1605   llvm::Function *ModuleInitFunction() override;
1606 
1607   CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1608                                       ReturnValueSlot Return,
1609                                       QualType ResultType, Selector Sel,
1610                                       llvm::Value *Receiver,
1611                                       const CallArgList &CallArgs,
1612                                       const ObjCInterfaceDecl *Class,
1613                                       const ObjCMethodDecl *Method) override;
1614 
1615   CodeGen::RValue
1616   GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1617                            ReturnValueSlot Return, QualType ResultType,
1618                            Selector Sel, const ObjCInterfaceDecl *Class,
1619                            bool isCategoryImpl, llvm::Value *Receiver,
1620                            bool IsClassMessage, const CallArgList &CallArgs,
1621                            const ObjCMethodDecl *Method) override;
1622 
1623   llvm::Value *GetClass(CodeGenFunction &CGF,
1624                         const ObjCInterfaceDecl *ID) override;
1625 
1626   llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override
1627     { return EmitSelector(CGF, Sel); }
1628   Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
1629     { return EmitSelectorAddr(Sel); }
1630 
1631   /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1632   /// untyped one.
1633   llvm::Value *GetSelector(CodeGenFunction &CGF,
1634                            const ObjCMethodDecl *Method) override
1635     { return EmitSelector(CGF, Method->getSelector()); }
1636 
1637   void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1638 
1639   void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1640 
1641   void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1642 
1643   llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1644                                    const ObjCProtocolDecl *PD) override;
1645 
1646   llvm::Constant *GetEHType(QualType T) override;
1647 
1648   llvm::FunctionCallee GetPropertyGetFunction() override {
1649     return ObjCTypes.getGetPropertyFn();
1650   }
1651   llvm::FunctionCallee GetPropertySetFunction() override {
1652     return ObjCTypes.getSetPropertyFn();
1653   }
1654 
1655   llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
1656                                                        bool copy) override {
1657     return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1658   }
1659 
1660   llvm::FunctionCallee GetSetStructFunction() override {
1661     return ObjCTypes.getCopyStructFn();
1662   }
1663 
1664   llvm::FunctionCallee GetGetStructFunction() override {
1665     return ObjCTypes.getCopyStructFn();
1666   }
1667 
1668   llvm::FunctionCallee GetCppAtomicObjectSetFunction() override {
1669     return ObjCTypes.getCppAtomicObjectFunction();
1670   }
1671 
1672   llvm::FunctionCallee GetCppAtomicObjectGetFunction() override {
1673     return ObjCTypes.getCppAtomicObjectFunction();
1674   }
1675 
1676   llvm::FunctionCallee EnumerationMutationFunction() override {
1677     return ObjCTypes.getEnumerationMutationFn();
1678   }
1679 
1680   void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1681                    const ObjCAtTryStmt &S) override;
1682   void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1683                             const ObjCAtSynchronizedStmt &S) override;
1684   void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1685                      bool ClearInsertionPoint=true) override;
1686   llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1687                                  Address AddrWeakObj) override;
1688   void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1689                           llvm::Value *src, Address edst) override;
1690   void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1691                             llvm::Value *src, Address dest,
1692                             bool threadlocal = false) override;
1693   void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1694                           llvm::Value *src, Address dest,
1695                           llvm::Value *ivarOffset) override;
1696   void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1697                                 llvm::Value *src, Address dest) override;
1698   void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1699                                 Address dest, Address src,
1700                                 llvm::Value *size) override;
1701   LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1702                               llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1703                               unsigned CVRQualifiers) override;
1704   llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1705                               const ObjCInterfaceDecl *Interface,
1706                               const ObjCIvarDecl *Ivar) override;
1707 };
1708 
1709 /// A helper class for performing the null-initialization of a return
1710 /// value.
1711 struct NullReturnState {
1712   llvm::BasicBlock *NullBB;
1713   NullReturnState() : NullBB(nullptr) {}
1714 
1715   /// Perform a null-check of the given receiver.
1716   void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1717     // Make blocks for the null-receiver and call edges.
1718     NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1719     llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1720 
1721     // Check for a null receiver and, if there is one, jump to the
1722     // null-receiver block.  There's no point in trying to avoid it:
1723     // we're always going to put *something* there, because otherwise
1724     // we shouldn't have done this null-check in the first place.
1725     llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1726     CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1727 
1728     // Otherwise, start performing the call.
1729     CGF.EmitBlock(callBB);
1730   }
1731 
1732   /// Complete the null-return operation.  It is valid to call this
1733   /// regardless of whether 'init' has been called.
1734   RValue complete(CodeGenFunction &CGF,
1735                   ReturnValueSlot returnSlot,
1736                   RValue result,
1737                   QualType resultType,
1738                   const CallArgList &CallArgs,
1739                   const ObjCMethodDecl *Method) {
1740     // If we never had to do a null-check, just use the raw result.
1741     if (!NullBB) return result;
1742 
1743     // The continuation block.  This will be left null if we don't have an
1744     // IP, which can happen if the method we're calling is marked noreturn.
1745     llvm::BasicBlock *contBB = nullptr;
1746 
1747     // Finish the call path.
1748     llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1749     if (callBB) {
1750       contBB = CGF.createBasicBlock("msgSend.cont");
1751       CGF.Builder.CreateBr(contBB);
1752     }
1753 
1754     // Okay, start emitting the null-receiver block.
1755     CGF.EmitBlock(NullBB);
1756 
1757     // Release any consumed arguments we've got.
1758     if (Method) {
1759       CallArgList::const_iterator I = CallArgs.begin();
1760       for (ObjCMethodDecl::param_const_iterator i = Method->param_begin(),
1761            e = Method->param_end(); i != e; ++i, ++I) {
1762         const ParmVarDecl *ParamDecl = (*i);
1763         if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1764           RValue RV = I->getRValue(CGF);
1765           assert(RV.isScalar() &&
1766                  "NullReturnState::complete - arg not on object");
1767           CGF.EmitARCRelease(RV.getScalarVal(), ARCImpreciseLifetime);
1768         } else {
1769           QualType QT = ParamDecl->getType();
1770           auto *RT = QT->getAs<RecordType>();
1771           if (RT && RT->getDecl()->isParamDestroyedInCallee()) {
1772             RValue RV = I->getRValue(CGF);
1773             QualType::DestructionKind DtorKind = QT.isDestructedType();
1774             switch (DtorKind) {
1775             case QualType::DK_cxx_destructor:
1776               CGF.destroyCXXObject(CGF, RV.getAggregateAddress(), QT);
1777               break;
1778             case QualType::DK_nontrivial_c_struct:
1779               CGF.destroyNonTrivialCStruct(CGF, RV.getAggregateAddress(), QT);
1780               break;
1781             default:
1782               llvm_unreachable("unexpected dtor kind");
1783               break;
1784             }
1785           }
1786         }
1787       }
1788     }
1789 
1790     // The phi code below assumes that we haven't needed any control flow yet.
1791     assert(CGF.Builder.GetInsertBlock() == NullBB);
1792 
1793     // If we've got a void return, just jump to the continuation block.
1794     if (result.isScalar() && resultType->isVoidType()) {
1795       // No jumps required if the message-send was noreturn.
1796       if (contBB) CGF.EmitBlock(contBB);
1797       return result;
1798     }
1799 
1800     // If we've got a scalar return, build a phi.
1801     if (result.isScalar()) {
1802       // Derive the null-initialization value.
1803       llvm::Value *null =
1804           CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(resultType), resultType);
1805 
1806       // If no join is necessary, just flow out.
1807       if (!contBB) return RValue::get(null);
1808 
1809       // Otherwise, build a phi.
1810       CGF.EmitBlock(contBB);
1811       llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1812       phi->addIncoming(result.getScalarVal(), callBB);
1813       phi->addIncoming(null, NullBB);
1814       return RValue::get(phi);
1815     }
1816 
1817     // If we've got an aggregate return, null the buffer out.
1818     // FIXME: maybe we should be doing things differently for all the
1819     // cases where the ABI has us returning (1) non-agg values in
1820     // memory or (2) agg values in registers.
1821     if (result.isAggregate()) {
1822       assert(result.isAggregate() && "null init of non-aggregate result?");
1823       if (!returnSlot.isUnused())
1824         CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
1825       if (contBB) CGF.EmitBlock(contBB);
1826       return result;
1827     }
1828 
1829     // Complex types.
1830     CGF.EmitBlock(contBB);
1831     CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1832 
1833     // Find the scalar type and its zero value.
1834     llvm::Type *scalarTy = callResult.first->getType();
1835     llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1836 
1837     // Build phis for both coordinates.
1838     llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1839     real->addIncoming(callResult.first, callBB);
1840     real->addIncoming(scalarZero, NullBB);
1841     llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1842     imag->addIncoming(callResult.second, callBB);
1843     imag->addIncoming(scalarZero, NullBB);
1844     return RValue::getComplex(real, imag);
1845   }
1846 };
1847 
1848 } // end anonymous namespace
1849 
1850 /* *** Helper Functions *** */
1851 
1852 /// getConstantGEP() - Help routine to construct simple GEPs.
1853 static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1854                                       llvm::GlobalVariable *C, unsigned idx0,
1855                                       unsigned idx1) {
1856   llvm::Value *Idxs[] = {
1857     llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1858     llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1859   };
1860   return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1861 }
1862 
1863 /// hasObjCExceptionAttribute - Return true if this class or any super
1864 /// class has the __objc_exception__ attribute.
1865 static bool hasObjCExceptionAttribute(ASTContext &Context,
1866                                       const ObjCInterfaceDecl *OID) {
1867   if (OID->hasAttr<ObjCExceptionAttr>())
1868     return true;
1869   if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1870     return hasObjCExceptionAttribute(Context, Super);
1871   return false;
1872 }
1873 
1874 static llvm::GlobalValue::LinkageTypes
1875 getLinkageTypeForObjCMetadata(CodeGenModule &CGM, StringRef Section) {
1876   if (CGM.getTriple().isOSBinFormatMachO() &&
1877       (Section.empty() || Section.startswith("__DATA")))
1878     return llvm::GlobalValue::InternalLinkage;
1879   return llvm::GlobalValue::PrivateLinkage;
1880 }
1881 
1882 /// A helper function to create an internal or private global variable.
1883 static llvm::GlobalVariable *
1884 finishAndCreateGlobal(ConstantInitBuilder::StructBuilder &Builder,
1885                      const llvm::Twine &Name, CodeGenModule &CGM) {
1886   std::string SectionName;
1887   if (CGM.getTriple().isOSBinFormatMachO())
1888     SectionName = "__DATA, __objc_const";
1889   auto *GV = Builder.finishAndCreateGlobal(
1890       Name, CGM.getPointerAlign(), /*constant*/ false,
1891       getLinkageTypeForObjCMetadata(CGM, SectionName));
1892   GV->setSection(SectionName);
1893   return GV;
1894 }
1895 
1896 /* *** CGObjCMac Public Interface *** */
1897 
1898 CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1899                                                     ObjCTypes(cgm) {
1900   ObjCABI = 1;
1901   EmitImageInfo();
1902 }
1903 
1904 /// GetClass - Return a reference to the class for the given interface
1905 /// decl.
1906 llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1907                                  const ObjCInterfaceDecl *ID) {
1908   return EmitClassRef(CGF, ID);
1909 }
1910 
1911 /// GetSelector - Return the pointer to the unique'd string for this selector.
1912 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1913   return EmitSelector(CGF, Sel);
1914 }
1915 Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1916   return EmitSelectorAddr(Sel);
1917 }
1918 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1919                                     *Method) {
1920   return EmitSelector(CGF, Method->getSelector());
1921 }
1922 
1923 llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1924   if (T->isObjCIdType() ||
1925       T->isObjCQualifiedIdType()) {
1926     return CGM.GetAddrOfRTTIDescriptor(
1927               CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1928   }
1929   if (T->isObjCClassType() ||
1930       T->isObjCQualifiedClassType()) {
1931     return CGM.GetAddrOfRTTIDescriptor(
1932              CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1933   }
1934   if (T->isObjCObjectPointerType())
1935     return CGM.GetAddrOfRTTIDescriptor(T,  /*ForEH=*/true);
1936 
1937   llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1938 }
1939 
1940 /// Generate a constant CFString object.
1941 /*
1942   struct __builtin_CFString {
1943   const int *isa; // point to __CFConstantStringClassReference
1944   int flags;
1945   const char *str;
1946   long length;
1947   };
1948 */
1949 
1950 /// or Generate a constant NSString object.
1951 /*
1952    struct __builtin_NSString {
1953      const int *isa; // point to __NSConstantStringClassReference
1954      const char *str;
1955      unsigned int length;
1956    };
1957 */
1958 
1959 ConstantAddress
1960 CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) {
1961   return (!CGM.getLangOpts().NoConstantCFStrings
1962             ? CGM.GetAddrOfConstantCFString(SL)
1963             : GenerateConstantNSString(SL));
1964 }
1965 
1966 static llvm::StringMapEntry<llvm::GlobalVariable *> &
1967 GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
1968                        const StringLiteral *Literal, unsigned &StringLength) {
1969   StringRef String = Literal->getString();
1970   StringLength = String.size();
1971   return *Map.insert(std::make_pair(String, nullptr)).first;
1972 }
1973 
1974 llvm::Constant *CGObjCMac::getNSConstantStringClassRef() {
1975   if (llvm::Value *V = ConstantStringClassRef)
1976     return cast<llvm::Constant>(V);
1977 
1978   auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1979   std::string str =
1980     StringClass.empty() ? "_NSConstantStringClassReference"
1981                         : "_" + StringClass + "ClassReference";
1982 
1983   llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
1984   auto GV = CGM.CreateRuntimeVariable(PTy, str);
1985   auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1986   ConstantStringClassRef = V;
1987   return V;
1988 }
1989 
1990 llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() {
1991   if (llvm::Value *V = ConstantStringClassRef)
1992     return cast<llvm::Constant>(V);
1993 
1994   auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1995   std::string str =
1996     StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
1997                         : "OBJC_CLASS_$_" + StringClass;
1998   llvm::Constant *GV = GetClassGlobal(str, NotForDefinition);
1999 
2000   // Make sure the result is of the correct type.
2001   auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
2002 
2003   ConstantStringClassRef = V;
2004   return V;
2005 }
2006 
2007 ConstantAddress
2008 CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) {
2009   unsigned StringLength = 0;
2010   llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
2011     GetConstantStringEntry(NSConstantStringMap, Literal, StringLength);
2012 
2013   if (auto *C = Entry.second)
2014     return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
2015 
2016   // If we don't already have it, get _NSConstantStringClassReference.
2017   llvm::Constant *Class = getNSConstantStringClassRef();
2018 
2019   // If we don't already have it, construct the type for a constant NSString.
2020   if (!NSConstantStringType) {
2021     NSConstantStringType =
2022       llvm::StructType::create({
2023         CGM.Int32Ty->getPointerTo(),
2024         CGM.Int8PtrTy,
2025         CGM.IntTy
2026       }, "struct.__builtin_NSString");
2027   }
2028 
2029   ConstantInitBuilder Builder(CGM);
2030   auto Fields = Builder.beginStruct(NSConstantStringType);
2031 
2032   // Class pointer.
2033   Fields.add(Class);
2034 
2035   // String pointer.
2036   llvm::Constant *C =
2037     llvm::ConstantDataArray::getString(VMContext, Entry.first());
2038 
2039   llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage;
2040   bool isConstant = !CGM.getLangOpts().WritableStrings;
2041 
2042   auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant,
2043                                       Linkage, C, ".str");
2044   GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2045   // Don't enforce the target's minimum global alignment, since the only use
2046   // of the string is via this class initializer.
2047   GV->setAlignment(llvm::Align(1));
2048   Fields.addBitCast(GV, CGM.Int8PtrTy);
2049 
2050   // String length.
2051   Fields.addInt(CGM.IntTy, StringLength);
2052 
2053   // The struct.
2054   CharUnits Alignment = CGM.getPointerAlign();
2055   GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
2056                                     /*constant*/ true,
2057                                     llvm::GlobalVariable::PrivateLinkage);
2058   const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
2059   const char *NSStringNonFragileABISection =
2060       "__DATA,__objc_stringobj,regular,no_dead_strip";
2061   // FIXME. Fix section.
2062   GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
2063                      ? NSStringNonFragileABISection
2064                      : NSStringSection);
2065   Entry.second = GV;
2066 
2067   return ConstantAddress(GV, Alignment);
2068 }
2069 
2070 enum {
2071   kCFTaggedObjectID_Integer = (1 << 1) + 1
2072 };
2073 
2074 /// Generates a message send where the super is the receiver.  This is
2075 /// a message send to self with special delivery semantics indicating
2076 /// which class's method should be called.
2077 CodeGen::RValue
2078 CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
2079                                     ReturnValueSlot Return,
2080                                     QualType ResultType,
2081                                     Selector Sel,
2082                                     const ObjCInterfaceDecl *Class,
2083                                     bool isCategoryImpl,
2084                                     llvm::Value *Receiver,
2085                                     bool IsClassMessage,
2086                                     const CodeGen::CallArgList &CallArgs,
2087                                     const ObjCMethodDecl *Method) {
2088   // Create and init a super structure; this is a (receiver, class)
2089   // pair we will pass to objc_msgSendSuper.
2090   Address ObjCSuper =
2091     CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
2092                          "objc_super");
2093   llvm::Value *ReceiverAsObject =
2094     CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
2095   CGF.Builder.CreateStore(ReceiverAsObject,
2096                           CGF.Builder.CreateStructGEP(ObjCSuper, 0));
2097 
2098   // If this is a class message the metaclass is passed as the target.
2099   llvm::Value *Target;
2100   if (IsClassMessage) {
2101     if (isCategoryImpl) {
2102       // Message sent to 'super' in a class method defined in a category
2103       // implementation requires an odd treatment.
2104       // If we are in a class method, we must retrieve the
2105       // _metaclass_ for the current class, pointed at by
2106       // the class's "isa" pointer.  The following assumes that
2107       // isa" is the first ivar in a class (which it must be).
2108       Target = EmitClassRef(CGF, Class->getSuperClass());
2109       Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
2110       Target = CGF.Builder.CreateAlignedLoad(Target, CGF.getPointerAlign());
2111     } else {
2112       llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
2113       llvm::Value *SuperPtr =
2114           CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
2115       llvm::Value *Super =
2116         CGF.Builder.CreateAlignedLoad(SuperPtr, CGF.getPointerAlign());
2117       Target = Super;
2118     }
2119   } else if (isCategoryImpl)
2120     Target = EmitClassRef(CGF, Class->getSuperClass());
2121   else {
2122     llvm::Value *ClassPtr = EmitSuperClassRef(Class);
2123     ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
2124     Target = CGF.Builder.CreateAlignedLoad(ClassPtr, CGF.getPointerAlign());
2125   }
2126   // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
2127   // ObjCTypes types.
2128   llvm::Type *ClassTy =
2129     CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
2130   Target = CGF.Builder.CreateBitCast(Target, ClassTy);
2131   CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
2132   return EmitMessageSend(CGF, Return, ResultType, Sel, ObjCSuper.getPointer(),
2133                          ObjCTypes.SuperPtrCTy, true, CallArgs, Method, Class,
2134                          ObjCTypes);
2135 }
2136 
2137 /// Generate code for a message send expression.
2138 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
2139                                                ReturnValueSlot Return,
2140                                                QualType ResultType,
2141                                                Selector Sel,
2142                                                llvm::Value *Receiver,
2143                                                const CallArgList &CallArgs,
2144                                                const ObjCInterfaceDecl *Class,
2145                                                const ObjCMethodDecl *Method) {
2146   return EmitMessageSend(CGF, Return, ResultType, Sel, Receiver,
2147                          CGF.getContext().getObjCIdType(), false, CallArgs,
2148                          Method, Class, ObjCTypes);
2149 }
2150 
2151 static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
2152   do {
2153     if (ID->isWeakImported())
2154       return true;
2155   } while ((ID = ID->getSuperClass()));
2156 
2157   return false;
2158 }
2159 
2160 CodeGen::RValue
2161 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
2162                                  ReturnValueSlot Return,
2163                                  QualType ResultType,
2164                                  Selector Sel,
2165                                  llvm::Value *Arg0,
2166                                  QualType Arg0Ty,
2167                                  bool IsSuper,
2168                                  const CallArgList &CallArgs,
2169                                  const ObjCMethodDecl *Method,
2170                                  const ObjCInterfaceDecl *ClassReceiver,
2171                                  const ObjCCommonTypesHelper &ObjCTypes) {
2172   CodeGenTypes &Types = CGM.getTypes();
2173   auto selTy = CGF.getContext().getObjCSelType();
2174   llvm::Value *SelValue;
2175 
2176   if (Method && Method->isDirectMethod()) {
2177     // Direct methods will synthesize the proper `_cmd` internally,
2178     // so just don't bother with setting the `_cmd` argument.
2179     assert(!IsSuper);
2180     SelValue = llvm::UndefValue::get(Types.ConvertType(selTy));
2181   } else {
2182     SelValue = GetSelector(CGF, Sel);
2183   }
2184 
2185   CallArgList ActualArgs;
2186   if (!IsSuper)
2187     Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
2188   ActualArgs.add(RValue::get(Arg0), Arg0Ty);
2189   ActualArgs.add(RValue::get(SelValue), selTy);
2190   ActualArgs.addFrom(CallArgs);
2191 
2192   // If we're calling a method, use the formal signature.
2193   MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2194 
2195   if (Method)
2196     assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==
2197                CGM.getContext().getCanonicalType(ResultType) &&
2198            "Result type mismatch!");
2199 
2200   bool ReceiverCanBeNull = true;
2201 
2202   // Super dispatch assumes that self is non-null; even the messenger
2203   // doesn't have a null check internally.
2204   if (IsSuper) {
2205     ReceiverCanBeNull = false;
2206 
2207   // If this is a direct dispatch of a class method, check whether the class,
2208   // or anything in its hierarchy, was weak-linked.
2209   } else if (ClassReceiver && Method && Method->isClassMethod()) {
2210     ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);
2211 
2212   // If we're emitting a method, and self is const (meaning just ARC, for now),
2213   // and the receiver is a load of self, then self is a valid object.
2214   } else if (auto CurMethod =
2215                dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
2216     auto Self = CurMethod->getSelfDecl();
2217     if (Self->getType().isConstQualified()) {
2218       if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {
2219         llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer();
2220         if (SelfAddr == LI->getPointerOperand()) {
2221           ReceiverCanBeNull = false;
2222         }
2223       }
2224     }
2225   }
2226 
2227   bool RequiresNullCheck = false;
2228 
2229   llvm::FunctionCallee Fn = nullptr;
2230   if (Method && Method->isDirectMethod()) {
2231     Fn = GenerateDirectMethod(Method, Method->getClassInterface());
2232   } else if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
2233     if (ReceiverCanBeNull) RequiresNullCheck = true;
2234     Fn = (ObjCABI == 2) ?  ObjCTypes.getSendStretFn2(IsSuper)
2235       : ObjCTypes.getSendStretFn(IsSuper);
2236   } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
2237     Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
2238       : ObjCTypes.getSendFpretFn(IsSuper);
2239   } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
2240     Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
2241       : ObjCTypes.getSendFp2retFn(IsSuper);
2242   } else {
2243     // arm64 uses objc_msgSend for stret methods and yet null receiver check
2244     // must be made for it.
2245     if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
2246       RequiresNullCheck = true;
2247     Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
2248       : ObjCTypes.getSendFn(IsSuper);
2249   }
2250 
2251   // Cast function to proper signature
2252   llvm::Constant *BitcastFn = cast<llvm::Constant>(
2253       CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType));
2254 
2255   // We don't need to emit a null check to zero out an indirect result if the
2256   // result is ignored.
2257   if (Return.isUnused())
2258     RequiresNullCheck = false;
2259 
2260   // Emit a null-check if there's a consumed argument other than the receiver.
2261   if (!RequiresNullCheck && CGM.getLangOpts().ObjCAutoRefCount && Method) {
2262     for (const auto *ParamDecl : Method->parameters()) {
2263       if (ParamDecl->isDestroyedInCallee()) {
2264         RequiresNullCheck = true;
2265         break;
2266       }
2267     }
2268   }
2269 
2270   NullReturnState nullReturn;
2271   if (RequiresNullCheck) {
2272     nullReturn.init(CGF, Arg0);
2273   }
2274 
2275   llvm::CallBase *CallSite;
2276   CGCallee Callee = CGCallee::forDirect(BitcastFn);
2277   RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
2278                                &CallSite);
2279 
2280   // Mark the call as noreturn if the method is marked noreturn and the
2281   // receiver cannot be null.
2282   if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) {
2283     CallSite->setDoesNotReturn();
2284   }
2285 
2286   return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs,
2287                              RequiresNullCheck ? Method : nullptr);
2288 }
2289 
2290 static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT,
2291                                            bool pointee = false) {
2292   // Note that GC qualification applies recursively to C pointer types
2293   // that aren't otherwise decorated.  This is weird, but it's probably
2294   // an intentional workaround to the unreliable placement of GC qualifiers.
2295   if (FQT.isObjCGCStrong())
2296     return Qualifiers::Strong;
2297 
2298   if (FQT.isObjCGCWeak())
2299     return Qualifiers::Weak;
2300 
2301   if (auto ownership = FQT.getObjCLifetime()) {
2302     // Ownership does not apply recursively to C pointer types.
2303     if (pointee) return Qualifiers::GCNone;
2304     switch (ownership) {
2305     case Qualifiers::OCL_Weak: return Qualifiers::Weak;
2306     case Qualifiers::OCL_Strong: return Qualifiers::Strong;
2307     case Qualifiers::OCL_ExplicitNone: return Qualifiers::GCNone;
2308     case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?");
2309     case Qualifiers::OCL_None: llvm_unreachable("known nonzero");
2310     }
2311     llvm_unreachable("bad objc ownership");
2312   }
2313 
2314   // Treat unqualified retainable pointers as strong.
2315   if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2316     return Qualifiers::Strong;
2317 
2318   // Walk into C pointer types, but only in GC.
2319   if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
2320     if (const PointerType *PT = FQT->getAs<PointerType>())
2321       return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
2322   }
2323 
2324   return Qualifiers::GCNone;
2325 }
2326 
2327 namespace {
2328   struct IvarInfo {
2329     CharUnits Offset;
2330     uint64_t SizeInWords;
2331     IvarInfo(CharUnits offset, uint64_t sizeInWords)
2332       : Offset(offset), SizeInWords(sizeInWords) {}
2333 
2334     // Allow sorting based on byte pos.
2335     bool operator<(const IvarInfo &other) const {
2336       return Offset < other.Offset;
2337     }
2338   };
2339 
2340   /// A helper class for building GC layout strings.
2341   class IvarLayoutBuilder {
2342     CodeGenModule &CGM;
2343 
2344     /// The start of the layout.  Offsets will be relative to this value,
2345     /// and entries less than this value will be silently discarded.
2346     CharUnits InstanceBegin;
2347 
2348     /// The end of the layout.  Offsets will never exceed this value.
2349     CharUnits InstanceEnd;
2350 
2351     /// Whether we're generating the strong layout or the weak layout.
2352     bool ForStrongLayout;
2353 
2354     /// Whether the offsets in IvarsInfo might be out-of-order.
2355     bool IsDisordered = false;
2356 
2357     llvm::SmallVector<IvarInfo, 8> IvarsInfo;
2358 
2359   public:
2360     IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2361                       CharUnits instanceEnd, bool forStrongLayout)
2362       : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
2363         ForStrongLayout(forStrongLayout) {
2364     }
2365 
2366     void visitRecord(const RecordType *RT, CharUnits offset);
2367 
2368     template <class Iterator, class GetOffsetFn>
2369     void visitAggregate(Iterator begin, Iterator end,
2370                         CharUnits aggrOffset,
2371                         const GetOffsetFn &getOffset);
2372 
2373     void visitField(const FieldDecl *field, CharUnits offset);
2374 
2375     /// Add the layout of a block implementation.
2376     void visitBlock(const CGBlockInfo &blockInfo);
2377 
2378     /// Is there any information for an interesting bitmap?
2379     bool hasBitmapData() const { return !IvarsInfo.empty(); }
2380 
2381     llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
2382                                 llvm::SmallVectorImpl<unsigned char> &buffer);
2383 
2384     static void dump(ArrayRef<unsigned char> buffer) {
2385       const unsigned char *s = buffer.data();
2386       for (unsigned i = 0, e = buffer.size(); i < e; i++)
2387         if (!(s[i] & 0xf0))
2388           printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2389         else
2390           printf("0x%x%s",  s[i], s[i] != 0 ? ", " : "");
2391       printf("\n");
2392     }
2393   };
2394 } // end anonymous namespace
2395 
2396 llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
2397                                                 const CGBlockInfo &blockInfo) {
2398 
2399   llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2400   if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
2401     return nullPtr;
2402 
2403   IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2404                             /*for strong layout*/ true);
2405 
2406   builder.visitBlock(blockInfo);
2407 
2408   if (!builder.hasBitmapData())
2409     return nullPtr;
2410 
2411   llvm::SmallVector<unsigned char, 32> buffer;
2412   llvm::Constant *C = builder.buildBitmap(*this, buffer);
2413   if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
2414     printf("\n block variable layout for block: ");
2415     builder.dump(buffer);
2416   }
2417 
2418   return C;
2419 }
2420 
2421 void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
2422   // __isa is the first field in block descriptor and must assume by runtime's
2423   // convention that it is GC'able.
2424   IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2425 
2426   const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2427 
2428   // Ignore the optional 'this' capture: C++ objects are not assumed
2429   // to be GC'ed.
2430 
2431   CharUnits lastFieldOffset;
2432 
2433   // Walk the captured variables.
2434   for (const auto &CI : blockDecl->captures()) {
2435     const VarDecl *variable = CI.getVariable();
2436     QualType type = variable->getType();
2437 
2438     const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2439 
2440     // Ignore constant captures.
2441     if (capture.isConstant()) continue;
2442 
2443     CharUnits fieldOffset = capture.getOffset();
2444 
2445     // Block fields are not necessarily ordered; if we detect that we're
2446     // adding them out-of-order, make sure we sort later.
2447     if (fieldOffset < lastFieldOffset)
2448       IsDisordered = true;
2449     lastFieldOffset = fieldOffset;
2450 
2451     // __block variables are passed by their descriptor address.
2452     if (CI.isByRef()) {
2453       IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2454       continue;
2455     }
2456 
2457     assert(!type->isArrayType() && "array variable should not be caught");
2458     if (const RecordType *record = type->getAs<RecordType>()) {
2459       visitRecord(record, fieldOffset);
2460       continue;
2461     }
2462 
2463     Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), type);
2464 
2465     if (GCAttr == Qualifiers::Strong) {
2466       assert(CGM.getContext().getTypeSize(type)
2467                 == CGM.getTarget().getPointerWidth(0));
2468       IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2469     }
2470   }
2471 }
2472 
2473 /// getBlockCaptureLifetime - This routine returns life time of the captured
2474 /// block variable for the purpose of block layout meta-data generation. FQT is
2475 /// the type of the variable captured in the block.
2476 Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2477                                                                   bool ByrefLayout) {
2478   // If it has an ownership qualifier, we're done.
2479   if (auto lifetime = FQT.getObjCLifetime())
2480     return lifetime;
2481 
2482   // If it doesn't, and this is ARC, it has no ownership.
2483   if (CGM.getLangOpts().ObjCAutoRefCount)
2484     return Qualifiers::OCL_None;
2485 
2486   // In MRC, retainable pointers are owned by non-__block variables.
2487   if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2488     return ByrefLayout ? Qualifiers::OCL_ExplicitNone : Qualifiers::OCL_Strong;
2489 
2490   return Qualifiers::OCL_None;
2491 }
2492 
2493 void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2494                                              Qualifiers::ObjCLifetime LifeTime,
2495                                              CharUnits FieldOffset,
2496                                              CharUnits FieldSize) {
2497   // __block variables are passed by their descriptor address.
2498   if (IsByref)
2499     RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2500                                         FieldSize));
2501   else if (LifeTime == Qualifiers::OCL_Strong)
2502     RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2503                                         FieldSize));
2504   else if (LifeTime == Qualifiers::OCL_Weak)
2505     RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2506                                         FieldSize));
2507   else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2508     RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2509                                         FieldSize));
2510   else
2511     RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2512                                         FieldOffset,
2513                                         FieldSize));
2514 }
2515 
2516 void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2517                                           const RecordDecl *RD,
2518                                           ArrayRef<const FieldDecl*> RecFields,
2519                                           CharUnits BytePos, bool &HasUnion,
2520                                           bool ByrefLayout) {
2521   bool IsUnion = (RD && RD->isUnion());
2522   CharUnits MaxUnionSize = CharUnits::Zero();
2523   const FieldDecl *MaxField = nullptr;
2524   const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2525   CharUnits MaxFieldOffset = CharUnits::Zero();
2526   CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2527 
2528   if (RecFields.empty())
2529     return;
2530   unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2531 
2532   for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
2533     const FieldDecl *Field = RecFields[i];
2534     // Note that 'i' here is actually the field index inside RD of Field,
2535     // although this dependency is hidden.
2536     const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2537     CharUnits FieldOffset =
2538       CGM.getContext().toCharUnitsFromBits(RL.getFieldOffset(i));
2539 
2540     // Skip over unnamed or bitfields
2541     if (!Field->getIdentifier() || Field->isBitField()) {
2542       LastFieldBitfieldOrUnnamed = Field;
2543       LastBitfieldOrUnnamedOffset = FieldOffset;
2544       continue;
2545     }
2546 
2547     LastFieldBitfieldOrUnnamed = nullptr;
2548     QualType FQT = Field->getType();
2549     if (FQT->isRecordType() || FQT->isUnionType()) {
2550       if (FQT->isUnionType())
2551         HasUnion = true;
2552 
2553       BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
2554                                   BytePos + FieldOffset, HasUnion);
2555       continue;
2556     }
2557 
2558     if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2559       auto *CArray = cast<ConstantArrayType>(Array);
2560       uint64_t ElCount = CArray->getSize().getZExtValue();
2561       assert(CArray && "only array with known element size is supported");
2562       FQT = CArray->getElementType();
2563       while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2564         auto *CArray = cast<ConstantArrayType>(Array);
2565         ElCount *= CArray->getSize().getZExtValue();
2566         FQT = CArray->getElementType();
2567       }
2568       if (FQT->isRecordType() && ElCount) {
2569         int OldIndex = RunSkipBlockVars.size() - 1;
2570         auto *RT = FQT->castAs<RecordType>();
2571         BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset, HasUnion);
2572 
2573         // Replicate layout information for each array element. Note that
2574         // one element is already done.
2575         uint64_t ElIx = 1;
2576         for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2577           CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2578           for (int i = OldIndex+1; i <= FirstIndex; ++i)
2579             RunSkipBlockVars.push_back(
2580               RUN_SKIP(RunSkipBlockVars[i].opcode,
2581               RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2582               RunSkipBlockVars[i].block_var_size));
2583         }
2584         continue;
2585       }
2586     }
2587     CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2588     if (IsUnion) {
2589       CharUnits UnionIvarSize = FieldSize;
2590       if (UnionIvarSize > MaxUnionSize) {
2591         MaxUnionSize = UnionIvarSize;
2592         MaxField = Field;
2593         MaxFieldOffset = FieldOffset;
2594       }
2595     } else {
2596       UpdateRunSkipBlockVars(false,
2597                              getBlockCaptureLifetime(FQT, ByrefLayout),
2598                              BytePos + FieldOffset,
2599                              FieldSize);
2600     }
2601   }
2602 
2603   if (LastFieldBitfieldOrUnnamed) {
2604     if (LastFieldBitfieldOrUnnamed->isBitField()) {
2605       // Last field was a bitfield. Must update the info.
2606       uint64_t BitFieldSize
2607         = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2608       unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2609                         ((BitFieldSize % ByteSizeInBits) != 0);
2610       CharUnits Size = CharUnits::fromQuantity(UnsSize);
2611       Size += LastBitfieldOrUnnamedOffset;
2612       UpdateRunSkipBlockVars(false,
2613                              getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2614                                                      ByrefLayout),
2615                              BytePos + LastBitfieldOrUnnamedOffset,
2616                              Size);
2617     } else {
2618       assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2619       // Last field was unnamed. Must update skip info.
2620       CharUnits FieldSize
2621         = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2622       UpdateRunSkipBlockVars(false,
2623                              getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2624                                                      ByrefLayout),
2625                              BytePos + LastBitfieldOrUnnamedOffset,
2626                              FieldSize);
2627     }
2628   }
2629 
2630   if (MaxField)
2631     UpdateRunSkipBlockVars(false,
2632                            getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2633                            BytePos + MaxFieldOffset,
2634                            MaxUnionSize);
2635 }
2636 
2637 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2638                                                   CharUnits BytePos,
2639                                                   bool &HasUnion,
2640                                                   bool ByrefLayout) {
2641   const RecordDecl *RD = RT->getDecl();
2642   SmallVector<const FieldDecl*, 16> Fields(RD->fields());
2643   llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2644   const llvm::StructLayout *RecLayout =
2645     CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2646 
2647   BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2648 }
2649 
2650 /// InlineLayoutInstruction - This routine produce an inline instruction for the
2651 /// block variable layout if it can. If not, it returns 0. Rules are as follow:
2652 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2653 /// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2654 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2655 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2656 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2657 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2658 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2659 uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2660                                     SmallVectorImpl<unsigned char> &Layout) {
2661   uint64_t Result = 0;
2662   if (Layout.size() <= 3) {
2663     unsigned size = Layout.size();
2664     unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2665     unsigned char inst;
2666     enum BLOCK_LAYOUT_OPCODE opcode ;
2667     switch (size) {
2668       case 3:
2669         inst = Layout[0];
2670         opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2671         if (opcode == BLOCK_LAYOUT_STRONG)
2672           strong_word_count = (inst & 0xF)+1;
2673         else
2674           return 0;
2675         inst = Layout[1];
2676         opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2677         if (opcode == BLOCK_LAYOUT_BYREF)
2678           byref_word_count = (inst & 0xF)+1;
2679         else
2680           return 0;
2681         inst = Layout[2];
2682         opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2683         if (opcode == BLOCK_LAYOUT_WEAK)
2684           weak_word_count = (inst & 0xF)+1;
2685         else
2686           return 0;
2687         break;
2688 
2689       case 2:
2690         inst = Layout[0];
2691         opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2692         if (opcode == BLOCK_LAYOUT_STRONG) {
2693           strong_word_count = (inst & 0xF)+1;
2694           inst = Layout[1];
2695           opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2696           if (opcode == BLOCK_LAYOUT_BYREF)
2697             byref_word_count = (inst & 0xF)+1;
2698           else if (opcode == BLOCK_LAYOUT_WEAK)
2699             weak_word_count = (inst & 0xF)+1;
2700           else
2701             return 0;
2702         }
2703         else if (opcode == BLOCK_LAYOUT_BYREF) {
2704           byref_word_count = (inst & 0xF)+1;
2705           inst = Layout[1];
2706           opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2707           if (opcode == BLOCK_LAYOUT_WEAK)
2708             weak_word_count = (inst & 0xF)+1;
2709           else
2710             return 0;
2711         }
2712         else
2713           return 0;
2714         break;
2715 
2716       case 1:
2717         inst = Layout[0];
2718         opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2719         if (opcode == BLOCK_LAYOUT_STRONG)
2720           strong_word_count = (inst & 0xF)+1;
2721         else if (opcode == BLOCK_LAYOUT_BYREF)
2722           byref_word_count = (inst & 0xF)+1;
2723         else if (opcode == BLOCK_LAYOUT_WEAK)
2724           weak_word_count = (inst & 0xF)+1;
2725         else
2726           return 0;
2727         break;
2728 
2729       default:
2730         return 0;
2731     }
2732 
2733     // Cannot inline when any of the word counts is 15. Because this is one less
2734     // than the actual work count (so 15 means 16 actual word counts),
2735     // and we can only display 0 thru 15 word counts.
2736     if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2737       return 0;
2738 
2739     unsigned count =
2740       (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2741 
2742     if (size == count) {
2743       if (strong_word_count)
2744         Result = strong_word_count;
2745       Result <<= 4;
2746       if (byref_word_count)
2747         Result += byref_word_count;
2748       Result <<= 4;
2749       if (weak_word_count)
2750         Result += weak_word_count;
2751     }
2752   }
2753   return Result;
2754 }
2755 
2756 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2757   llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2758   if (RunSkipBlockVars.empty())
2759     return nullPtr;
2760   unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2761   unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2762   unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2763 
2764   // Sort on byte position; captures might not be allocated in order,
2765   // and unions can do funny things.
2766   llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2767   SmallVector<unsigned char, 16> Layout;
2768 
2769   unsigned size = RunSkipBlockVars.size();
2770   for (unsigned i = 0; i < size; i++) {
2771     enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2772     CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2773     CharUnits end_byte_pos = start_byte_pos;
2774     unsigned j = i+1;
2775     while (j < size) {
2776       if (opcode == RunSkipBlockVars[j].opcode) {
2777         end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2778         i++;
2779       }
2780       else
2781         break;
2782     }
2783     CharUnits size_in_bytes =
2784     end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2785     if (j < size) {
2786       CharUnits gap =
2787       RunSkipBlockVars[j].block_var_bytepos -
2788       RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2789       size_in_bytes += gap;
2790     }
2791     CharUnits residue_in_bytes = CharUnits::Zero();
2792     if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2793       residue_in_bytes = size_in_bytes % WordSizeInBytes;
2794       size_in_bytes -= residue_in_bytes;
2795       opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2796     }
2797 
2798     unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2799     while (size_in_words >= 16) {
2800       // Note that value in imm. is one less that the actual
2801       // value. So, 0xf means 16 words follow!
2802       unsigned char inst = (opcode << 4) | 0xf;
2803       Layout.push_back(inst);
2804       size_in_words -= 16;
2805     }
2806     if (size_in_words > 0) {
2807       // Note that value in imm. is one less that the actual
2808       // value. So, we subtract 1 away!
2809       unsigned char inst = (opcode << 4) | (size_in_words-1);
2810       Layout.push_back(inst);
2811     }
2812     if (residue_in_bytes > CharUnits::Zero()) {
2813       unsigned char inst =
2814       (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2815       Layout.push_back(inst);
2816     }
2817   }
2818 
2819   while (!Layout.empty()) {
2820     unsigned char inst = Layout.back();
2821     enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2822     if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2823       Layout.pop_back();
2824     else
2825       break;
2826   }
2827 
2828   uint64_t Result = InlineLayoutInstruction(Layout);
2829   if (Result != 0) {
2830     // Block variable layout instruction has been inlined.
2831     if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2832       if (ComputeByrefLayout)
2833         printf("\n Inline BYREF variable layout: ");
2834       else
2835         printf("\n Inline block variable layout: ");
2836       printf("0x0%" PRIx64 "", Result);
2837       if (auto numStrong = (Result & 0xF00) >> 8)
2838         printf(", BL_STRONG:%d", (int) numStrong);
2839       if (auto numByref = (Result & 0x0F0) >> 4)
2840         printf(", BL_BYREF:%d", (int) numByref);
2841       if (auto numWeak = (Result & 0x00F) >> 0)
2842         printf(", BL_WEAK:%d", (int) numWeak);
2843       printf(", BL_OPERATOR:0\n");
2844     }
2845     return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2846   }
2847 
2848   unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2849   Layout.push_back(inst);
2850   std::string BitMap;
2851   for (unsigned i = 0, e = Layout.size(); i != e; i++)
2852     BitMap += Layout[i];
2853 
2854   if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2855     if (ComputeByrefLayout)
2856       printf("\n Byref variable layout: ");
2857     else
2858       printf("\n Block variable layout: ");
2859     for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2860       unsigned char inst = BitMap[i];
2861       enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2862       unsigned delta = 1;
2863       switch (opcode) {
2864         case BLOCK_LAYOUT_OPERATOR:
2865           printf("BL_OPERATOR:");
2866           delta = 0;
2867           break;
2868         case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2869           printf("BL_NON_OBJECT_BYTES:");
2870           break;
2871         case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2872           printf("BL_NON_OBJECT_WORD:");
2873           break;
2874         case BLOCK_LAYOUT_STRONG:
2875           printf("BL_STRONG:");
2876           break;
2877         case BLOCK_LAYOUT_BYREF:
2878           printf("BL_BYREF:");
2879           break;
2880         case BLOCK_LAYOUT_WEAK:
2881           printf("BL_WEAK:");
2882           break;
2883         case BLOCK_LAYOUT_UNRETAINED:
2884           printf("BL_UNRETAINED:");
2885           break;
2886       }
2887       // Actual value of word count is one more that what is in the imm.
2888       // field of the instruction
2889       printf("%d", (inst & 0xf) + delta);
2890       if (i < e-1)
2891         printf(", ");
2892       else
2893         printf("\n");
2894     }
2895   }
2896 
2897   auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
2898                                      /*ForceNonFragileABI=*/true,
2899                                      /*NullTerminate=*/false);
2900   return getConstantGEP(VMContext, Entry, 0, 0);
2901 }
2902 
2903 static std::string getBlockLayoutInfoString(
2904     const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars,
2905     bool HasCopyDisposeHelpers) {
2906   std::string Str;
2907   for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) {
2908     if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) {
2909       // Copy/dispose helpers don't have any information about
2910       // __unsafe_unretained captures, so unconditionally concatenate a string.
2911       Str += "u";
2912     } else if (HasCopyDisposeHelpers) {
2913       // Information about __strong, __weak, or byref captures has already been
2914       // encoded into the names of the copy/dispose helpers. We have to add a
2915       // string here only when the copy/dispose helpers aren't generated (which
2916       // happens when the block is non-escaping).
2917       continue;
2918     } else {
2919       switch (R.opcode) {
2920       case CGObjCCommonMac::BLOCK_LAYOUT_STRONG:
2921         Str += "s";
2922         break;
2923       case CGObjCCommonMac::BLOCK_LAYOUT_BYREF:
2924         Str += "r";
2925         break;
2926       case CGObjCCommonMac::BLOCK_LAYOUT_WEAK:
2927         Str += "w";
2928         break;
2929       default:
2930         continue;
2931       }
2932     }
2933     Str += llvm::to_string(R.block_var_bytepos.getQuantity());
2934     Str += "l" + llvm::to_string(R.block_var_size.getQuantity());
2935   }
2936   return Str;
2937 }
2938 
2939 void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM,
2940                                            const CGBlockInfo &blockInfo) {
2941   assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2942 
2943   RunSkipBlockVars.clear();
2944   bool hasUnion = false;
2945 
2946   unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2947   unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2948   unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2949 
2950   const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2951 
2952   // Calculate the basic layout of the block structure.
2953   const llvm::StructLayout *layout =
2954   CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2955 
2956   // Ignore the optional 'this' capture: C++ objects are not assumed
2957   // to be GC'ed.
2958   if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2959     UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2960                            blockInfo.BlockHeaderForcedGapOffset,
2961                            blockInfo.BlockHeaderForcedGapSize);
2962   // Walk the captured variables.
2963   for (const auto &CI : blockDecl->captures()) {
2964     const VarDecl *variable = CI.getVariable();
2965     QualType type = variable->getType();
2966 
2967     const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2968 
2969     // Ignore constant captures.
2970     if (capture.isConstant()) continue;
2971 
2972     CharUnits fieldOffset =
2973        CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2974 
2975     assert(!type->isArrayType() && "array variable should not be caught");
2976     if (!CI.isByRef())
2977       if (const RecordType *record = type->getAs<RecordType>()) {
2978         BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2979         continue;
2980       }
2981     CharUnits fieldSize;
2982     if (CI.isByRef())
2983       fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2984     else
2985       fieldSize = CGM.getContext().getTypeSizeInChars(type);
2986     UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2987                            fieldOffset, fieldSize);
2988   }
2989 }
2990 
2991 llvm::Constant *
2992 CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2993                                     const CGBlockInfo &blockInfo) {
2994   fillRunSkipBlockVars(CGM, blockInfo);
2995   return getBitmapBlockLayout(false);
2996 }
2997 
2998 std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM,
2999                                                  const CGBlockInfo &blockInfo) {
3000   fillRunSkipBlockVars(CGM, blockInfo);
3001   return getBlockLayoutInfoString(RunSkipBlockVars,
3002                                   blockInfo.needsCopyDisposeHelpers());
3003 }
3004 
3005 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
3006                                                   QualType T) {
3007   assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3008   assert(!T->isArrayType() && "__block array variable should not be caught");
3009   CharUnits fieldOffset;
3010   RunSkipBlockVars.clear();
3011   bool hasUnion = false;
3012   if (const RecordType *record = T->getAs<RecordType>()) {
3013     BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
3014     llvm::Constant *Result = getBitmapBlockLayout(true);
3015     if (isa<llvm::ConstantInt>(Result))
3016       Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
3017     return Result;
3018   }
3019   llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
3020   return nullPtr;
3021 }
3022 
3023 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
3024                                             const ObjCProtocolDecl *PD) {
3025   // FIXME: I don't understand why gcc generates this, or where it is
3026   // resolved. Investigate. Its also wasteful to look this up over and over.
3027   LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3028 
3029   return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
3030                                         ObjCTypes.getExternalProtocolPtrTy());
3031 }
3032 
3033 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
3034   // FIXME: We shouldn't need this, the protocol decl should contain enough
3035   // information to tell us whether this was a declaration or a definition.
3036   DefinedProtocols.insert(PD->getIdentifier());
3037 
3038   // If we have generated a forward reference to this protocol, emit
3039   // it now. Otherwise do nothing, the protocol objects are lazily
3040   // emitted.
3041   if (Protocols.count(PD->getIdentifier()))
3042     GetOrEmitProtocol(PD);
3043 }
3044 
3045 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
3046   if (DefinedProtocols.count(PD->getIdentifier()))
3047     return GetOrEmitProtocol(PD);
3048 
3049   return GetOrEmitProtocolRef(PD);
3050 }
3051 
3052 llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
3053                CodeGenFunction &CGF,
3054                const ObjCInterfaceDecl *ID,
3055                ObjCCommonTypesHelper &ObjCTypes) {
3056   llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn();
3057 
3058   llvm::Value *className = CGF.CGM
3059                                .GetAddrOfConstantCString(std::string(
3060                                    ID->getObjCRuntimeNameAsString()))
3061                                .getPointer();
3062   ASTContext &ctx = CGF.CGM.getContext();
3063   className =
3064       CGF.Builder.CreateBitCast(className,
3065                                 CGF.ConvertType(
3066                                   ctx.getPointerType(ctx.CharTy.withConst())));
3067   llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
3068   call->setDoesNotThrow();
3069   return call;
3070 }
3071 
3072 /*
3073 // Objective-C 1.0 extensions
3074 struct _objc_protocol {
3075 struct _objc_protocol_extension *isa;
3076 char *protocol_name;
3077 struct _objc_protocol_list *protocol_list;
3078 struct _objc__method_prototype_list *instance_methods;
3079 struct _objc__method_prototype_list *class_methods
3080 };
3081 
3082 See EmitProtocolExtension().
3083 */
3084 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
3085   llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
3086 
3087   // Early exit if a defining object has already been generated.
3088   if (Entry && Entry->hasInitializer())
3089     return Entry;
3090 
3091   // Use the protocol definition, if there is one.
3092   if (const ObjCProtocolDecl *Def = PD->getDefinition())
3093     PD = Def;
3094 
3095   // FIXME: I don't understand why gcc generates this, or where it is
3096   // resolved. Investigate. Its also wasteful to look this up over and over.
3097   LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3098 
3099   // Construct method lists.
3100   auto methodLists = ProtocolMethodLists::get(PD);
3101 
3102   ConstantInitBuilder builder(CGM);
3103   auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
3104   values.add(EmitProtocolExtension(PD, methodLists));
3105   values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
3106   values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
3107                               PD->protocol_begin(), PD->protocol_end()));
3108   values.add(methodLists.emitMethodList(this, PD,
3109                               ProtocolMethodLists::RequiredInstanceMethods));
3110   values.add(methodLists.emitMethodList(this, PD,
3111                               ProtocolMethodLists::RequiredClassMethods));
3112 
3113   if (Entry) {
3114     // Already created, update the initializer.
3115     assert(Entry->hasPrivateLinkage());
3116     values.finishAndSetAsInitializer(Entry);
3117   } else {
3118     Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
3119                                          CGM.getPointerAlign(),
3120                                          /*constant*/ false,
3121                                          llvm::GlobalValue::PrivateLinkage);
3122     Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3123 
3124     Protocols[PD->getIdentifier()] = Entry;
3125   }
3126   CGM.addCompilerUsedGlobal(Entry);
3127 
3128   return Entry;
3129 }
3130 
3131 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
3132   llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
3133 
3134   if (!Entry) {
3135     // We use the initializer as a marker of whether this is a forward
3136     // reference or not. At module finalization we add the empty
3137     // contents for protocols which were referenced but never defined.
3138     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
3139                                      false, llvm::GlobalValue::PrivateLinkage,
3140                                      nullptr, "OBJC_PROTOCOL_" + PD->getName());
3141     Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3142     // FIXME: Is this necessary? Why only for protocol?
3143     Entry->setAlignment(llvm::Align(4));
3144   }
3145 
3146   return Entry;
3147 }
3148 
3149 /*
3150   struct _objc_protocol_extension {
3151   uint32_t size;
3152   struct objc_method_description_list *optional_instance_methods;
3153   struct objc_method_description_list *optional_class_methods;
3154   struct objc_property_list *instance_properties;
3155   const char ** extendedMethodTypes;
3156   struct objc_property_list *class_properties;
3157   };
3158 */
3159 llvm::Constant *
3160 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
3161                                  const ProtocolMethodLists &methodLists) {
3162   auto optInstanceMethods =
3163     methodLists.emitMethodList(this, PD,
3164                                ProtocolMethodLists::OptionalInstanceMethods);
3165   auto optClassMethods =
3166     methodLists.emitMethodList(this, PD,
3167                                ProtocolMethodLists::OptionalClassMethods);
3168 
3169   auto extendedMethodTypes =
3170     EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3171                             methodLists.emitExtendedTypesArray(this),
3172                             ObjCTypes);
3173 
3174   auto instanceProperties =
3175     EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3176                      ObjCTypes, false);
3177   auto classProperties =
3178     EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3179                      PD, ObjCTypes, true);
3180 
3181   // Return null if no extension bits are used.
3182   if (optInstanceMethods->isNullValue() &&
3183       optClassMethods->isNullValue() &&
3184       extendedMethodTypes->isNullValue() &&
3185       instanceProperties->isNullValue() &&
3186       classProperties->isNullValue()) {
3187     return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3188   }
3189 
3190   uint64_t size =
3191     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3192 
3193   ConstantInitBuilder builder(CGM);
3194   auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3195   values.addInt(ObjCTypes.IntTy, size);
3196   values.add(optInstanceMethods);
3197   values.add(optClassMethods);
3198   values.add(instanceProperties);
3199   values.add(extendedMethodTypes);
3200   values.add(classProperties);
3201 
3202   // No special section, but goes in llvm.used
3203   return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3204                            StringRef(), CGM.getPointerAlign(), true);
3205 }
3206 
3207 /*
3208   struct objc_protocol_list {
3209     struct objc_protocol_list *next;
3210     long count;
3211     Protocol *list[];
3212   };
3213 */
3214 llvm::Constant *
3215 CGObjCMac::EmitProtocolList(Twine name,
3216                             ObjCProtocolDecl::protocol_iterator begin,
3217                             ObjCProtocolDecl::protocol_iterator end) {
3218   // Just return null for empty protocol lists
3219   auto PDs = GetRuntimeProtocolList(begin, end);
3220   if (PDs.empty())
3221     return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3222 
3223   ConstantInitBuilder builder(CGM);
3224   auto values = builder.beginStruct();
3225 
3226   // This field is only used by the runtime.
3227   values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3228 
3229   // Reserve a slot for the count.
3230   auto countSlot = values.addPlaceholder();
3231 
3232   auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3233   for (const auto *Proto : PDs)
3234     refsArray.add(GetProtocolRef(Proto));
3235 
3236   auto count = refsArray.size();
3237 
3238   // This list is null terminated.
3239   refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3240 
3241   refsArray.finishAndAddTo(values);
3242   values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3243 
3244   StringRef section;
3245   if (CGM.getTriple().isOSBinFormatMachO())
3246     section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3247 
3248   llvm::GlobalVariable *GV =
3249       CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3250   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3251 }
3252 
3253 static void
3254 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
3255                        SmallVectorImpl<const ObjCPropertyDecl *> &Properties,
3256                        const ObjCProtocolDecl *Proto,
3257                        bool IsClassProperty) {
3258   for (const auto *PD : Proto->properties()) {
3259     if (IsClassProperty != PD->isClassProperty())
3260       continue;
3261     if (!PropertySet.insert(PD->getIdentifier()).second)
3262       continue;
3263     Properties.push_back(PD);
3264   }
3265 
3266   for (const auto *P : Proto->protocols())
3267     PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3268 }
3269 
3270 /*
3271   struct _objc_property {
3272     const char * const name;
3273     const char * const attributes;
3274   };
3275 
3276   struct _objc_property_list {
3277     uint32_t entsize; // sizeof (struct _objc_property)
3278     uint32_t prop_count;
3279     struct _objc_property[prop_count];
3280   };
3281 */
3282 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3283                                        const Decl *Container,
3284                                        const ObjCContainerDecl *OCD,
3285                                        const ObjCCommonTypesHelper &ObjCTypes,
3286                                        bool IsClassProperty) {
3287   if (IsClassProperty) {
3288     // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3289     // with deployment target < 9.0.
3290     const llvm::Triple &Triple = CGM.getTarget().getTriple();
3291     if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
3292         (Triple.isiOS() && Triple.isOSVersionLT(9)))
3293       return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3294   }
3295 
3296   SmallVector<const ObjCPropertyDecl *, 16> Properties;
3297   llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3298 
3299   if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3300     for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3301       for (auto *PD : ClassExt->properties()) {
3302         if (IsClassProperty != PD->isClassProperty())
3303           continue;
3304         if (PD->isDirectProperty())
3305           continue;
3306         PropertySet.insert(PD->getIdentifier());
3307         Properties.push_back(PD);
3308       }
3309 
3310   for (const auto *PD : OCD->properties()) {
3311     if (IsClassProperty != PD->isClassProperty())
3312       continue;
3313     // Don't emit duplicate metadata for properties that were already in a
3314     // class extension.
3315     if (!PropertySet.insert(PD->getIdentifier()).second)
3316       continue;
3317     if (PD->isDirectProperty())
3318       continue;
3319     Properties.push_back(PD);
3320   }
3321 
3322   if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3323     for (const auto *P : OID->all_referenced_protocols())
3324       PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3325   }
3326   else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3327     for (const auto *P : CD->protocols())
3328       PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3329   }
3330 
3331   // Return null for empty list.
3332   if (Properties.empty())
3333     return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3334 
3335   unsigned propertySize =
3336     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3337 
3338   ConstantInitBuilder builder(CGM);
3339   auto values = builder.beginStruct();
3340   values.addInt(ObjCTypes.IntTy, propertySize);
3341   values.addInt(ObjCTypes.IntTy, Properties.size());
3342   auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3343   for (auto PD : Properties) {
3344     auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3345     property.add(GetPropertyName(PD->getIdentifier()));
3346     property.add(GetPropertyTypeString(PD, Container));
3347     property.finishAndAddTo(propertiesArray);
3348   }
3349   propertiesArray.finishAndAddTo(values);
3350 
3351   StringRef Section;
3352   if (CGM.getTriple().isOSBinFormatMachO())
3353     Section = (ObjCABI == 2) ? "__DATA, __objc_const"
3354                              : "__OBJC,__property,regular,no_dead_strip";
3355 
3356   llvm::GlobalVariable *GV =
3357       CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3358   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3359 }
3360 
3361 llvm::Constant *
3362 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3363                                          ArrayRef<llvm::Constant*> MethodTypes,
3364                                          const ObjCCommonTypesHelper &ObjCTypes) {
3365   // Return null for empty list.
3366   if (MethodTypes.empty())
3367     return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3368 
3369   llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3370                                              MethodTypes.size());
3371   llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3372 
3373   StringRef Section;
3374   if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
3375     Section = "__DATA, __objc_const";
3376 
3377   llvm::GlobalVariable *GV =
3378       CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3379   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3380 }
3381 
3382 /*
3383   struct _objc_category {
3384   char *category_name;
3385   char *class_name;
3386   struct _objc_method_list *instance_methods;
3387   struct _objc_method_list *class_methods;
3388   struct _objc_protocol_list *protocols;
3389   uint32_t size; // <rdar://4585769>
3390   struct _objc_property_list *instance_properties;
3391   struct _objc_property_list *class_properties;
3392   };
3393 */
3394 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3395   unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3396 
3397   // FIXME: This is poor design, the OCD should have a pointer to the category
3398   // decl. Additionally, note that Category can be null for the @implementation
3399   // w/o an @interface case. Sema should just create one for us as it does for
3400   // @implementation so everyone else can live life under a clear blue sky.
3401   const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3402   const ObjCCategoryDecl *Category =
3403     Interface->FindCategoryDeclaration(OCD->getIdentifier());
3404 
3405   SmallString<256> ExtName;
3406   llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3407                                      << OCD->getName();
3408 
3409   ConstantInitBuilder Builder(CGM);
3410   auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3411 
3412   enum {
3413     InstanceMethods,
3414     ClassMethods,
3415     NumMethodLists
3416   };
3417   SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3418   for (const auto *MD : OCD->methods()) {
3419     if (!MD->isDirectMethod())
3420       Methods[unsigned(MD->isClassMethod())].push_back(MD);
3421   }
3422 
3423   Values.add(GetClassName(OCD->getName()));
3424   Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3425   LazySymbols.insert(Interface->getIdentifier());
3426 
3427   Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3428                             Methods[InstanceMethods]));
3429   Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3430                             Methods[ClassMethods]));
3431   if (Category) {
3432     Values.add(
3433         EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3434                          Category->protocol_begin(), Category->protocol_end()));
3435   } else {
3436     Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3437   }
3438   Values.addInt(ObjCTypes.IntTy, Size);
3439 
3440   // If there is no category @interface then there can be no properties.
3441   if (Category) {
3442     Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
3443                                 OCD, Category, ObjCTypes, false));
3444     Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3445                                 OCD, Category, ObjCTypes, true));
3446   } else {
3447     Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3448     Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3449   }
3450 
3451   llvm::GlobalVariable *GV =
3452       CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3453                         "__OBJC,__category,regular,no_dead_strip",
3454                         CGM.getPointerAlign(), true);
3455   DefinedCategories.push_back(GV);
3456   DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3457   // method definition entries must be clear for next implementation.
3458   MethodDefinitions.clear();
3459 }
3460 
3461 enum FragileClassFlags {
3462   /// Apparently: is not a meta-class.
3463   FragileABI_Class_Factory                 = 0x00001,
3464 
3465   /// Is a meta-class.
3466   FragileABI_Class_Meta                    = 0x00002,
3467 
3468   /// Has a non-trivial constructor or destructor.
3469   FragileABI_Class_HasCXXStructors         = 0x02000,
3470 
3471   /// Has hidden visibility.
3472   FragileABI_Class_Hidden                  = 0x20000,
3473 
3474   /// Class implementation was compiled under ARC.
3475   FragileABI_Class_CompiledByARC           = 0x04000000,
3476 
3477   /// Class implementation was compiled under MRC and has MRC weak ivars.
3478   /// Exclusive with CompiledByARC.
3479   FragileABI_Class_HasMRCWeakIvars         = 0x08000000,
3480 };
3481 
3482 enum NonFragileClassFlags {
3483   /// Is a meta-class.
3484   NonFragileABI_Class_Meta                 = 0x00001,
3485 
3486   /// Is a root class.
3487   NonFragileABI_Class_Root                 = 0x00002,
3488 
3489   /// Has a non-trivial constructor or destructor.
3490   NonFragileABI_Class_HasCXXStructors      = 0x00004,
3491 
3492   /// Has hidden visibility.
3493   NonFragileABI_Class_Hidden               = 0x00010,
3494 
3495   /// Has the exception attribute.
3496   NonFragileABI_Class_Exception            = 0x00020,
3497 
3498   /// (Obsolete) ARC-specific: this class has a .release_ivars method
3499   NonFragileABI_Class_HasIvarReleaser      = 0x00040,
3500 
3501   /// Class implementation was compiled under ARC.
3502   NonFragileABI_Class_CompiledByARC        = 0x00080,
3503 
3504   /// Class has non-trivial destructors, but zero-initialization is okay.
3505   NonFragileABI_Class_HasCXXDestructorOnly = 0x00100,
3506 
3507   /// Class implementation was compiled under MRC and has MRC weak ivars.
3508   /// Exclusive with CompiledByARC.
3509   NonFragileABI_Class_HasMRCWeakIvars      = 0x00200,
3510 };
3511 
3512 static bool hasWeakMember(QualType type) {
3513   if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3514     return true;
3515   }
3516 
3517   if (auto recType = type->getAs<RecordType>()) {
3518     for (auto field : recType->getDecl()->fields()) {
3519       if (hasWeakMember(field->getType()))
3520         return true;
3521     }
3522   }
3523 
3524   return false;
3525 }
3526 
3527 /// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3528 /// (and actually fill in a layout string) if we really do have any
3529 /// __weak ivars.
3530 static bool hasMRCWeakIvars(CodeGenModule &CGM,
3531                             const ObjCImplementationDecl *ID) {
3532   if (!CGM.getLangOpts().ObjCWeak) return false;
3533   assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3534 
3535   for (const ObjCIvarDecl *ivar =
3536          ID->getClassInterface()->all_declared_ivar_begin();
3537        ivar; ivar = ivar->getNextIvar()) {
3538     if (hasWeakMember(ivar->getType()))
3539       return true;
3540   }
3541 
3542   return false;
3543 }
3544 
3545 /*
3546   struct _objc_class {
3547   Class isa;
3548   Class super_class;
3549   const char *name;
3550   long version;
3551   long info;
3552   long instance_size;
3553   struct _objc_ivar_list *ivars;
3554   struct _objc_method_list *methods;
3555   struct _objc_cache *cache;
3556   struct _objc_protocol_list *protocols;
3557   // Objective-C 1.0 extensions (<rdr://4585769>)
3558   const char *ivar_layout;
3559   struct _objc_class_ext *ext;
3560   };
3561 
3562   See EmitClassExtension();
3563 */
3564 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3565   IdentifierInfo *RuntimeName =
3566       &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
3567   DefinedSymbols.insert(RuntimeName);
3568 
3569   std::string ClassName = ID->getNameAsString();
3570   // FIXME: Gross
3571   ObjCInterfaceDecl *Interface =
3572     const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3573   llvm::Constant *Protocols =
3574       EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3575                        Interface->all_referenced_protocol_begin(),
3576                        Interface->all_referenced_protocol_end());
3577   unsigned Flags = FragileABI_Class_Factory;
3578   if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3579     Flags |= FragileABI_Class_HasCXXStructors;
3580 
3581   bool hasMRCWeak = false;
3582 
3583   if (CGM.getLangOpts().ObjCAutoRefCount)
3584     Flags |= FragileABI_Class_CompiledByARC;
3585   else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3586     Flags |= FragileABI_Class_HasMRCWeakIvars;
3587 
3588   CharUnits Size =
3589     CGM.getContext().getASTObjCImplementationLayout(ID).getSize();
3590 
3591   // FIXME: Set CXX-structors flag.
3592   if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3593     Flags |= FragileABI_Class_Hidden;
3594 
3595   enum {
3596     InstanceMethods,
3597     ClassMethods,
3598     NumMethodLists
3599   };
3600   SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3601   for (const auto *MD : ID->methods()) {
3602     if (!MD->isDirectMethod())
3603       Methods[unsigned(MD->isClassMethod())].push_back(MD);
3604   }
3605 
3606   for (const auto *PID : ID->property_impls()) {
3607     if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3608       if (PID->getPropertyDecl()->isDirectProperty())
3609         continue;
3610       if (ObjCMethodDecl *MD = PID->getGetterMethodDecl())
3611         if (GetMethodDefinition(MD))
3612           Methods[InstanceMethods].push_back(MD);
3613       if (ObjCMethodDecl *MD = PID->getSetterMethodDecl())
3614         if (GetMethodDefinition(MD))
3615           Methods[InstanceMethods].push_back(MD);
3616     }
3617   }
3618 
3619   ConstantInitBuilder builder(CGM);
3620   auto values = builder.beginStruct(ObjCTypes.ClassTy);
3621   values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3622   if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3623     // Record a reference to the super class.
3624     LazySymbols.insert(Super->getIdentifier());
3625 
3626     values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3627                       ObjCTypes.ClassPtrTy);
3628   } else {
3629     values.addNullPointer(ObjCTypes.ClassPtrTy);
3630   }
3631   values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3632   // Version is always 0.
3633   values.addInt(ObjCTypes.LongTy, 0);
3634   values.addInt(ObjCTypes.LongTy, Flags);
3635   values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3636   values.add(EmitIvarList(ID, false));
3637   values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3638                             Methods[InstanceMethods]));
3639   // cache is always NULL.
3640   values.addNullPointer(ObjCTypes.CachePtrTy);
3641   values.add(Protocols);
3642   values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3643   values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3644                                 /*isMetaclass*/ false));
3645 
3646   std::string Name("OBJC_CLASS_");
3647   Name += ClassName;
3648   const char *Section = "__OBJC,__class,regular,no_dead_strip";
3649   // Check for a forward reference.
3650   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3651   if (GV) {
3652     assert(GV->getValueType() == ObjCTypes.ClassTy &&
3653            "Forward metaclass reference has incorrect type.");
3654     values.finishAndSetAsInitializer(GV);
3655     GV->setSection(Section);
3656     GV->setAlignment(CGM.getPointerAlign().getAsAlign());
3657     CGM.addCompilerUsedGlobal(GV);
3658   } else
3659     GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3660   DefinedClasses.push_back(GV);
3661   ImplementedClasses.push_back(Interface);
3662   // method definition entries must be clear for next implementation.
3663   MethodDefinitions.clear();
3664 }
3665 
3666 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3667                                          llvm::Constant *Protocols,
3668                                 ArrayRef<const ObjCMethodDecl*> Methods) {
3669   unsigned Flags = FragileABI_Class_Meta;
3670   unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3671 
3672   if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3673     Flags |= FragileABI_Class_Hidden;
3674 
3675   ConstantInitBuilder builder(CGM);
3676   auto values = builder.beginStruct(ObjCTypes.ClassTy);
3677   // The isa for the metaclass is the root of the hierarchy.
3678   const ObjCInterfaceDecl *Root = ID->getClassInterface();
3679   while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3680     Root = Super;
3681   values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3682                     ObjCTypes.ClassPtrTy);
3683   // The super class for the metaclass is emitted as the name of the
3684   // super class. The runtime fixes this up to point to the
3685   // *metaclass* for the super class.
3686   if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3687     values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3688                       ObjCTypes.ClassPtrTy);
3689   } else {
3690     values.addNullPointer(ObjCTypes.ClassPtrTy);
3691   }
3692   values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3693   // Version is always 0.
3694   values.addInt(ObjCTypes.LongTy, 0);
3695   values.addInt(ObjCTypes.LongTy, Flags);
3696   values.addInt(ObjCTypes.LongTy, Size);
3697   values.add(EmitIvarList(ID, true));
3698   values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3699                             Methods));
3700   // cache is always NULL.
3701   values.addNullPointer(ObjCTypes.CachePtrTy);
3702   values.add(Protocols);
3703   // ivar_layout for metaclass is always NULL.
3704   values.addNullPointer(ObjCTypes.Int8PtrTy);
3705   // The class extension is used to store class properties for metaclasses.
3706   values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3707                                 /*isMetaclass*/true));
3708 
3709   std::string Name("OBJC_METACLASS_");
3710   Name += ID->getName();
3711 
3712   // Check for a forward reference.
3713   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3714   if (GV) {
3715     assert(GV->getValueType() == ObjCTypes.ClassTy &&
3716            "Forward metaclass reference has incorrect type.");
3717     values.finishAndSetAsInitializer(GV);
3718   } else {
3719     GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3720                                       /*constant*/ false,
3721                                       llvm::GlobalValue::PrivateLinkage);
3722   }
3723   GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3724   CGM.addCompilerUsedGlobal(GV);
3725 
3726   return GV;
3727 }
3728 
3729 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3730   std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3731 
3732   // FIXME: Should we look these up somewhere other than the module. Its a bit
3733   // silly since we only generate these while processing an implementation, so
3734   // exactly one pointer would work if know when we entered/exitted an
3735   // implementation block.
3736 
3737   // Check for an existing forward reference.
3738   // Previously, metaclass with internal linkage may have been defined.
3739   // pass 'true' as 2nd argument so it is returned.
3740   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3741   if (!GV)
3742     GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3743                                   llvm::GlobalValue::PrivateLinkage, nullptr,
3744                                   Name);
3745 
3746   assert(GV->getValueType() == ObjCTypes.ClassTy &&
3747          "Forward metaclass reference has incorrect type.");
3748   return GV;
3749 }
3750 
3751 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3752   std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3753   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3754 
3755   if (!GV)
3756     GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3757                                   llvm::GlobalValue::PrivateLinkage, nullptr,
3758                                   Name);
3759 
3760   assert(GV->getValueType() == ObjCTypes.ClassTy &&
3761          "Forward class metadata reference has incorrect type.");
3762   return GV;
3763 }
3764 
3765 /*
3766   Emit a "class extension", which in this specific context means extra
3767   data that doesn't fit in the normal fragile-ABI class structure, and
3768   has nothing to do with the language concept of a class extension.
3769 
3770   struct objc_class_ext {
3771   uint32_t size;
3772   const char *weak_ivar_layout;
3773   struct _objc_property_list *properties;
3774   };
3775 */
3776 llvm::Constant *
3777 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3778                               CharUnits InstanceSize, bool hasMRCWeakIvars,
3779                               bool isMetaclass) {
3780   // Weak ivar layout.
3781   llvm::Constant *layout;
3782   if (isMetaclass) {
3783     layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3784   } else {
3785     layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3786                                  hasMRCWeakIvars);
3787   }
3788 
3789   // Properties.
3790   llvm::Constant *propertyList =
3791     EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_")
3792                                   : Twine("_OBJC_$_PROP_LIST_"))
3793                         + ID->getName(),
3794                      ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3795 
3796   // Return null if no extension bits are used.
3797   if (layout->isNullValue() && propertyList->isNullValue()) {
3798     return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3799   }
3800 
3801   uint64_t size =
3802     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3803 
3804   ConstantInitBuilder builder(CGM);
3805   auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3806   values.addInt(ObjCTypes.IntTy, size);
3807   values.add(layout);
3808   values.add(propertyList);
3809 
3810   return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3811                            "__OBJC,__class_ext,regular,no_dead_strip",
3812                            CGM.getPointerAlign(), true);
3813 }
3814 
3815 /*
3816   struct objc_ivar {
3817     char *ivar_name;
3818     char *ivar_type;
3819     int ivar_offset;
3820   };
3821 
3822   struct objc_ivar_list {
3823     int ivar_count;
3824     struct objc_ivar list[count];
3825   };
3826 */
3827 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3828                                         bool ForClass) {
3829   // When emitting the root class GCC emits ivar entries for the
3830   // actual class structure. It is not clear if we need to follow this
3831   // behavior; for now lets try and get away with not doing it. If so,
3832   // the cleanest solution would be to make up an ObjCInterfaceDecl
3833   // for the class.
3834   if (ForClass)
3835     return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3836 
3837   const ObjCInterfaceDecl *OID = ID->getClassInterface();
3838 
3839   ConstantInitBuilder builder(CGM);
3840   auto ivarList = builder.beginStruct();
3841   auto countSlot = ivarList.addPlaceholder();
3842   auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3843 
3844   for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3845        IVD; IVD = IVD->getNextIvar()) {
3846     // Ignore unnamed bit-fields.
3847     if (!IVD->getDeclName())
3848       continue;
3849 
3850     auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3851     ivar.add(GetMethodVarName(IVD->getIdentifier()));
3852     ivar.add(GetMethodVarType(IVD));
3853     ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3854     ivar.finishAndAddTo(ivars);
3855   }
3856 
3857   // Return null for empty list.
3858   auto count = ivars.size();
3859   if (count == 0) {
3860     ivars.abandon();
3861     ivarList.abandon();
3862     return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3863   }
3864 
3865   ivars.finishAndAddTo(ivarList);
3866   ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3867 
3868   llvm::GlobalVariable *GV;
3869   if (ForClass)
3870     GV =
3871         CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3872                           "__OBJC,__class_vars,regular,no_dead_strip",
3873                           CGM.getPointerAlign(), true);
3874   else
3875     GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3876                            "__OBJC,__instance_vars,regular,no_dead_strip",
3877                            CGM.getPointerAlign(), true);
3878   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3879 }
3880 
3881 /// Build a struct objc_method_description constant for the given method.
3882 ///
3883 /// struct objc_method_description {
3884 ///   SEL method_name;
3885 ///   char *method_types;
3886 /// };
3887 void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3888                                               const ObjCMethodDecl *MD) {
3889   auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3890   description.addBitCast(GetMethodVarName(MD->getSelector()),
3891                          ObjCTypes.SelectorPtrTy);
3892   description.add(GetMethodVarType(MD));
3893   description.finishAndAddTo(builder);
3894 }
3895 
3896 /// Build a struct objc_method constant for the given method.
3897 ///
3898 /// struct objc_method {
3899 ///   SEL method_name;
3900 ///   char *method_types;
3901 ///   void *method;
3902 /// };
3903 void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3904                                    const ObjCMethodDecl *MD) {
3905   llvm::Function *fn = GetMethodDefinition(MD);
3906   assert(fn && "no definition registered for method");
3907 
3908   auto method = builder.beginStruct(ObjCTypes.MethodTy);
3909   method.addBitCast(GetMethodVarName(MD->getSelector()),
3910                     ObjCTypes.SelectorPtrTy);
3911   method.add(GetMethodVarType(MD));
3912   method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3913   method.finishAndAddTo(builder);
3914 }
3915 
3916 /// Build a struct objc_method_list or struct objc_method_description_list,
3917 /// as appropriate.
3918 ///
3919 /// struct objc_method_list {
3920 ///   struct objc_method_list *obsolete;
3921 ///   int count;
3922 ///   struct objc_method methods_list[count];
3923 /// };
3924 ///
3925 /// struct objc_method_description_list {
3926 ///   int count;
3927 ///   struct objc_method_description list[count];
3928 /// };
3929 llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3930                                  ArrayRef<const ObjCMethodDecl *> methods) {
3931   StringRef prefix;
3932   StringRef section;
3933   bool forProtocol = false;
3934   switch (MLT) {
3935   case MethodListType::CategoryInstanceMethods:
3936     prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3937     section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3938     forProtocol = false;
3939     break;
3940   case MethodListType::CategoryClassMethods:
3941     prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3942     section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3943     forProtocol = false;
3944     break;
3945   case MethodListType::InstanceMethods:
3946     prefix = "OBJC_INSTANCE_METHODS_";
3947     section = "__OBJC,__inst_meth,regular,no_dead_strip";
3948     forProtocol = false;
3949     break;
3950   case MethodListType::ClassMethods:
3951     prefix = "OBJC_CLASS_METHODS_";
3952     section = "__OBJC,__cls_meth,regular,no_dead_strip";
3953     forProtocol = false;
3954     break;
3955   case MethodListType::ProtocolInstanceMethods:
3956     prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3957     section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3958     forProtocol = true;
3959     break;
3960   case MethodListType::ProtocolClassMethods:
3961     prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3962     section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3963     forProtocol = true;
3964     break;
3965   case MethodListType::OptionalProtocolInstanceMethods:
3966     prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3967     section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3968     forProtocol = true;
3969     break;
3970   case MethodListType::OptionalProtocolClassMethods:
3971     prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3972     section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3973     forProtocol = true;
3974     break;
3975   }
3976 
3977   // Return null for empty list.
3978   if (methods.empty())
3979     return llvm::Constant::getNullValue(forProtocol
3980                                         ? ObjCTypes.MethodDescriptionListPtrTy
3981                                         : ObjCTypes.MethodListPtrTy);
3982 
3983   // For protocols, this is an objc_method_description_list, which has
3984   // a slightly different structure.
3985   if (forProtocol) {
3986     ConstantInitBuilder builder(CGM);
3987     auto values = builder.beginStruct();
3988     values.addInt(ObjCTypes.IntTy, methods.size());
3989     auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3990     for (auto MD : methods) {
3991       emitMethodDescriptionConstant(methodArray, MD);
3992     }
3993     methodArray.finishAndAddTo(values);
3994 
3995     llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3996                                                  CGM.getPointerAlign(), true);
3997     return llvm::ConstantExpr::getBitCast(GV,
3998                                           ObjCTypes.MethodDescriptionListPtrTy);
3999   }
4000 
4001   // Otherwise, it's an objc_method_list.
4002   ConstantInitBuilder builder(CGM);
4003   auto values = builder.beginStruct();
4004   values.addNullPointer(ObjCTypes.Int8PtrTy);
4005   values.addInt(ObjCTypes.IntTy, methods.size());
4006   auto methodArray = values.beginArray(ObjCTypes.MethodTy);
4007   for (auto MD : methods) {
4008     if (!MD->isDirectMethod())
4009       emitMethodConstant(methodArray, MD);
4010   }
4011   methodArray.finishAndAddTo(values);
4012 
4013   llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
4014                                                CGM.getPointerAlign(), true);
4015   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
4016 }
4017 
4018 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
4019                                                 const ObjCContainerDecl *CD) {
4020   llvm::Function *Method;
4021 
4022   if (OMD->isDirectMethod()) {
4023     Method = GenerateDirectMethod(OMD, CD);
4024   } else {
4025     auto Name = getSymbolNameForMethod(OMD);
4026 
4027     CodeGenTypes &Types = CGM.getTypes();
4028     llvm::FunctionType *MethodTy =
4029         Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
4030     Method =
4031         llvm::Function::Create(MethodTy, llvm::GlobalValue::InternalLinkage,
4032                                Name, &CGM.getModule());
4033   }
4034 
4035   MethodDefinitions.insert(std::make_pair(OMD, Method));
4036 
4037   return Method;
4038 }
4039 
4040 llvm::Function *
4041 CGObjCCommonMac::GenerateDirectMethod(const ObjCMethodDecl *OMD,
4042                                       const ObjCContainerDecl *CD) {
4043   auto *COMD = OMD->getCanonicalDecl();
4044   auto I = DirectMethodDefinitions.find(COMD);
4045   llvm::Function *OldFn = nullptr, *Fn = nullptr;
4046 
4047   if (I != DirectMethodDefinitions.end()) {
4048     // Objective-C allows for the declaration and implementation types
4049     // to differ slightly.
4050     //
4051     // If we're being asked for the Function associated for a method
4052     // implementation, a previous value might have been cached
4053     // based on the type of the canonical declaration.
4054     //
4055     // If these do not match, then we'll replace this function with
4056     // a new one that has the proper type below.
4057     if (!OMD->getBody() || COMD->getReturnType() == OMD->getReturnType())
4058       return I->second;
4059     OldFn = I->second;
4060   }
4061 
4062   CodeGenTypes &Types = CGM.getTypes();
4063   llvm::FunctionType *MethodTy =
4064     Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
4065 
4066   if (OldFn) {
4067     Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
4068                                 "", &CGM.getModule());
4069     Fn->takeName(OldFn);
4070     OldFn->replaceAllUsesWith(
4071         llvm::ConstantExpr::getBitCast(Fn, OldFn->getType()));
4072     OldFn->eraseFromParent();
4073 
4074     // Replace the cached function in the map.
4075     I->second = Fn;
4076   } else {
4077     auto Name = getSymbolNameForMethod(OMD, /*include category*/ false);
4078 
4079     Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,
4080                                 Name, &CGM.getModule());
4081     DirectMethodDefinitions.insert(std::make_pair(COMD, Fn));
4082   }
4083 
4084   return Fn;
4085 }
4086 
4087 void CGObjCCommonMac::GenerateDirectMethodPrologue(
4088     CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD,
4089     const ObjCContainerDecl *CD) {
4090   auto &Builder = CGF.Builder;
4091   bool ReceiverCanBeNull = true;
4092   auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
4093   auto selfValue = Builder.CreateLoad(selfAddr);
4094 
4095   // Generate:
4096   //
4097   // /* for class methods only to force class lazy initialization */
4098   // self = [self self];
4099   //
4100   // /* unless the receiver is never NULL */
4101   // if (self == nil) {
4102   //     return (ReturnType){ };
4103   // }
4104   //
4105   // _cmd = @selector(...)
4106   // ...
4107 
4108   if (OMD->isClassMethod()) {
4109     const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD);
4110     assert(OID &&
4111            "GenerateDirectMethod() should be called with the Class Interface");
4112     Selector SelfSel = GetNullarySelector("self", CGM.getContext());
4113     auto ResultType = CGF.getContext().getObjCIdType();
4114     RValue result;
4115     CallArgList Args;
4116 
4117     // TODO: If this method is inlined, the caller might know that `self` is
4118     // already initialized; for example, it might be an ordinary Objective-C
4119     // method which always receives an initialized `self`, or it might have just
4120     // forced initialization on its own.
4121     //
4122     // We should find a way to eliminate this unnecessary initialization in such
4123     // cases in LLVM.
4124     result = GeneratePossiblySpecializedMessageSend(
4125         CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID,
4126         nullptr, true);
4127     Builder.CreateStore(result.getScalarVal(), selfAddr);
4128 
4129     // Nullable `Class` expressions cannot be messaged with a direct method
4130     // so the only reason why the receive can be null would be because
4131     // of weak linking.
4132     ReceiverCanBeNull = isWeakLinkedClass(OID);
4133   }
4134 
4135   if (ReceiverCanBeNull) {
4136     llvm::BasicBlock *SelfIsNilBlock =
4137         CGF.createBasicBlock("objc_direct_method.self_is_nil");
4138     llvm::BasicBlock *ContBlock =
4139         CGF.createBasicBlock("objc_direct_method.cont");
4140 
4141     // if (self == nil) {
4142     auto selfTy = cast<llvm::PointerType>(selfValue->getType());
4143     auto Zero = llvm::ConstantPointerNull::get(selfTy);
4144 
4145     llvm::MDBuilder MDHelper(CGM.getLLVMContext());
4146     Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock,
4147                          ContBlock, MDHelper.createBranchWeights(1, 1 << 20));
4148 
4149     CGF.EmitBlock(SelfIsNilBlock);
4150 
4151     //   return (ReturnType){ };
4152     auto retTy = OMD->getReturnType();
4153     Builder.SetInsertPoint(SelfIsNilBlock);
4154     if (!retTy->isVoidType()) {
4155       CGF.EmitNullInitialization(CGF.ReturnValue, retTy);
4156     }
4157     CGF.EmitBranchThroughCleanup(CGF.ReturnBlock);
4158     // }
4159 
4160     // rest of the body
4161     CGF.EmitBlock(ContBlock);
4162     Builder.SetInsertPoint(ContBlock);
4163   }
4164 
4165   // only synthesize _cmd if it's referenced
4166   if (OMD->getCmdDecl()->isUsed()) {
4167     Builder.CreateStore(GetSelector(CGF, OMD),
4168                         CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
4169   }
4170 }
4171 
4172 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4173                                                ConstantStructBuilder &Init,
4174                                                          StringRef Section,
4175                                                          CharUnits Align,
4176                                                          bool AddToUsed) {
4177   llvm::GlobalValue::LinkageTypes LT =
4178       getLinkageTypeForObjCMetadata(CGM, Section);
4179   llvm::GlobalVariable *GV =
4180       Init.finishAndCreateGlobal(Name, Align, /*constant*/ false, LT);
4181   if (!Section.empty())
4182     GV->setSection(Section);
4183   if (AddToUsed)
4184     CGM.addCompilerUsedGlobal(GV);
4185   return GV;
4186 }
4187 
4188 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4189                                                          llvm::Constant *Init,
4190                                                          StringRef Section,
4191                                                          CharUnits Align,
4192                                                          bool AddToUsed) {
4193   llvm::Type *Ty = Init->getType();
4194   llvm::GlobalValue::LinkageTypes LT =
4195       getLinkageTypeForObjCMetadata(CGM, Section);
4196   llvm::GlobalVariable *GV =
4197       new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name);
4198   if (!Section.empty())
4199     GV->setSection(Section);
4200   GV->setAlignment(Align.getAsAlign());
4201   if (AddToUsed)
4202     CGM.addCompilerUsedGlobal(GV);
4203   return GV;
4204 }
4205 
4206 llvm::GlobalVariable *
4207 CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
4208                                       bool ForceNonFragileABI,
4209                                       bool NullTerminate) {
4210   StringRef Label;
4211   switch (Type) {
4212   case ObjCLabelType::ClassName:     Label = "OBJC_CLASS_NAME_"; break;
4213   case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
4214   case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
4215   case ObjCLabelType::PropertyName:  Label = "OBJC_PROP_NAME_ATTR_"; break;
4216   }
4217 
4218   bool NonFragile = ForceNonFragileABI || isNonFragileABI();
4219 
4220   StringRef Section;
4221   switch (Type) {
4222   case ObjCLabelType::ClassName:
4223     Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
4224                          : "__TEXT,__cstring,cstring_literals";
4225     break;
4226   case ObjCLabelType::MethodVarName:
4227     Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4228                          : "__TEXT,__cstring,cstring_literals";
4229     break;
4230   case ObjCLabelType::MethodVarType:
4231     Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
4232                          : "__TEXT,__cstring,cstring_literals";
4233     break;
4234   case ObjCLabelType::PropertyName:
4235     Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4236                          : "__TEXT,__cstring,cstring_literals";
4237     break;
4238   }
4239 
4240   llvm::Constant *Value =
4241       llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
4242   llvm::GlobalVariable *GV =
4243       new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
4244                                /*isConstant=*/true,
4245                                llvm::GlobalValue::PrivateLinkage, Value, Label);
4246   if (CGM.getTriple().isOSBinFormatMachO())
4247     GV->setSection(Section);
4248   GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4249   GV->setAlignment(CharUnits::One().getAsAlign());
4250   CGM.addCompilerUsedGlobal(GV);
4251 
4252   return GV;
4253 }
4254 
4255 llvm::Function *CGObjCMac::ModuleInitFunction() {
4256   // Abuse this interface function as a place to finalize.
4257   FinishModule();
4258   return nullptr;
4259 }
4260 
4261 llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() {
4262   return ObjCTypes.getGetPropertyFn();
4263 }
4264 
4265 llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() {
4266   return ObjCTypes.getSetPropertyFn();
4267 }
4268 
4269 llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
4270                                                                 bool copy) {
4271   return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
4272 }
4273 
4274 llvm::FunctionCallee CGObjCMac::GetGetStructFunction() {
4275   return ObjCTypes.getCopyStructFn();
4276 }
4277 
4278 llvm::FunctionCallee CGObjCMac::GetSetStructFunction() {
4279   return ObjCTypes.getCopyStructFn();
4280 }
4281 
4282 llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() {
4283   return ObjCTypes.getCppAtomicObjectFunction();
4284 }
4285 
4286 llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() {
4287   return ObjCTypes.getCppAtomicObjectFunction();
4288 }
4289 
4290 llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() {
4291   return ObjCTypes.getEnumerationMutationFn();
4292 }
4293 
4294 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
4295   return EmitTryOrSynchronizedStmt(CGF, S);
4296 }
4297 
4298 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
4299                                      const ObjCAtSynchronizedStmt &S) {
4300   return EmitTryOrSynchronizedStmt(CGF, S);
4301 }
4302 
4303 namespace {
4304   struct PerformFragileFinally final : EHScopeStack::Cleanup {
4305     const Stmt &S;
4306     Address SyncArgSlot;
4307     Address CallTryExitVar;
4308     Address ExceptionData;
4309     ObjCTypesHelper &ObjCTypes;
4310     PerformFragileFinally(const Stmt *S,
4311                           Address SyncArgSlot,
4312                           Address CallTryExitVar,
4313                           Address ExceptionData,
4314                           ObjCTypesHelper *ObjCTypes)
4315       : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4316         ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4317 
4318     void Emit(CodeGenFunction &CGF, Flags flags) override {
4319       // Check whether we need to call objc_exception_try_exit.
4320       // In optimized code, this branch will always be folded.
4321       llvm::BasicBlock *FinallyCallExit =
4322         CGF.createBasicBlock("finally.call_exit");
4323       llvm::BasicBlock *FinallyNoCallExit =
4324         CGF.createBasicBlock("finally.no_call_exit");
4325       CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4326                                FinallyCallExit, FinallyNoCallExit);
4327 
4328       CGF.EmitBlock(FinallyCallExit);
4329       CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4330                                   ExceptionData.getPointer());
4331 
4332       CGF.EmitBlock(FinallyNoCallExit);
4333 
4334       if (isa<ObjCAtTryStmt>(S)) {
4335         if (const ObjCAtFinallyStmt* FinallyStmt =
4336               cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4337           // Don't try to do the @finally if this is an EH cleanup.
4338           if (flags.isForEHCleanup()) return;
4339 
4340           // Save the current cleanup destination in case there's
4341           // control flow inside the finally statement.
4342           llvm::Value *CurCleanupDest =
4343             CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
4344 
4345           CGF.EmitStmt(FinallyStmt->getFinallyBody());
4346 
4347           if (CGF.HaveInsertPoint()) {
4348             CGF.Builder.CreateStore(CurCleanupDest,
4349                                     CGF.getNormalCleanupDestSlot());
4350           } else {
4351             // Currently, the end of the cleanup must always exist.
4352             CGF.EnsureInsertPoint();
4353           }
4354         }
4355       } else {
4356         // Emit objc_sync_exit(expr); as finally's sole statement for
4357         // @synchronized.
4358         llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4359         CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4360       }
4361     }
4362   };
4363 
4364   class FragileHazards {
4365     CodeGenFunction &CGF;
4366     SmallVector<llvm::Value*, 20> Locals;
4367     llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4368 
4369     llvm::InlineAsm *ReadHazard;
4370     llvm::InlineAsm *WriteHazard;
4371 
4372     llvm::FunctionType *GetAsmFnType();
4373 
4374     void collectLocals();
4375     void emitReadHazard(CGBuilderTy &Builder);
4376 
4377   public:
4378     FragileHazards(CodeGenFunction &CGF);
4379 
4380     void emitWriteHazard();
4381     void emitHazardsInNewBlocks();
4382   };
4383 } // end anonymous namespace
4384 
4385 /// Create the fragile-ABI read and write hazards based on the current
4386 /// state of the function, which is presumed to be immediately prior
4387 /// to a @try block.  These hazards are used to maintain correct
4388 /// semantics in the face of optimization and the fragile ABI's
4389 /// cavalier use of setjmp/longjmp.
4390 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4391   collectLocals();
4392 
4393   if (Locals.empty()) return;
4394 
4395   // Collect all the blocks in the function.
4396   for (llvm::Function::iterator
4397          I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
4398     BlocksBeforeTry.insert(&*I);
4399 
4400   llvm::FunctionType *AsmFnTy = GetAsmFnType();
4401 
4402   // Create a read hazard for the allocas.  This inhibits dead-store
4403   // optimizations and forces the values to memory.  This hazard is
4404   // inserted before any 'throwing' calls in the protected scope to
4405   // reflect the possibility that the variables might be read from the
4406   // catch block if the call throws.
4407   {
4408     std::string Constraint;
4409     for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4410       if (I) Constraint += ',';
4411       Constraint += "*m";
4412     }
4413 
4414     ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4415   }
4416 
4417   // Create a write hazard for the allocas.  This inhibits folding
4418   // loads across the hazard.  This hazard is inserted at the
4419   // beginning of the catch path to reflect the possibility that the
4420   // variables might have been written within the protected scope.
4421   {
4422     std::string Constraint;
4423     for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4424       if (I) Constraint += ',';
4425       Constraint += "=*m";
4426     }
4427 
4428     WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4429   }
4430 }
4431 
4432 /// Emit a write hazard at the current location.
4433 void FragileHazards::emitWriteHazard() {
4434   if (Locals.empty()) return;
4435 
4436   CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4437 }
4438 
4439 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4440   assert(!Locals.empty());
4441   llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4442   call->setDoesNotThrow();
4443   call->setCallingConv(CGF.getRuntimeCC());
4444 }
4445 
4446 /// Emit read hazards in all the protected blocks, i.e. all the blocks
4447 /// which have been inserted since the beginning of the try.
4448 void FragileHazards::emitHazardsInNewBlocks() {
4449   if (Locals.empty()) return;
4450 
4451   CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4452 
4453   // Iterate through all blocks, skipping those prior to the try.
4454   for (llvm::Function::iterator
4455          FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
4456     llvm::BasicBlock &BB = *FI;
4457     if (BlocksBeforeTry.count(&BB)) continue;
4458 
4459     // Walk through all the calls in the block.
4460     for (llvm::BasicBlock::iterator
4461            BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
4462       llvm::Instruction &I = *BI;
4463 
4464       // Ignore instructions that aren't non-intrinsic calls.
4465       // These are the only calls that can possibly call longjmp.
4466       if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I))
4467         continue;
4468       if (isa<llvm::IntrinsicInst>(I))
4469         continue;
4470 
4471       // Ignore call sites marked nounwind.  This may be questionable,
4472       // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4473       if (cast<llvm::CallBase>(I).doesNotThrow())
4474         continue;
4475 
4476       // Insert a read hazard before the call.  This will ensure that
4477       // any writes to the locals are performed before making the
4478       // call.  If the call throws, then this is sufficient to
4479       // guarantee correctness as long as it doesn't also write to any
4480       // locals.
4481       Builder.SetInsertPoint(&BB, BI);
4482       emitReadHazard(Builder);
4483     }
4484   }
4485 }
4486 
4487 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
4488   if (V.isValid()) S.insert(V.getPointer());
4489 }
4490 
4491 void FragileHazards::collectLocals() {
4492   // Compute a set of allocas to ignore.
4493   llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4494   addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4495   addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4496 
4497   // Collect all the allocas currently in the function.  This is
4498   // probably way too aggressive.
4499   llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4500   for (llvm::BasicBlock::iterator
4501          I = Entry.begin(), E = Entry.end(); I != E; ++I)
4502     if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
4503       Locals.push_back(&*I);
4504 }
4505 
4506 llvm::FunctionType *FragileHazards::GetAsmFnType() {
4507   SmallVector<llvm::Type *, 16> tys(Locals.size());
4508   for (unsigned i = 0, e = Locals.size(); i != e; ++i)
4509     tys[i] = Locals[i]->getType();
4510   return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4511 }
4512 
4513 /*
4514 
4515   Objective-C setjmp-longjmp (sjlj) Exception Handling
4516   --
4517 
4518   A catch buffer is a setjmp buffer plus:
4519     - a pointer to the exception that was caught
4520     - a pointer to the previous exception data buffer
4521     - two pointers of reserved storage
4522   Therefore catch buffers form a stack, with a pointer to the top
4523   of the stack kept in thread-local storage.
4524 
4525   objc_exception_try_enter pushes a catch buffer onto the EH stack.
4526   objc_exception_try_exit pops the given catch buffer, which is
4527     required to be the top of the EH stack.
4528   objc_exception_throw pops the top of the EH stack, writes the
4529     thrown exception into the appropriate field, and longjmps
4530     to the setjmp buffer.  It crashes the process (with a printf
4531     and an abort()) if there are no catch buffers on the stack.
4532   objc_exception_extract just reads the exception pointer out of the
4533     catch buffer.
4534 
4535   There's no reason an implementation couldn't use a light-weight
4536   setjmp here --- something like __builtin_setjmp, but API-compatible
4537   with the heavyweight setjmp.  This will be more important if we ever
4538   want to implement correct ObjC/C++ exception interactions for the
4539   fragile ABI.
4540 
4541   Note that for this use of setjmp/longjmp to be correct, we may need
4542   to mark some local variables volatile: if a non-volatile local
4543   variable is modified between the setjmp and the longjmp, it has
4544   indeterminate value.  For the purposes of LLVM IR, it may be
4545   sufficient to make loads and stores within the @try (to variables
4546   declared outside the @try) volatile.  This is necessary for
4547   optimized correctness, but is not currently being done; this is
4548   being tracked as rdar://problem/8160285
4549 
4550   The basic framework for a @try-catch-finally is as follows:
4551   {
4552   objc_exception_data d;
4553   id _rethrow = null;
4554   bool _call_try_exit = true;
4555 
4556   objc_exception_try_enter(&d);
4557   if (!setjmp(d.jmp_buf)) {
4558   ... try body ...
4559   } else {
4560   // exception path
4561   id _caught = objc_exception_extract(&d);
4562 
4563   // enter new try scope for handlers
4564   if (!setjmp(d.jmp_buf)) {
4565   ... match exception and execute catch blocks ...
4566 
4567   // fell off end, rethrow.
4568   _rethrow = _caught;
4569   ... jump-through-finally to finally_rethrow ...
4570   } else {
4571   // exception in catch block
4572   _rethrow = objc_exception_extract(&d);
4573   _call_try_exit = false;
4574   ... jump-through-finally to finally_rethrow ...
4575   }
4576   }
4577   ... jump-through-finally to finally_end ...
4578 
4579   finally:
4580   if (_call_try_exit)
4581   objc_exception_try_exit(&d);
4582 
4583   ... finally block ....
4584   ... dispatch to finally destination ...
4585 
4586   finally_rethrow:
4587   objc_exception_throw(_rethrow);
4588 
4589   finally_end:
4590   }
4591 
4592   This framework differs slightly from the one gcc uses, in that gcc
4593   uses _rethrow to determine if objc_exception_try_exit should be called
4594   and if the object should be rethrown. This breaks in the face of
4595   throwing nil and introduces unnecessary branches.
4596 
4597   We specialize this framework for a few particular circumstances:
4598 
4599   - If there are no catch blocks, then we avoid emitting the second
4600   exception handling context.
4601 
4602   - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4603   e)) we avoid emitting the code to rethrow an uncaught exception.
4604 
4605   - FIXME: If there is no @finally block we can do a few more
4606   simplifications.
4607 
4608   Rethrows and Jumps-Through-Finally
4609   --
4610 
4611   '@throw;' is supported by pushing the currently-caught exception
4612   onto ObjCEHStack while the @catch blocks are emitted.
4613 
4614   Branches through the @finally block are handled with an ordinary
4615   normal cleanup.  We do not register an EH cleanup; fragile-ABI ObjC
4616   exceptions are not compatible with C++ exceptions, and this is
4617   hardly the only place where this will go wrong.
4618 
4619   @synchronized(expr) { stmt; } is emitted as if it were:
4620     id synch_value = expr;
4621     objc_sync_enter(synch_value);
4622     @try { stmt; } @finally { objc_sync_exit(synch_value); }
4623 */
4624 
4625 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4626                                           const Stmt &S) {
4627   bool isTry = isa<ObjCAtTryStmt>(S);
4628 
4629   // A destination for the fall-through edges of the catch handlers to
4630   // jump to.
4631   CodeGenFunction::JumpDest FinallyEnd =
4632     CGF.getJumpDestInCurrentScope("finally.end");
4633 
4634   // A destination for the rethrow edge of the catch handlers to jump
4635   // to.
4636   CodeGenFunction::JumpDest FinallyRethrow =
4637     CGF.getJumpDestInCurrentScope("finally.rethrow");
4638 
4639   // For @synchronized, call objc_sync_enter(sync.expr). The
4640   // evaluation of the expression must occur before we enter the
4641   // @synchronized.  We can't avoid a temp here because we need the
4642   // value to be preserved.  If the backend ever does liveness
4643   // correctly after setjmp, this will be unnecessary.
4644   Address SyncArgSlot = Address::invalid();
4645   if (!isTry) {
4646     llvm::Value *SyncArg =
4647       CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4648     SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4649     CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4650 
4651     SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4652                                        CGF.getPointerAlign(), "sync.arg");
4653     CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4654   }
4655 
4656   // Allocate memory for the setjmp buffer.  This needs to be kept
4657   // live throughout the try and catch blocks.
4658   Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4659                                                CGF.getPointerAlign(),
4660                                                "exceptiondata.ptr");
4661 
4662   // Create the fragile hazards.  Note that this will not capture any
4663   // of the allocas required for exception processing, but will
4664   // capture the current basic block (which extends all the way to the
4665   // setjmp call) as "before the @try".
4666   FragileHazards Hazards(CGF);
4667 
4668   // Create a flag indicating whether the cleanup needs to call
4669   // objc_exception_try_exit.  This is true except when
4670   //   - no catches match and we're branching through the cleanup
4671   //     just to rethrow the exception, or
4672   //   - a catch matched and we're falling out of the catch handler.
4673   // The setjmp-safety rule here is that we should always store to this
4674   // variable in a place that dominates the branch through the cleanup
4675   // without passing through any setjmps.
4676   Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4677                                                 CharUnits::One(),
4678                                                 "_call_try_exit");
4679 
4680   // A slot containing the exception to rethrow.  Only needed when we
4681   // have both a @catch and a @finally.
4682   Address PropagatingExnVar = Address::invalid();
4683 
4684   // Push a normal cleanup to leave the try scope.
4685   CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4686                                                  SyncArgSlot,
4687                                                  CallTryExitVar,
4688                                                  ExceptionData,
4689                                                  &ObjCTypes);
4690 
4691   // Enter a try block:
4692   //  - Call objc_exception_try_enter to push ExceptionData on top of
4693   //    the EH stack.
4694   CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4695                               ExceptionData.getPointer());
4696 
4697   //  - Call setjmp on the exception data buffer.
4698   llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4699   llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4700   llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4701       ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4702       "setjmp_buffer");
4703   llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4704       ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4705   SetJmpResult->setCanReturnTwice();
4706 
4707   // If setjmp returned 0, enter the protected block; otherwise,
4708   // branch to the handler.
4709   llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4710   llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4711   llvm::Value *DidCatch =
4712     CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4713   CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4714 
4715   // Emit the protected block.
4716   CGF.EmitBlock(TryBlock);
4717   CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4718   CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4719                      : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4720 
4721   CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4722 
4723   // Emit the exception handler block.
4724   CGF.EmitBlock(TryHandler);
4725 
4726   // Don't optimize loads of the in-scope locals across this point.
4727   Hazards.emitWriteHazard();
4728 
4729   // For a @synchronized (or a @try with no catches), just branch
4730   // through the cleanup to the rethrow block.
4731   if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4732     // Tell the cleanup not to re-pop the exit.
4733     CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4734     CGF.EmitBranchThroughCleanup(FinallyRethrow);
4735 
4736   // Otherwise, we have to match against the caught exceptions.
4737   } else {
4738     // Retrieve the exception object.  We may emit multiple blocks but
4739     // nothing can cross this so the value is already in SSA form.
4740     llvm::CallInst *Caught =
4741       CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4742                                   ExceptionData.getPointer(), "caught");
4743 
4744     // Push the exception to rethrow onto the EH value stack for the
4745     // benefit of any @throws in the handlers.
4746     CGF.ObjCEHValueStack.push_back(Caught);
4747 
4748     const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4749 
4750     bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4751 
4752     llvm::BasicBlock *CatchBlock = nullptr;
4753     llvm::BasicBlock *CatchHandler = nullptr;
4754     if (HasFinally) {
4755       // Save the currently-propagating exception before
4756       // objc_exception_try_enter clears the exception slot.
4757       PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4758                                                CGF.getPointerAlign(),
4759                                                "propagating_exception");
4760       CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4761 
4762       // Enter a new exception try block (in case a @catch block
4763       // throws an exception).
4764       CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4765                                   ExceptionData.getPointer());
4766 
4767       llvm::CallInst *SetJmpResult =
4768         CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4769                                     SetJmpBuffer, "setjmp.result");
4770       SetJmpResult->setCanReturnTwice();
4771 
4772       llvm::Value *Threw =
4773         CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4774 
4775       CatchBlock = CGF.createBasicBlock("catch");
4776       CatchHandler = CGF.createBasicBlock("catch_for_catch");
4777       CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4778 
4779       CGF.EmitBlock(CatchBlock);
4780     }
4781 
4782     CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4783 
4784     // Handle catch list. As a special case we check if everything is
4785     // matched and avoid generating code for falling off the end if
4786     // so.
4787     bool AllMatched = false;
4788     for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
4789       const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4790 
4791       const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4792       const ObjCObjectPointerType *OPT = nullptr;
4793 
4794       // catch(...) always matches.
4795       if (!CatchParam) {
4796         AllMatched = true;
4797       } else {
4798         OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4799 
4800         // catch(id e) always matches under this ABI, since only
4801         // ObjC exceptions end up here in the first place.
4802         // FIXME: For the time being we also match id<X>; this should
4803         // be rejected by Sema instead.
4804         if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4805           AllMatched = true;
4806       }
4807 
4808       // If this is a catch-all, we don't need to test anything.
4809       if (AllMatched) {
4810         CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4811 
4812         if (CatchParam) {
4813           CGF.EmitAutoVarDecl(*CatchParam);
4814           assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4815 
4816           // These types work out because ConvertType(id) == i8*.
4817           EmitInitOfCatchParam(CGF, Caught, CatchParam);
4818         }
4819 
4820         CGF.EmitStmt(CatchStmt->getCatchBody());
4821 
4822         // The scope of the catch variable ends right here.
4823         CatchVarCleanups.ForceCleanup();
4824 
4825         CGF.EmitBranchThroughCleanup(FinallyEnd);
4826         break;
4827       }
4828 
4829       assert(OPT && "Unexpected non-object pointer type in @catch");
4830       const ObjCObjectType *ObjTy = OPT->getObjectType();
4831 
4832       // FIXME: @catch (Class c) ?
4833       ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4834       assert(IDecl && "Catch parameter must have Objective-C type!");
4835 
4836       // Check if the @catch block matches the exception object.
4837       llvm::Value *Class = EmitClassRef(CGF, IDecl);
4838 
4839       llvm::Value *matchArgs[] = { Class, Caught };
4840       llvm::CallInst *Match =
4841         CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4842                                     matchArgs, "match");
4843 
4844       llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4845       llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4846 
4847       CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4848                                MatchedBlock, NextCatchBlock);
4849 
4850       // Emit the @catch block.
4851       CGF.EmitBlock(MatchedBlock);
4852 
4853       // Collect any cleanups for the catch variable.  The scope lasts until
4854       // the end of the catch body.
4855       CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4856 
4857       CGF.EmitAutoVarDecl(*CatchParam);
4858       assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4859 
4860       // Initialize the catch variable.
4861       llvm::Value *Tmp =
4862         CGF.Builder.CreateBitCast(Caught,
4863                                   CGF.ConvertType(CatchParam->getType()));
4864       EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4865 
4866       CGF.EmitStmt(CatchStmt->getCatchBody());
4867 
4868       // We're done with the catch variable.
4869       CatchVarCleanups.ForceCleanup();
4870 
4871       CGF.EmitBranchThroughCleanup(FinallyEnd);
4872 
4873       CGF.EmitBlock(NextCatchBlock);
4874     }
4875 
4876     CGF.ObjCEHValueStack.pop_back();
4877 
4878     // If nothing wanted anything to do with the caught exception,
4879     // kill the extract call.
4880     if (Caught->use_empty())
4881       Caught->eraseFromParent();
4882 
4883     if (!AllMatched)
4884       CGF.EmitBranchThroughCleanup(FinallyRethrow);
4885 
4886     if (HasFinally) {
4887       // Emit the exception handler for the @catch blocks.
4888       CGF.EmitBlock(CatchHandler);
4889 
4890       // In theory we might now need a write hazard, but actually it's
4891       // unnecessary because there's no local-accessing code between
4892       // the try's write hazard and here.
4893       //Hazards.emitWriteHazard();
4894 
4895       // Extract the new exception and save it to the
4896       // propagating-exception slot.
4897       assert(PropagatingExnVar.isValid());
4898       llvm::CallInst *NewCaught =
4899         CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4900                                     ExceptionData.getPointer(), "caught");
4901       CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4902 
4903       // Don't pop the catch handler; the throw already did.
4904       CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4905       CGF.EmitBranchThroughCleanup(FinallyRethrow);
4906     }
4907   }
4908 
4909   // Insert read hazards as required in the new blocks.
4910   Hazards.emitHazardsInNewBlocks();
4911 
4912   // Pop the cleanup.
4913   CGF.Builder.restoreIP(TryFallthroughIP);
4914   if (CGF.HaveInsertPoint())
4915     CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4916   CGF.PopCleanupBlock();
4917   CGF.EmitBlock(FinallyEnd.getBlock(), true);
4918 
4919   // Emit the rethrow block.
4920   CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4921   CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4922   if (CGF.HaveInsertPoint()) {
4923     // If we have a propagating-exception variable, check it.
4924     llvm::Value *PropagatingExn;
4925     if (PropagatingExnVar.isValid()) {
4926       PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4927 
4928     // Otherwise, just look in the buffer for the exception to throw.
4929     } else {
4930       llvm::CallInst *Caught =
4931         CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4932                                     ExceptionData.getPointer());
4933       PropagatingExn = Caught;
4934     }
4935 
4936     CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4937                                 PropagatingExn);
4938     CGF.Builder.CreateUnreachable();
4939   }
4940 
4941   CGF.Builder.restoreIP(SavedIP);
4942 }
4943 
4944 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4945                               const ObjCAtThrowStmt &S,
4946                               bool ClearInsertionPoint) {
4947   llvm::Value *ExceptionAsObject;
4948 
4949   if (const Expr *ThrowExpr = S.getThrowExpr()) {
4950     llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4951     ExceptionAsObject =
4952       CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4953   } else {
4954     assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4955            "Unexpected rethrow outside @catch block.");
4956     ExceptionAsObject = CGF.ObjCEHValueStack.back();
4957   }
4958 
4959   CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4960     ->setDoesNotReturn();
4961   CGF.Builder.CreateUnreachable();
4962 
4963   // Clear the insertion point to indicate we are in unreachable code.
4964   if (ClearInsertionPoint)
4965     CGF.Builder.ClearInsertionPoint();
4966 }
4967 
4968 /// EmitObjCWeakRead - Code gen for loading value of a __weak
4969 /// object: objc_read_weak (id *src)
4970 ///
4971 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4972                                           Address AddrWeakObj) {
4973   llvm::Type* DestTy = AddrWeakObj.getElementType();
4974   AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4975                                           ObjCTypes.PtrObjectPtrTy);
4976   llvm::Value *read_weak =
4977     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4978                                 AddrWeakObj.getPointer(), "weakread");
4979   read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4980   return read_weak;
4981 }
4982 
4983 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4984 /// objc_assign_weak (id src, id *dst)
4985 ///
4986 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4987                                    llvm::Value *src, Address dst) {
4988   llvm::Type * SrcTy = src->getType();
4989   if (!isa<llvm::PointerType>(SrcTy)) {
4990     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4991     assert(Size <= 8 && "does not support size > 8");
4992     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4993                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4994     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4995   }
4996   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4997   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4998   llvm::Value *args[] = { src, dst.getPointer() };
4999   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
5000                               args, "weakassign");
5001 }
5002 
5003 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
5004 /// objc_assign_global (id src, id *dst)
5005 ///
5006 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
5007                                      llvm::Value *src, Address dst,
5008                                      bool threadlocal) {
5009   llvm::Type * SrcTy = src->getType();
5010   if (!isa<llvm::PointerType>(SrcTy)) {
5011     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5012     assert(Size <= 8 && "does not support size > 8");
5013     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5014                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5015     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5016   }
5017   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5018   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5019   llvm::Value *args[] = { src, dst.getPointer() };
5020   if (!threadlocal)
5021     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
5022                                 args, "globalassign");
5023   else
5024     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
5025                                 args, "threadlocalassign");
5026 }
5027 
5028 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
5029 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
5030 ///
5031 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
5032                                    llvm::Value *src, Address dst,
5033                                    llvm::Value *ivarOffset) {
5034   assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
5035   llvm::Type * SrcTy = src->getType();
5036   if (!isa<llvm::PointerType>(SrcTy)) {
5037     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5038     assert(Size <= 8 && "does not support size > 8");
5039     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5040                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5041     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5042   }
5043   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5044   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5045   llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
5046   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
5047 }
5048 
5049 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
5050 /// objc_assign_strongCast (id src, id *dst)
5051 ///
5052 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
5053                                          llvm::Value *src, Address dst) {
5054   llvm::Type * SrcTy = src->getType();
5055   if (!isa<llvm::PointerType>(SrcTy)) {
5056     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5057     assert(Size <= 8 && "does not support size > 8");
5058     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5059                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5060     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5061   }
5062   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5063   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5064   llvm::Value *args[] = { src, dst.getPointer() };
5065   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
5066                               args, "strongassign");
5067 }
5068 
5069 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
5070                                          Address DestPtr,
5071                                          Address SrcPtr,
5072                                          llvm::Value *size) {
5073   SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
5074   DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
5075   llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
5076   CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
5077 }
5078 
5079 /// EmitObjCValueForIvar - Code Gen for ivar reference.
5080 ///
5081 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
5082                                        QualType ObjectTy,
5083                                        llvm::Value *BaseValue,
5084                                        const ObjCIvarDecl *Ivar,
5085                                        unsigned CVRQualifiers) {
5086   const ObjCInterfaceDecl *ID =
5087     ObjectTy->castAs<ObjCObjectType>()->getInterface();
5088   return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
5089                                   EmitIvarOffset(CGF, ID, Ivar));
5090 }
5091 
5092 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
5093                                        const ObjCInterfaceDecl *Interface,
5094                                        const ObjCIvarDecl *Ivar) {
5095   uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
5096   return llvm::ConstantInt::get(
5097     CGM.getTypes().ConvertType(CGM.getContext().LongTy),
5098     Offset);
5099 }
5100 
5101 /* *** Private Interface *** */
5102 
5103 std::string CGObjCCommonMac::GetSectionName(StringRef Section,
5104                                             StringRef MachOAttributes) {
5105   switch (CGM.getTriple().getObjectFormat()) {
5106   case llvm::Triple::UnknownObjectFormat:
5107     llvm_unreachable("unexpected object file format");
5108   case llvm::Triple::MachO: {
5109     if (MachOAttributes.empty())
5110       return ("__DATA," + Section).str();
5111     return ("__DATA," + Section + "," + MachOAttributes).str();
5112   }
5113   case llvm::Triple::ELF:
5114     assert(Section.substr(0, 2) == "__" &&
5115            "expected the name to begin with __");
5116     return Section.substr(2).str();
5117   case llvm::Triple::COFF:
5118     assert(Section.substr(0, 2) == "__" &&
5119            "expected the name to begin with __");
5120     return ("." + Section.substr(2) + "$B").str();
5121   case llvm::Triple::Wasm:
5122   case llvm::Triple::GOFF:
5123   case llvm::Triple::XCOFF:
5124     llvm::report_fatal_error(
5125         "Objective-C support is unimplemented for object file format");
5126   }
5127 
5128   llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum");
5129 }
5130 
5131 /// EmitImageInfo - Emit the image info marker used to encode some module
5132 /// level information.
5133 ///
5134 /// See: <rdr://4810609&4810587&4810587>
5135 /// struct IMAGE_INFO {
5136 ///   unsigned version;
5137 ///   unsigned flags;
5138 /// };
5139 enum ImageInfoFlags {
5140   eImageInfo_FixAndContinue      = (1 << 0), // This flag is no longer set by clang.
5141   eImageInfo_GarbageCollected    = (1 << 1),
5142   eImageInfo_GCOnly              = (1 << 2),
5143   eImageInfo_OptimizedByDyld     = (1 << 3), // This flag is set by the dyld shared cache.
5144 
5145   // A flag indicating that the module has no instances of a @synthesize of a
5146   // superclass variable. <rdar://problem/6803242>
5147   eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
5148   eImageInfo_ImageIsSimulated    = (1 << 5),
5149   eImageInfo_ClassProperties     = (1 << 6)
5150 };
5151 
5152 void CGObjCCommonMac::EmitImageInfo() {
5153   unsigned version = 0; // Version is unused?
5154   std::string Section =
5155       (ObjCABI == 1)
5156           ? "__OBJC,__image_info,regular"
5157           : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");
5158 
5159   // Generate module-level named metadata to convey this information to the
5160   // linker and code-gen.
5161   llvm::Module &Mod = CGM.getModule();
5162 
5163   // Add the ObjC ABI version to the module flags.
5164   Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
5165   Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
5166                     version);
5167   Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
5168                     llvm::MDString::get(VMContext, Section));
5169 
5170   auto Int8Ty = llvm::Type::getInt8Ty(VMContext);
5171   if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5172     // Non-GC overrides those files which specify GC.
5173     Mod.addModuleFlag(llvm::Module::Error,
5174                       "Objective-C Garbage Collection",
5175                       llvm::ConstantInt::get(Int8Ty,0));
5176   } else {
5177     // Add the ObjC garbage collection value.
5178     Mod.addModuleFlag(llvm::Module::Error,
5179                       "Objective-C Garbage Collection",
5180                       llvm::ConstantInt::get(Int8Ty,
5181                         (uint8_t)eImageInfo_GarbageCollected));
5182 
5183     if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
5184       // Add the ObjC GC Only value.
5185       Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
5186                         eImageInfo_GCOnly);
5187 
5188       // Require that GC be specified and set to eImageInfo_GarbageCollected.
5189       llvm::Metadata *Ops[2] = {
5190           llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
5191           llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
5192               Int8Ty, eImageInfo_GarbageCollected))};
5193       Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
5194                         llvm::MDNode::get(VMContext, Ops));
5195     }
5196   }
5197 
5198   // Indicate whether we're compiling this to run on a simulator.
5199   if (CGM.getTarget().getTriple().isSimulatorEnvironment())
5200     Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
5201                       eImageInfo_ImageIsSimulated);
5202 
5203   // Indicate whether we are generating class properties.
5204   Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
5205                     eImageInfo_ClassProperties);
5206 }
5207 
5208 // struct objc_module {
5209 //   unsigned long version;
5210 //   unsigned long size;
5211 //   const char *name;
5212 //   Symtab symtab;
5213 // };
5214 
5215 // FIXME: Get from somewhere
5216 static const int ModuleVersion = 7;
5217 
5218 void CGObjCMac::EmitModuleInfo() {
5219   uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
5220 
5221   ConstantInitBuilder builder(CGM);
5222   auto values = builder.beginStruct(ObjCTypes.ModuleTy);
5223   values.addInt(ObjCTypes.LongTy, ModuleVersion);
5224   values.addInt(ObjCTypes.LongTy, Size);
5225   // This used to be the filename, now it is unused. <rdr://4327263>
5226   values.add(GetClassName(StringRef("")));
5227   values.add(EmitModuleSymbols());
5228   CreateMetadataVar("OBJC_MODULES", values,
5229                     "__OBJC,__module_info,regular,no_dead_strip",
5230                     CGM.getPointerAlign(), true);
5231 }
5232 
5233 llvm::Constant *CGObjCMac::EmitModuleSymbols() {
5234   unsigned NumClasses = DefinedClasses.size();
5235   unsigned NumCategories = DefinedCategories.size();
5236 
5237   // Return null if no symbols were defined.
5238   if (!NumClasses && !NumCategories)
5239     return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
5240 
5241   ConstantInitBuilder builder(CGM);
5242   auto values = builder.beginStruct();
5243   values.addInt(ObjCTypes.LongTy, 0);
5244   values.addNullPointer(ObjCTypes.SelectorPtrTy);
5245   values.addInt(ObjCTypes.ShortTy, NumClasses);
5246   values.addInt(ObjCTypes.ShortTy, NumCategories);
5247 
5248   // The runtime expects exactly the list of defined classes followed
5249   // by the list of defined categories, in a single array.
5250   auto array = values.beginArray(ObjCTypes.Int8PtrTy);
5251   for (unsigned i=0; i<NumClasses; i++) {
5252     const ObjCInterfaceDecl *ID = ImplementedClasses[i];
5253     assert(ID);
5254     if (ObjCImplementationDecl *IMP = ID->getImplementation())
5255       // We are implementing a weak imported interface. Give it external linkage
5256       if (ID->isWeakImported() && !IMP->isWeakImported())
5257         DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5258 
5259     array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy);
5260   }
5261   for (unsigned i=0; i<NumCategories; i++)
5262     array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy);
5263 
5264   array.finishAndAddTo(values);
5265 
5266   llvm::GlobalVariable *GV = CreateMetadataVar(
5267       "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip",
5268       CGM.getPointerAlign(), true);
5269   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
5270 }
5271 
5272 llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
5273                                            IdentifierInfo *II) {
5274   LazySymbols.insert(II);
5275 
5276   llvm::GlobalVariable *&Entry = ClassReferences[II];
5277 
5278   if (!Entry) {
5279     llvm::Constant *Casted =
5280     llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
5281                                    ObjCTypes.ClassPtrTy);
5282     Entry = CreateMetadataVar(
5283         "OBJC_CLASS_REFERENCES_", Casted,
5284         "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
5285         CGM.getPointerAlign(), true);
5286   }
5287 
5288   return CGF.Builder.CreateAlignedLoad(Entry, CGF.getPointerAlign());
5289 }
5290 
5291 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
5292                                      const ObjCInterfaceDecl *ID) {
5293   // If the class has the objc_runtime_visible attribute, we need to
5294   // use the Objective-C runtime to get the class.
5295   if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
5296     return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
5297 
5298   IdentifierInfo *RuntimeName =
5299       &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
5300   return EmitClassRefFromId(CGF, RuntimeName);
5301 }
5302 
5303 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
5304   IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
5305   return EmitClassRefFromId(CGF, II);
5306 }
5307 
5308 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
5309   return CGF.Builder.CreateLoad(EmitSelectorAddr(Sel));
5310 }
5311 
5312 Address CGObjCMac::EmitSelectorAddr(Selector Sel) {
5313   CharUnits Align = CGM.getPointerAlign();
5314 
5315   llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
5316   if (!Entry) {
5317     llvm::Constant *Casted =
5318       llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5319                                      ObjCTypes.SelectorPtrTy);
5320     Entry = CreateMetadataVar(
5321         "OBJC_SELECTOR_REFERENCES_", Casted,
5322         "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
5323     Entry->setExternallyInitialized(true);
5324   }
5325 
5326   return Address(Entry, Align);
5327 }
5328 
5329 llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
5330     llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
5331     if (!Entry)
5332       Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
5333     return getConstantGEP(VMContext, Entry, 0, 0);
5334 }
5335 
5336 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
5337   llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
5338       I = MethodDefinitions.find(MD);
5339   if (I != MethodDefinitions.end())
5340     return I->second;
5341 
5342   return nullptr;
5343 }
5344 
5345 /// GetIvarLayoutName - Returns a unique constant for the given
5346 /// ivar layout bitmap.
5347 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
5348                                        const ObjCCommonTypesHelper &ObjCTypes) {
5349   return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5350 }
5351 
5352 void IvarLayoutBuilder::visitRecord(const RecordType *RT,
5353                                     CharUnits offset) {
5354   const RecordDecl *RD = RT->getDecl();
5355 
5356   // If this is a union, remember that we had one, because it might mess
5357   // up the ordering of layout entries.
5358   if (RD->isUnion())
5359     IsDisordered = true;
5360 
5361   const ASTRecordLayout *recLayout = nullptr;
5362   visitAggregate(RD->field_begin(), RD->field_end(), offset,
5363                  [&](const FieldDecl *field) -> CharUnits {
5364     if (!recLayout)
5365       recLayout = &CGM.getContext().getASTRecordLayout(RD);
5366     auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
5367     return CGM.getContext().toCharUnitsFromBits(offsetInBits);
5368   });
5369 }
5370 
5371 template <class Iterator, class GetOffsetFn>
5372 void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
5373                                        CharUnits aggregateOffset,
5374                                        const GetOffsetFn &getOffset) {
5375   for (; begin != end; ++begin) {
5376     auto field = *begin;
5377 
5378     // Skip over bitfields.
5379     if (field->isBitField()) {
5380       continue;
5381     }
5382 
5383     // Compute the offset of the field within the aggregate.
5384     CharUnits fieldOffset = aggregateOffset + getOffset(field);
5385 
5386     visitField(field, fieldOffset);
5387   }
5388 }
5389 
5390 /// Collect layout information for the given fields into IvarsInfo.
5391 void IvarLayoutBuilder::visitField(const FieldDecl *field,
5392                                    CharUnits fieldOffset) {
5393   QualType fieldType = field->getType();
5394 
5395   // Drill down into arrays.
5396   uint64_t numElts = 1;
5397   if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) {
5398     numElts = 0;
5399     fieldType = arrayType->getElementType();
5400   }
5401   // Unlike incomplete arrays, constant arrays can be nested.
5402   while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
5403     numElts *= arrayType->getSize().getZExtValue();
5404     fieldType = arrayType->getElementType();
5405   }
5406 
5407   assert(!fieldType->isArrayType() && "ivar of non-constant array type?");
5408 
5409   // If we ended up with a zero-sized array, we've done what we can do within
5410   // the limits of this layout encoding.
5411   if (numElts == 0) return;
5412 
5413   // Recurse if the base element type is a record type.
5414   if (auto recType = fieldType->getAs<RecordType>()) {
5415     size_t oldEnd = IvarsInfo.size();
5416 
5417     visitRecord(recType, fieldOffset);
5418 
5419     // If we have an array, replicate the first entry's layout information.
5420     auto numEltEntries = IvarsInfo.size() - oldEnd;
5421     if (numElts != 1 && numEltEntries != 0) {
5422       CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5423       for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
5424         // Copy the last numEltEntries onto the end of the array, adjusting
5425         // each for the element size.
5426         for (size_t i = 0; i != numEltEntries; ++i) {
5427           auto firstEntry = IvarsInfo[oldEnd + i];
5428           IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
5429                                        firstEntry.SizeInWords));
5430         }
5431       }
5432     }
5433 
5434     return;
5435   }
5436 
5437   // Classify the element type.
5438   Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
5439 
5440   // If it matches what we're looking for, add an entry.
5441   if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
5442       || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
5443     assert(CGM.getContext().getTypeSizeInChars(fieldType)
5444              == CGM.getPointerSize());
5445     IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
5446   }
5447 }
5448 
5449 /// buildBitmap - This routine does the horsework of taking the offsets of
5450 /// strong/weak references and creating a bitmap.  The bitmap is also
5451 /// returned in the given buffer, suitable for being passed to \c dump().
5452 llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
5453                                 llvm::SmallVectorImpl<unsigned char> &buffer) {
5454   // The bitmap is a series of skip/scan instructions, aligned to word
5455   // boundaries.  The skip is performed first.
5456   const unsigned char MaxNibble = 0xF;
5457   const unsigned char SkipMask = 0xF0, SkipShift = 4;
5458   const unsigned char ScanMask = 0x0F, ScanShift = 0;
5459 
5460   assert(!IvarsInfo.empty() && "generating bitmap for no data");
5461 
5462   // Sort the ivar info on byte position in case we encounterred a
5463   // union nested in the ivar list.
5464   if (IsDisordered) {
5465     // This isn't a stable sort, but our algorithm should handle it fine.
5466     llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
5467   } else {
5468     assert(llvm::is_sorted(IvarsInfo));
5469   }
5470   assert(IvarsInfo.back().Offset < InstanceEnd);
5471 
5472   assert(buffer.empty());
5473 
5474   // Skip the next N words.
5475   auto skip = [&](unsigned numWords) {
5476     assert(numWords > 0);
5477 
5478     // Try to merge into the previous byte.  Since scans happen second, we
5479     // can't do this if it includes a scan.
5480     if (!buffer.empty() && !(buffer.back() & ScanMask)) {
5481       unsigned lastSkip = buffer.back() >> SkipShift;
5482       if (lastSkip < MaxNibble) {
5483         unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
5484         numWords -= claimed;
5485         lastSkip += claimed;
5486         buffer.back() = (lastSkip << SkipShift);
5487       }
5488     }
5489 
5490     while (numWords >= MaxNibble) {
5491       buffer.push_back(MaxNibble << SkipShift);
5492       numWords -= MaxNibble;
5493     }
5494     if (numWords) {
5495       buffer.push_back(numWords << SkipShift);
5496     }
5497   };
5498 
5499   // Scan the next N words.
5500   auto scan = [&](unsigned numWords) {
5501     assert(numWords > 0);
5502 
5503     // Try to merge into the previous byte.  Since scans happen second, we can
5504     // do this even if it includes a skip.
5505     if (!buffer.empty()) {
5506       unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
5507       if (lastScan < MaxNibble) {
5508         unsigned claimed = std::min(MaxNibble - lastScan, numWords);
5509         numWords -= claimed;
5510         lastScan += claimed;
5511         buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
5512       }
5513     }
5514 
5515     while (numWords >= MaxNibble) {
5516       buffer.push_back(MaxNibble << ScanShift);
5517       numWords -= MaxNibble;
5518     }
5519     if (numWords) {
5520       buffer.push_back(numWords << ScanShift);
5521     }
5522   };
5523 
5524   // One past the end of the last scan.
5525   unsigned endOfLastScanInWords = 0;
5526   const CharUnits WordSize = CGM.getPointerSize();
5527 
5528   // Consider all the scan requests.
5529   for (auto &request : IvarsInfo) {
5530     CharUnits beginOfScan = request.Offset - InstanceBegin;
5531 
5532     // Ignore scan requests that don't start at an even multiple of the
5533     // word size.  We can't encode them.
5534     if ((beginOfScan % WordSize) != 0) continue;
5535 
5536     // Ignore scan requests that start before the instance start.
5537     // This assumes that scans never span that boundary.  The boundary
5538     // isn't the true start of the ivars, because in the fragile-ARC case
5539     // it's rounded up to word alignment, but the test above should leave
5540     // us ignoring that possibility.
5541     if (beginOfScan.isNegative()) {
5542       assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin);
5543       continue;
5544     }
5545 
5546     unsigned beginOfScanInWords = beginOfScan / WordSize;
5547     unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
5548 
5549     // If the scan starts some number of words after the last one ended,
5550     // skip forward.
5551     if (beginOfScanInWords > endOfLastScanInWords) {
5552       skip(beginOfScanInWords - endOfLastScanInWords);
5553 
5554     // Otherwise, start scanning where the last left off.
5555     } else {
5556       beginOfScanInWords = endOfLastScanInWords;
5557 
5558       // If that leaves us with nothing to scan, ignore this request.
5559       if (beginOfScanInWords >= endOfScanInWords) continue;
5560     }
5561 
5562     // Scan to the end of the request.
5563     assert(beginOfScanInWords < endOfScanInWords);
5564     scan(endOfScanInWords - beginOfScanInWords);
5565     endOfLastScanInWords = endOfScanInWords;
5566   }
5567 
5568   if (buffer.empty())
5569     return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
5570 
5571   // For GC layouts, emit a skip to the end of the allocation so that we
5572   // have precise information about the entire thing.  This isn't useful
5573   // or necessary for the ARC-style layout strings.
5574   if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5575     unsigned lastOffsetInWords =
5576       (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5577     if (lastOffsetInWords > endOfLastScanInWords) {
5578       skip(lastOffsetInWords - endOfLastScanInWords);
5579     }
5580   }
5581 
5582   // Null terminate the string.
5583   buffer.push_back(0);
5584 
5585   auto *Entry = CGObjC.CreateCStringLiteral(
5586       reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
5587   return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5588 }
5589 
5590 /// BuildIvarLayout - Builds ivar layout bitmap for the class
5591 /// implementation for the __strong or __weak case.
5592 /// The layout map displays which words in ivar list must be skipped
5593 /// and which must be scanned by GC (see below). String is built of bytes.
5594 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5595 /// of words to skip and right nibble is count of words to scan. So, each
5596 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5597 /// represented by a 0x00 byte which also ends the string.
5598 /// 1. when ForStrongLayout is true, following ivars are scanned:
5599 /// - id, Class
5600 /// - object *
5601 /// - __strong anything
5602 ///
5603 /// 2. When ForStrongLayout is false, following ivars are scanned:
5604 /// - __weak anything
5605 ///
5606 llvm::Constant *
5607 CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
5608                                  CharUnits beginOffset, CharUnits endOffset,
5609                                  bool ForStrongLayout, bool HasMRCWeakIvars) {
5610   // If this is MRC, and we're either building a strong layout or there
5611   // are no weak ivars, bail out early.
5612   llvm::Type *PtrTy = CGM.Int8PtrTy;
5613   if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5614       !CGM.getLangOpts().ObjCAutoRefCount &&
5615       (ForStrongLayout || !HasMRCWeakIvars))
5616     return llvm::Constant::getNullValue(PtrTy);
5617 
5618   const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5619   SmallVector<const ObjCIvarDecl*, 32> ivars;
5620 
5621   // GC layout strings include the complete object layout, possibly
5622   // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5623   // up.
5624   //
5625   // ARC layout strings only include the class's ivars.  In non-fragile
5626   // runtimes, that means starting at InstanceStart, rounded up to word
5627   // alignment.  In fragile runtimes, there's no InstanceStart, so it means
5628   // starting at the offset of the first ivar, rounded up to word alignment.
5629   //
5630   // MRC weak layout strings follow the ARC style.
5631   CharUnits baseOffset;
5632   if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5633     for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5634          IVD; IVD = IVD->getNextIvar())
5635       ivars.push_back(IVD);
5636 
5637     if (isNonFragileABI()) {
5638       baseOffset = beginOffset; // InstanceStart
5639     } else if (!ivars.empty()) {
5640       baseOffset =
5641         CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5642     } else {
5643       baseOffset = CharUnits::Zero();
5644     }
5645 
5646     baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5647   }
5648   else {
5649     CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5650 
5651     baseOffset = CharUnits::Zero();
5652   }
5653 
5654   if (ivars.empty())
5655     return llvm::Constant::getNullValue(PtrTy);
5656 
5657   IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5658 
5659   builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5660                          [&](const ObjCIvarDecl *ivar) -> CharUnits {
5661       return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5662   });
5663 
5664   if (!builder.hasBitmapData())
5665     return llvm::Constant::getNullValue(PtrTy);
5666 
5667   llvm::SmallVector<unsigned char, 4> buffer;
5668   llvm::Constant *C = builder.buildBitmap(*this, buffer);
5669 
5670    if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5671     printf("\n%s ivar layout for class '%s': ",
5672            ForStrongLayout ? "strong" : "weak",
5673            OMD->getClassInterface()->getName().str().c_str());
5674     builder.dump(buffer);
5675   }
5676   return C;
5677 }
5678 
5679 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5680   llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5681   // FIXME: Avoid std::string in "Sel.getAsString()"
5682   if (!Entry)
5683     Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
5684   return getConstantGEP(VMContext, Entry, 0, 0);
5685 }
5686 
5687 // FIXME: Merge into a single cstring creation function.
5688 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5689   return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5690 }
5691 
5692 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5693   std::string TypeStr;
5694   CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5695 
5696   llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5697   if (!Entry)
5698     Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5699   return getConstantGEP(VMContext, Entry, 0, 0);
5700 }
5701 
5702 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5703                                                   bool Extended) {
5704   std::string TypeStr =
5705     CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);
5706 
5707   llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5708   if (!Entry)
5709     Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5710   return getConstantGEP(VMContext, Entry, 0, 0);
5711 }
5712 
5713 // FIXME: Merge into a single cstring creation function.
5714 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5715   llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5716   if (!Entry)
5717     Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
5718   return getConstantGEP(VMContext, Entry, 0, 0);
5719 }
5720 
5721 // FIXME: Merge into a single cstring creation function.
5722 // FIXME: This Decl should be more precise.
5723 llvm::Constant *
5724 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5725                                        const Decl *Container) {
5726   std::string TypeStr =
5727     CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
5728   return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5729 }
5730 
5731 void CGObjCMac::FinishModule() {
5732   EmitModuleInfo();
5733 
5734   // Emit the dummy bodies for any protocols which were referenced but
5735   // never defined.
5736   for (auto &entry : Protocols) {
5737     llvm::GlobalVariable *global = entry.second;
5738     if (global->hasInitializer())
5739       continue;
5740 
5741     ConstantInitBuilder builder(CGM);
5742     auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
5743     values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
5744     values.add(GetClassName(entry.first->getName()));
5745     values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
5746     values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5747     values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5748     values.finishAndSetAsInitializer(global);
5749     CGM.addCompilerUsedGlobal(global);
5750   }
5751 
5752   // Add assembler directives to add lazy undefined symbol references
5753   // for classes which are referenced but not defined. This is
5754   // important for correct linker interaction.
5755   //
5756   // FIXME: It would be nice if we had an LLVM construct for this.
5757   if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
5758       CGM.getTriple().isOSBinFormatMachO()) {
5759     SmallString<256> Asm;
5760     Asm += CGM.getModule().getModuleInlineAsm();
5761     if (!Asm.empty() && Asm.back() != '\n')
5762       Asm += '\n';
5763 
5764     llvm::raw_svector_ostream OS(Asm);
5765     for (const auto *Sym : DefinedSymbols)
5766       OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
5767          << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
5768     for (const auto *Sym : LazySymbols)
5769       OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
5770     for (const auto &Category : DefinedCategoryNames)
5771       OS << "\t.objc_category_name_" << Category << "=0\n"
5772          << "\t.globl .objc_category_name_" << Category << "\n";
5773 
5774     CGM.getModule().setModuleInlineAsm(OS.str());
5775   }
5776 }
5777 
5778 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5779     : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
5780       ObjCEmptyVtableVar(nullptr) {
5781   ObjCABI = 2;
5782 }
5783 
5784 /* *** */
5785 
5786 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5787   : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5788 {
5789   CodeGen::CodeGenTypes &Types = CGM.getTypes();
5790   ASTContext &Ctx = CGM.getContext();
5791 
5792   ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
5793   IntTy = CGM.IntTy;
5794   LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
5795   Int8PtrTy = CGM.Int8PtrTy;
5796   Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5797 
5798   // arm64 targets use "int" ivar offset variables. All others,
5799   // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5800   if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5801     IvarOffsetVarTy = IntTy;
5802   else
5803     IvarOffsetVarTy = LongTy;
5804 
5805   ObjectPtrTy =
5806     cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
5807   PtrObjectPtrTy =
5808     llvm::PointerType::getUnqual(ObjectPtrTy);
5809   SelectorPtrTy =
5810     cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
5811 
5812   // I'm not sure I like this. The implicit coordination is a bit
5813   // gross. We should solve this in a reasonable fashion because this
5814   // is a pretty common task (match some runtime data structure with
5815   // an LLVM data structure).
5816 
5817   // FIXME: This is leaked.
5818   // FIXME: Merge with rewriter code?
5819 
5820   // struct _objc_super {
5821   //   id self;
5822   //   Class cls;
5823   // }
5824   RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5825                                       Ctx.getTranslationUnitDecl(),
5826                                       SourceLocation(), SourceLocation(),
5827                                       &Ctx.Idents.get("_objc_super"));
5828   RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5829                                 nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5830                                 false, ICIS_NoInit));
5831   RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5832                                 nullptr, Ctx.getObjCClassType(), nullptr,
5833                                 nullptr, false, ICIS_NoInit));
5834   RD->completeDefinition();
5835 
5836   SuperCTy = Ctx.getTagDeclType(RD);
5837   SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5838 
5839   SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5840   SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5841 
5842   // struct _prop_t {
5843   //   char *name;
5844   //   char *attributes;
5845   // }
5846   PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy);
5847 
5848   // struct _prop_list_t {
5849   //   uint32_t entsize;      // sizeof(struct _prop_t)
5850   //   uint32_t count_of_properties;
5851   //   struct _prop_t prop_list[count_of_properties];
5852   // }
5853   PropertyListTy = llvm::StructType::create(
5854       "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0));
5855   // struct _prop_list_t *
5856   PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5857 
5858   // struct _objc_method {
5859   //   SEL _cmd;
5860   //   char *method_type;
5861   //   char *_imp;
5862   // }
5863   MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy,
5864                                       Int8PtrTy, Int8PtrTy);
5865 
5866   // struct _objc_cache *
5867   CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5868   CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5869 }
5870 
5871 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5872   : ObjCCommonTypesHelper(cgm) {
5873   // struct _objc_method_description {
5874   //   SEL name;
5875   //   char *types;
5876   // }
5877   MethodDescriptionTy = llvm::StructType::create(
5878       "struct._objc_method_description", SelectorPtrTy, Int8PtrTy);
5879 
5880   // struct _objc_method_description_list {
5881   //   int count;
5882   //   struct _objc_method_description[1];
5883   // }
5884   MethodDescriptionListTy =
5885       llvm::StructType::create("struct._objc_method_description_list", IntTy,
5886                                llvm::ArrayType::get(MethodDescriptionTy, 0));
5887 
5888   // struct _objc_method_description_list *
5889   MethodDescriptionListPtrTy =
5890     llvm::PointerType::getUnqual(MethodDescriptionListTy);
5891 
5892   // Protocol description structures
5893 
5894   // struct _objc_protocol_extension {
5895   //   uint32_t size;  // sizeof(struct _objc_protocol_extension)
5896   //   struct _objc_method_description_list *optional_instance_methods;
5897   //   struct _objc_method_description_list *optional_class_methods;
5898   //   struct _objc_property_list *instance_properties;
5899   //   const char ** extendedMethodTypes;
5900   //   struct _objc_property_list *class_properties;
5901   // }
5902   ProtocolExtensionTy = llvm::StructType::create(
5903       "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy,
5904       MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy,
5905       PropertyListPtrTy);
5906 
5907   // struct _objc_protocol_extension *
5908   ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5909 
5910   // Handle recursive construction of Protocol and ProtocolList types
5911 
5912   ProtocolTy =
5913     llvm::StructType::create(VMContext, "struct._objc_protocol");
5914 
5915   ProtocolListTy =
5916     llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5917   ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy,
5918                           llvm::ArrayType::get(ProtocolTy, 0));
5919 
5920   // struct _objc_protocol {
5921   //   struct _objc_protocol_extension *isa;
5922   //   char *protocol_name;
5923   //   struct _objc_protocol **_objc_protocol_list;
5924   //   struct _objc_method_description_list *instance_methods;
5925   //   struct _objc_method_description_list *class_methods;
5926   // }
5927   ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5928                       llvm::PointerType::getUnqual(ProtocolListTy),
5929                       MethodDescriptionListPtrTy, MethodDescriptionListPtrTy);
5930 
5931   // struct _objc_protocol_list *
5932   ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5933 
5934   ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5935 
5936   // Class description structures
5937 
5938   // struct _objc_ivar {
5939   //   char *ivar_name;
5940   //   char *ivar_type;
5941   //   int  ivar_offset;
5942   // }
5943   IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy,
5944                                     IntTy);
5945 
5946   // struct _objc_ivar_list *
5947   IvarListTy =
5948     llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5949   IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5950 
5951   // struct _objc_method_list *
5952   MethodListTy =
5953     llvm::StructType::create(VMContext, "struct._objc_method_list");
5954   MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5955 
5956   // struct _objc_class_extension *
5957   ClassExtensionTy = llvm::StructType::create(
5958       "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy);
5959   ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5960 
5961   ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5962 
5963   // struct _objc_class {
5964   //   Class isa;
5965   //   Class super_class;
5966   //   char *name;
5967   //   long version;
5968   //   long info;
5969   //   long instance_size;
5970   //   struct _objc_ivar_list *ivars;
5971   //   struct _objc_method_list *methods;
5972   //   struct _objc_cache *cache;
5973   //   struct _objc_protocol_list *protocols;
5974   //   char *ivar_layout;
5975   //   struct _objc_class_ext *ext;
5976   // };
5977   ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5978                    llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy,
5979                    LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy,
5980                    ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy);
5981 
5982   ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5983 
5984   // struct _objc_category {
5985   //   char *category_name;
5986   //   char *class_name;
5987   //   struct _objc_method_list *instance_method;
5988   //   struct _objc_method_list *class_method;
5989   //   struct _objc_protocol_list *protocols;
5990   //   uint32_t size;  // sizeof(struct _objc_category)
5991   //   struct _objc_property_list *instance_properties;// category's @property
5992   //   struct _objc_property_list *class_properties;
5993   // }
5994   CategoryTy = llvm::StructType::create(
5995       "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5996       MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy,
5997       PropertyListPtrTy);
5998 
5999   // Global metadata structures
6000 
6001   // struct _objc_symtab {
6002   //   long sel_ref_cnt;
6003   //   SEL *refs;
6004   //   short cls_def_cnt;
6005   //   short cat_def_cnt;
6006   //   char *defs[cls_def_cnt + cat_def_cnt];
6007   // }
6008   SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy,
6009                                       SelectorPtrTy, ShortTy, ShortTy,
6010                                       llvm::ArrayType::get(Int8PtrTy, 0));
6011   SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
6012 
6013   // struct _objc_module {
6014   //   long version;
6015   //   long size;   // sizeof(struct _objc_module)
6016   //   char *name;
6017   //   struct _objc_symtab* symtab;
6018   //  }
6019   ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy,
6020                                       Int8PtrTy, SymtabPtrTy);
6021 
6022   // FIXME: This is the size of the setjmp buffer and should be target
6023   // specific. 18 is what's used on 32-bit X86.
6024   uint64_t SetJmpBufferSize = 18;
6025 
6026   // Exceptions
6027   llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
6028 
6029   ExceptionDataTy = llvm::StructType::create(
6030       "struct._objc_exception_data",
6031       llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy);
6032 }
6033 
6034 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
6035   : ObjCCommonTypesHelper(cgm) {
6036   // struct _method_list_t {
6037   //   uint32_t entsize;  // sizeof(struct _objc_method)
6038   //   uint32_t method_count;
6039   //   struct _objc_method method_list[method_count];
6040   // }
6041   MethodListnfABITy =
6042       llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
6043                                llvm::ArrayType::get(MethodTy, 0));
6044   // struct method_list_t *
6045   MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
6046 
6047   // struct _protocol_t {
6048   //   id isa;  // NULL
6049   //   const char * const protocol_name;
6050   //   const struct _protocol_list_t * protocol_list; // super protocols
6051   //   const struct method_list_t * const instance_methods;
6052   //   const struct method_list_t * const class_methods;
6053   //   const struct method_list_t *optionalInstanceMethods;
6054   //   const struct method_list_t *optionalClassMethods;
6055   //   const struct _prop_list_t * properties;
6056   //   const uint32_t size;  // sizeof(struct _protocol_t)
6057   //   const uint32_t flags;  // = 0
6058   //   const char ** extendedMethodTypes;
6059   //   const char *demangledName;
6060   //   const struct _prop_list_t * class_properties;
6061   // }
6062 
6063   // Holder for struct _protocol_list_t *
6064   ProtocolListnfABITy =
6065     llvm::StructType::create(VMContext, "struct._objc_protocol_list");
6066 
6067   ProtocolnfABITy = llvm::StructType::create(
6068       "struct._protocol_t", ObjectPtrTy, Int8PtrTy,
6069       llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy,
6070       MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy,
6071       PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy,
6072       PropertyListPtrTy);
6073 
6074   // struct _protocol_t*
6075   ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
6076 
6077   // struct _protocol_list_t {
6078   //   long protocol_count;   // Note, this is 32/64 bit
6079   //   struct _protocol_t *[protocol_count];
6080   // }
6081   ProtocolListnfABITy->setBody(LongTy,
6082                                llvm::ArrayType::get(ProtocolnfABIPtrTy, 0));
6083 
6084   // struct _objc_protocol_list*
6085   ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
6086 
6087   // struct _ivar_t {
6088   //   unsigned [long] int *offset;  // pointer to ivar offset location
6089   //   char *name;
6090   //   char *type;
6091   //   uint32_t alignment;
6092   //   uint32_t size;
6093   // }
6094   IvarnfABITy = llvm::StructType::create(
6095       "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
6096       Int8PtrTy, Int8PtrTy, IntTy, IntTy);
6097 
6098   // struct _ivar_list_t {
6099   //   uint32 entsize;  // sizeof(struct _ivar_t)
6100   //   uint32 count;
6101   //   struct _iver_t list[count];
6102   // }
6103   IvarListnfABITy =
6104       llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
6105                                llvm::ArrayType::get(IvarnfABITy, 0));
6106 
6107   IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
6108 
6109   // struct _class_ro_t {
6110   //   uint32_t const flags;
6111   //   uint32_t const instanceStart;
6112   //   uint32_t const instanceSize;
6113   //   uint32_t const reserved;  // only when building for 64bit targets
6114   //   const uint8_t * const ivarLayout;
6115   //   const char *const name;
6116   //   const struct _method_list_t * const baseMethods;
6117   //   const struct _objc_protocol_list *const baseProtocols;
6118   //   const struct _ivar_list_t *const ivars;
6119   //   const uint8_t * const weakIvarLayout;
6120   //   const struct _prop_list_t * const properties;
6121   // }
6122 
6123   // FIXME. Add 'reserved' field in 64bit abi mode!
6124   ClassRonfABITy = llvm::StructType::create(
6125       "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy,
6126       MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy,
6127       Int8PtrTy, PropertyListPtrTy);
6128 
6129   // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
6130   llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
6131   ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
6132                  ->getPointerTo();
6133 
6134   // struct _class_t {
6135   //   struct _class_t *isa;
6136   //   struct _class_t * const superclass;
6137   //   void *cache;
6138   //   IMP *vtable;
6139   //   struct class_ro_t *ro;
6140   // }
6141 
6142   ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
6143   ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
6144                         llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy,
6145                         llvm::PointerType::getUnqual(ImpnfABITy),
6146                         llvm::PointerType::getUnqual(ClassRonfABITy));
6147 
6148   // LLVM for struct _class_t *
6149   ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
6150 
6151   // struct _category_t {
6152   //   const char * const name;
6153   //   struct _class_t *const cls;
6154   //   const struct _method_list_t * const instance_methods;
6155   //   const struct _method_list_t * const class_methods;
6156   //   const struct _protocol_list_t * const protocols;
6157   //   const struct _prop_list_t * const properties;
6158   //   const struct _prop_list_t * const class_properties;
6159   //   const uint32_t size;
6160   // }
6161   CategorynfABITy = llvm::StructType::create(
6162       "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy,
6163       MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy,
6164       PropertyListPtrTy, IntTy);
6165 
6166   // New types for nonfragile abi messaging.
6167   CodeGen::CodeGenTypes &Types = CGM.getTypes();
6168   ASTContext &Ctx = CGM.getContext();
6169 
6170   // MessageRefTy - LLVM for:
6171   // struct _message_ref_t {
6172   //   IMP messenger;
6173   //   SEL name;
6174   // };
6175 
6176   // First the clang type for struct _message_ref_t
6177   RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
6178                                       Ctx.getTranslationUnitDecl(),
6179                                       SourceLocation(), SourceLocation(),
6180                                       &Ctx.Idents.get("_message_ref_t"));
6181   RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
6182                                 nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
6183                                 ICIS_NoInit));
6184   RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
6185                                 nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
6186                                 false, ICIS_NoInit));
6187   RD->completeDefinition();
6188 
6189   MessageRefCTy = Ctx.getTagDeclType(RD);
6190   MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
6191   MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
6192 
6193   // MessageRefPtrTy - LLVM for struct _message_ref_t*
6194   MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
6195 
6196   // SuperMessageRefTy - LLVM for:
6197   // struct _super_message_ref_t {
6198   //   SUPER_IMP messenger;
6199   //   SEL name;
6200   // };
6201   SuperMessageRefTy = llvm::StructType::create("struct._super_message_ref_t",
6202                                                ImpnfABITy, SelectorPtrTy);
6203 
6204   // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
6205   SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
6206 
6207 
6208   // struct objc_typeinfo {
6209   //   const void** vtable; // objc_ehtype_vtable + 2
6210   //   const char*  name;    // c++ typeinfo string
6211   //   Class        cls;
6212   // };
6213   EHTypeTy = llvm::StructType::create("struct._objc_typeinfo",
6214                                       llvm::PointerType::getUnqual(Int8PtrTy),
6215                                       Int8PtrTy, ClassnfABIPtrTy);
6216   EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
6217 }
6218 
6219 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
6220   FinishNonFragileABIModule();
6221 
6222   return nullptr;
6223 }
6224 
6225 void CGObjCNonFragileABIMac::AddModuleClassList(
6226     ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName,
6227     StringRef SectionName) {
6228   unsigned NumClasses = Container.size();
6229 
6230   if (!NumClasses)
6231     return;
6232 
6233   SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
6234   for (unsigned i=0; i<NumClasses; i++)
6235     Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
6236                                                 ObjCTypes.Int8PtrTy);
6237   llvm::Constant *Init =
6238     llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
6239                                                   Symbols.size()),
6240                              Symbols);
6241 
6242   // Section name is obtained by calling GetSectionName, which returns
6243   // sections in the __DATA segment on MachO.
6244   assert((!CGM.getTriple().isOSBinFormatMachO() ||
6245           SectionName.startswith("__DATA")) &&
6246          "SectionName expected to start with __DATA on MachO");
6247   llvm::GlobalVariable *GV = new llvm::GlobalVariable(
6248       CGM.getModule(), Init->getType(), false,
6249       llvm::GlobalValue::PrivateLinkage, Init, SymbolName);
6250   GV->setAlignment(
6251       llvm::Align(CGM.getDataLayout().getABITypeAlignment(Init->getType())));
6252   GV->setSection(SectionName);
6253   CGM.addCompilerUsedGlobal(GV);
6254 }
6255 
6256 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
6257   // nonfragile abi has no module definition.
6258 
6259   // Build list of all implemented class addresses in array
6260   // L_OBJC_LABEL_CLASS_$.
6261 
6262   for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
6263     const ObjCInterfaceDecl *ID = ImplementedClasses[i];
6264     assert(ID);
6265     if (ObjCImplementationDecl *IMP = ID->getImplementation())
6266       // We are implementing a weak imported interface. Give it external linkage
6267       if (ID->isWeakImported() && !IMP->isWeakImported()) {
6268         DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6269         DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6270       }
6271   }
6272 
6273   AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
6274                      GetSectionName("__objc_classlist",
6275                                     "regular,no_dead_strip"));
6276 
6277   AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$",
6278                      GetSectionName("__objc_nlclslist",
6279                                     "regular,no_dead_strip"));
6280 
6281   // Build list of all implemented category addresses in array
6282   // L_OBJC_LABEL_CATEGORY_$.
6283   AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$",
6284                      GetSectionName("__objc_catlist",
6285                                     "regular,no_dead_strip"));
6286   AddModuleClassList(DefinedStubCategories, "OBJC_LABEL_STUB_CATEGORY_$",
6287                      GetSectionName("__objc_catlist2",
6288                                     "regular,no_dead_strip"));
6289   AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$",
6290                      GetSectionName("__objc_nlcatlist",
6291                                     "regular,no_dead_strip"));
6292 
6293   EmitImageInfo();
6294 }
6295 
6296 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of
6297 /// VTableDispatchMethods; false otherwise. What this means is that
6298 /// except for the 19 selectors in the list, we generate 32bit-style
6299 /// message dispatch call for all the rest.
6300 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
6301   // At various points we've experimented with using vtable-based
6302   // dispatch for all methods.
6303   switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
6304   case CodeGenOptions::Legacy:
6305     return false;
6306   case CodeGenOptions::NonLegacy:
6307     return true;
6308   case CodeGenOptions::Mixed:
6309     break;
6310   }
6311 
6312   // If so, see whether this selector is in the white-list of things which must
6313   // use the new dispatch convention. We lazily build a dense set for this.
6314   if (VTableDispatchMethods.empty()) {
6315     VTableDispatchMethods.insert(GetNullarySelector("alloc"));
6316     VTableDispatchMethods.insert(GetNullarySelector("class"));
6317     VTableDispatchMethods.insert(GetNullarySelector("self"));
6318     VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
6319     VTableDispatchMethods.insert(GetNullarySelector("length"));
6320     VTableDispatchMethods.insert(GetNullarySelector("count"));
6321 
6322     // These are vtable-based if GC is disabled.
6323     // Optimistically use vtable dispatch for hybrid compiles.
6324     if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
6325       VTableDispatchMethods.insert(GetNullarySelector("retain"));
6326       VTableDispatchMethods.insert(GetNullarySelector("release"));
6327       VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
6328     }
6329 
6330     VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
6331     VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
6332     VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
6333     VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
6334     VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
6335     VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
6336     VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
6337 
6338     // These are vtable-based if GC is enabled.
6339     // Optimistically use vtable dispatch for hybrid compiles.
6340     if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
6341       VTableDispatchMethods.insert(GetNullarySelector("hash"));
6342       VTableDispatchMethods.insert(GetUnarySelector("addObject"));
6343 
6344       // "countByEnumeratingWithState:objects:count"
6345       IdentifierInfo *KeyIdents[] = {
6346         &CGM.getContext().Idents.get("countByEnumeratingWithState"),
6347         &CGM.getContext().Idents.get("objects"),
6348         &CGM.getContext().Idents.get("count")
6349       };
6350       VTableDispatchMethods.insert(
6351         CGM.getContext().Selectors.getSelector(3, KeyIdents));
6352     }
6353   }
6354 
6355   return VTableDispatchMethods.count(Sel);
6356 }
6357 
6358 /// BuildClassRoTInitializer - generate meta-data for:
6359 /// struct _class_ro_t {
6360 ///   uint32_t const flags;
6361 ///   uint32_t const instanceStart;
6362 ///   uint32_t const instanceSize;
6363 ///   uint32_t const reserved;  // only when building for 64bit targets
6364 ///   const uint8_t * const ivarLayout;
6365 ///   const char *const name;
6366 ///   const struct _method_list_t * const baseMethods;
6367 ///   const struct _protocol_list_t *const baseProtocols;
6368 ///   const struct _ivar_list_t *const ivars;
6369 ///   const uint8_t * const weakIvarLayout;
6370 ///   const struct _prop_list_t * const properties;
6371 /// }
6372 ///
6373 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
6374   unsigned flags,
6375   unsigned InstanceStart,
6376   unsigned InstanceSize,
6377   const ObjCImplementationDecl *ID) {
6378   std::string ClassName = std::string(ID->getObjCRuntimeNameAsString());
6379 
6380   CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
6381   CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
6382 
6383   bool hasMRCWeak = false;
6384   if (CGM.getLangOpts().ObjCAutoRefCount)
6385     flags |= NonFragileABI_Class_CompiledByARC;
6386   else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
6387     flags |= NonFragileABI_Class_HasMRCWeakIvars;
6388 
6389   ConstantInitBuilder builder(CGM);
6390   auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy);
6391 
6392   values.addInt(ObjCTypes.IntTy, flags);
6393   values.addInt(ObjCTypes.IntTy, InstanceStart);
6394   values.addInt(ObjCTypes.IntTy, InstanceSize);
6395   values.add((flags & NonFragileABI_Class_Meta)
6396                 ? GetIvarLayoutName(nullptr, ObjCTypes)
6397                 : BuildStrongIvarLayout(ID, beginInstance, endInstance));
6398   values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
6399 
6400   // const struct _method_list_t * const baseMethods;
6401   SmallVector<const ObjCMethodDecl*, 16> methods;
6402   if (flags & NonFragileABI_Class_Meta) {
6403     for (const auto *MD : ID->class_methods())
6404       if (!MD->isDirectMethod())
6405         methods.push_back(MD);
6406   } else {
6407     for (const auto *MD : ID->instance_methods())
6408       if (!MD->isDirectMethod())
6409         methods.push_back(MD);
6410   }
6411 
6412   values.add(emitMethodList(ID->getObjCRuntimeNameAsString(),
6413                             (flags & NonFragileABI_Class_Meta)
6414                                ? MethodListType::ClassMethods
6415                                : MethodListType::InstanceMethods,
6416                             methods));
6417 
6418   const ObjCInterfaceDecl *OID = ID->getClassInterface();
6419   assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
6420   values.add(EmitProtocolList("_OBJC_CLASS_PROTOCOLS_$_"
6421                                 + OID->getObjCRuntimeNameAsString(),
6422                               OID->all_referenced_protocol_begin(),
6423                               OID->all_referenced_protocol_end()));
6424 
6425   if (flags & NonFragileABI_Class_Meta) {
6426     values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy);
6427     values.add(GetIvarLayoutName(nullptr, ObjCTypes));
6428     values.add(EmitPropertyList(
6429         "_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6430         ID, ID->getClassInterface(), ObjCTypes, true));
6431   } else {
6432     values.add(EmitIvarList(ID));
6433     values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak));
6434     values.add(EmitPropertyList(
6435         "_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6436         ID, ID->getClassInterface(), ObjCTypes, false));
6437   }
6438 
6439   llvm::SmallString<64> roLabel;
6440   llvm::raw_svector_ostream(roLabel)
6441       << ((flags & NonFragileABI_Class_Meta) ? "_OBJC_METACLASS_RO_$_"
6442                                              : "_OBJC_CLASS_RO_$_")
6443       << ClassName;
6444 
6445   return finishAndCreateGlobal(values, roLabel, CGM);
6446 }
6447 
6448 /// Build the metaclass object for a class.
6449 ///
6450 /// struct _class_t {
6451 ///   struct _class_t *isa;
6452 ///   struct _class_t * const superclass;
6453 ///   void *cache;
6454 ///   IMP *vtable;
6455 ///   struct class_ro_t *ro;
6456 /// }
6457 ///
6458 llvm::GlobalVariable *
6459 CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI,
6460                                          bool isMetaclass,
6461                                          llvm::Constant *IsAGV,
6462                                          llvm::Constant *SuperClassGV,
6463                                          llvm::Constant *ClassRoGV,
6464                                          bool HiddenVisibility) {
6465   ConstantInitBuilder builder(CGM);
6466   auto values = builder.beginStruct(ObjCTypes.ClassnfABITy);
6467   values.add(IsAGV);
6468   if (SuperClassGV) {
6469     values.add(SuperClassGV);
6470   } else {
6471     values.addNullPointer(ObjCTypes.ClassnfABIPtrTy);
6472   }
6473   values.add(ObjCEmptyCacheVar);
6474   values.add(ObjCEmptyVtableVar);
6475   values.add(ClassRoGV);
6476 
6477   llvm::GlobalVariable *GV =
6478     cast<llvm::GlobalVariable>(GetClassGlobal(CI, isMetaclass, ForDefinition));
6479   values.finishAndSetAsInitializer(GV);
6480 
6481   if (CGM.getTriple().isOSBinFormatMachO())
6482     GV->setSection("__DATA, __objc_data");
6483   GV->setAlignment(llvm::Align(
6484       CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy)));
6485   if (!CGM.getTriple().isOSBinFormatCOFF())
6486     if (HiddenVisibility)
6487       GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6488   return GV;
6489 }
6490 
6491 bool CGObjCNonFragileABIMac::ImplementationIsNonLazy(
6492     const ObjCImplDecl *OD) const {
6493   return OD->getClassMethod(GetNullarySelector("load")) != nullptr ||
6494          OD->getClassInterface()->hasAttr<ObjCNonLazyClassAttr>() ||
6495          OD->hasAttr<ObjCNonLazyClassAttr>();
6496 }
6497 
6498 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
6499                                               uint32_t &InstanceStart,
6500                                               uint32_t &InstanceSize) {
6501   const ASTRecordLayout &RL =
6502     CGM.getContext().getASTObjCImplementationLayout(OID);
6503 
6504   // InstanceSize is really instance end.
6505   InstanceSize = RL.getDataSize().getQuantity();
6506 
6507   // If there are no fields, the start is the same as the end.
6508   if (!RL.getFieldCount())
6509     InstanceStart = InstanceSize;
6510   else
6511     InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
6512 }
6513 
6514 static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM,
6515                                                           StringRef Name) {
6516   IdentifierInfo &II = CGM.getContext().Idents.get(Name);
6517   TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
6518   DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
6519 
6520   const VarDecl *VD = nullptr;
6521   for (const auto &Result : DC->lookup(&II))
6522     if ((VD = dyn_cast<VarDecl>(Result)))
6523       break;
6524 
6525   if (!VD)
6526     return llvm::GlobalValue::DLLImportStorageClass;
6527   if (VD->hasAttr<DLLExportAttr>())
6528     return llvm::GlobalValue::DLLExportStorageClass;
6529   if (VD->hasAttr<DLLImportAttr>())
6530     return llvm::GlobalValue::DLLImportStorageClass;
6531   return llvm::GlobalValue::DefaultStorageClass;
6532 }
6533 
6534 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
6535   if (!ObjCEmptyCacheVar) {
6536     ObjCEmptyCacheVar =
6537         new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false,
6538                                  llvm::GlobalValue::ExternalLinkage, nullptr,
6539                                  "_objc_empty_cache");
6540     if (CGM.getTriple().isOSBinFormatCOFF())
6541       ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache"));
6542 
6543     // Only OS X with deployment version <10.9 use the empty vtable symbol
6544     const llvm::Triple &Triple = CGM.getTarget().getTriple();
6545     if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9))
6546       ObjCEmptyVtableVar =
6547           new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false,
6548                                    llvm::GlobalValue::ExternalLinkage, nullptr,
6549                                    "_objc_empty_vtable");
6550     else
6551       ObjCEmptyVtableVar =
6552         llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo());
6553   }
6554 
6555   // FIXME: Is this correct (that meta class size is never computed)?
6556   uint32_t InstanceStart =
6557     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
6558   uint32_t InstanceSize = InstanceStart;
6559   uint32_t flags = NonFragileABI_Class_Meta;
6560 
6561   llvm::Constant *SuperClassGV, *IsAGV;
6562 
6563   const auto *CI = ID->getClassInterface();
6564   assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0");
6565 
6566   // Build the flags for the metaclass.
6567   bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF())
6568                            ? !CI->hasAttr<DLLExportAttr>()
6569                            : CI->getVisibility() == HiddenVisibility;
6570   if (classIsHidden)
6571     flags |= NonFragileABI_Class_Hidden;
6572 
6573   // FIXME: why is this flag set on the metaclass?
6574   // ObjC metaclasses have no fields and don't really get constructed.
6575   if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6576     flags |= NonFragileABI_Class_HasCXXStructors;
6577     if (!ID->hasNonZeroConstructors())
6578       flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6579   }
6580 
6581   if (!CI->getSuperClass()) {
6582     // class is root
6583     flags |= NonFragileABI_Class_Root;
6584 
6585     SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition);
6586     IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition);
6587   } else {
6588     // Has a root. Current class is not a root.
6589     const ObjCInterfaceDecl *Root = ID->getClassInterface();
6590     while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
6591       Root = Super;
6592 
6593     const auto *Super = CI->getSuperClass();
6594     IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition);
6595     SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition);
6596   }
6597 
6598   llvm::GlobalVariable *CLASS_RO_GV =
6599       BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6600 
6601   llvm::GlobalVariable *MetaTClass =
6602     BuildClassObject(CI, /*metaclass*/ true,
6603                      IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden);
6604   CGM.setGVProperties(MetaTClass, CI);
6605   DefinedMetaClasses.push_back(MetaTClass);
6606 
6607   // Metadata for the class
6608   flags = 0;
6609   if (classIsHidden)
6610     flags |= NonFragileABI_Class_Hidden;
6611 
6612   if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6613     flags |= NonFragileABI_Class_HasCXXStructors;
6614 
6615     // Set a flag to enable a runtime optimization when a class has
6616     // fields that require destruction but which don't require
6617     // anything except zero-initialization during construction.  This
6618     // is most notably true of __strong and __weak types, but you can
6619     // also imagine there being C++ types with non-trivial default
6620     // constructors that merely set all fields to null.
6621     if (!ID->hasNonZeroConstructors())
6622       flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6623   }
6624 
6625   if (hasObjCExceptionAttribute(CGM.getContext(), CI))
6626     flags |= NonFragileABI_Class_Exception;
6627 
6628   if (!CI->getSuperClass()) {
6629     flags |= NonFragileABI_Class_Root;
6630     SuperClassGV = nullptr;
6631   } else {
6632     // Has a root. Current class is not a root.
6633     const auto *Super = CI->getSuperClass();
6634     SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition);
6635   }
6636 
6637   GetClassSizeInfo(ID, InstanceStart, InstanceSize);
6638   CLASS_RO_GV =
6639       BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6640 
6641   llvm::GlobalVariable *ClassMD =
6642     BuildClassObject(CI, /*metaclass*/ false,
6643                      MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden);
6644   CGM.setGVProperties(ClassMD, CI);
6645   DefinedClasses.push_back(ClassMD);
6646   ImplementedClasses.push_back(CI);
6647 
6648   // Determine if this class is also "non-lazy".
6649   if (ImplementationIsNonLazy(ID))
6650     DefinedNonLazyClasses.push_back(ClassMD);
6651 
6652   // Force the definition of the EHType if necessary.
6653   if (flags & NonFragileABI_Class_Exception)
6654     (void) GetInterfaceEHType(CI, ForDefinition);
6655   // Make sure method definition entries are all clear for next implementation.
6656   MethodDefinitions.clear();
6657 }
6658 
6659 /// GenerateProtocolRef - This routine is called to generate code for
6660 /// a protocol reference expression; as in:
6661 /// @code
6662 ///   @protocol(Proto1);
6663 /// @endcode
6664 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
6665 /// which will hold address of the protocol meta-data.
6666 ///
6667 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
6668                                                          const ObjCProtocolDecl *PD) {
6669 
6670   // This routine is called for @protocol only. So, we must build definition
6671   // of protocol's meta-data (not a reference to it!)
6672   assert(!PD->isNonRuntimeProtocol() &&
6673          "attempting to get a protocol ref to a static protocol.");
6674   llvm::Constant *Init =
6675     llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
6676                                    ObjCTypes.getExternalProtocolPtrTy());
6677 
6678   std::string ProtocolName("_OBJC_PROTOCOL_REFERENCE_$_");
6679   ProtocolName += PD->getObjCRuntimeNameAsString();
6680 
6681   CharUnits Align = CGF.getPointerAlign();
6682 
6683   llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
6684   if (PTGV)
6685     return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6686   PTGV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6687                                   llvm::GlobalValue::WeakAnyLinkage, Init,
6688                                   ProtocolName);
6689   PTGV->setSection(GetSectionName("__objc_protorefs",
6690                                   "coalesced,no_dead_strip"));
6691   PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6692   PTGV->setAlignment(Align.getAsAlign());
6693   if (!CGM.getTriple().isOSBinFormatMachO())
6694     PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolName));
6695   CGM.addUsedGlobal(PTGV);
6696   return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6697 }
6698 
6699 /// GenerateCategory - Build metadata for a category implementation.
6700 /// struct _category_t {
6701 ///   const char * const name;
6702 ///   struct _class_t *const cls;
6703 ///   const struct _method_list_t * const instance_methods;
6704 ///   const struct _method_list_t * const class_methods;
6705 ///   const struct _protocol_list_t * const protocols;
6706 ///   const struct _prop_list_t * const properties;
6707 ///   const struct _prop_list_t * const class_properties;
6708 ///   const uint32_t size;
6709 /// }
6710 ///
6711 void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
6712   const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
6713   const char *Prefix = "_OBJC_$_CATEGORY_";
6714 
6715   llvm::SmallString<64> ExtCatName(Prefix);
6716   ExtCatName += Interface->getObjCRuntimeNameAsString();
6717   ExtCatName += "_$_";
6718   ExtCatName += OCD->getNameAsString();
6719 
6720   ConstantInitBuilder builder(CGM);
6721   auto values = builder.beginStruct(ObjCTypes.CategorynfABITy);
6722   values.add(GetClassName(OCD->getIdentifier()->getName()));
6723   // meta-class entry symbol
6724   values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition));
6725   std::string listName =
6726       (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str();
6727 
6728   SmallVector<const ObjCMethodDecl *, 16> instanceMethods;
6729   SmallVector<const ObjCMethodDecl *, 8> classMethods;
6730   for (const auto *MD : OCD->methods()) {
6731     if (MD->isDirectMethod())
6732       continue;
6733     if (MD->isInstanceMethod()) {
6734       instanceMethods.push_back(MD);
6735     } else {
6736       classMethods.push_back(MD);
6737     }
6738   }
6739 
6740   values.add(emitMethodList(listName, MethodListType::CategoryInstanceMethods,
6741                             instanceMethods));
6742   values.add(emitMethodList(listName, MethodListType::CategoryClassMethods,
6743                             classMethods));
6744 
6745   const ObjCCategoryDecl *Category =
6746     Interface->FindCategoryDeclaration(OCD->getIdentifier());
6747   if (Category) {
6748     SmallString<256> ExtName;
6749     llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
6750                                        << OCD->getName();
6751     values.add(EmitProtocolList("_OBJC_CATEGORY_PROTOCOLS_$_"
6752                                    + Interface->getObjCRuntimeNameAsString() + "_$_"
6753                                    + Category->getName(),
6754                                 Category->protocol_begin(),
6755                                 Category->protocol_end()));
6756     values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
6757                                 OCD, Category, ObjCTypes, false));
6758     values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
6759                                 OCD, Category, ObjCTypes, true));
6760   } else {
6761     values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy);
6762     values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6763     values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6764   }
6765 
6766   unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy);
6767   values.addInt(ObjCTypes.IntTy, Size);
6768 
6769   llvm::GlobalVariable *GCATV =
6770       finishAndCreateGlobal(values, ExtCatName.str(), CGM);
6771   CGM.addCompilerUsedGlobal(GCATV);
6772   if (Interface->hasAttr<ObjCClassStubAttr>())
6773     DefinedStubCategories.push_back(GCATV);
6774   else
6775     DefinedCategories.push_back(GCATV);
6776 
6777   // Determine if this category is also "non-lazy".
6778   if (ImplementationIsNonLazy(OCD))
6779     DefinedNonLazyCategories.push_back(GCATV);
6780   // method definition entries must be clear for next implementation.
6781   MethodDefinitions.clear();
6782 }
6783 
6784 /// emitMethodConstant - Return a struct objc_method constant.  If
6785 /// forProtocol is true, the implementation will be null; otherwise,
6786 /// the method must have a definition registered with the runtime.
6787 ///
6788 /// struct _objc_method {
6789 ///   SEL _cmd;
6790 ///   char *method_type;
6791 ///   char *_imp;
6792 /// }
6793 void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
6794                                                 const ObjCMethodDecl *MD,
6795                                                 bool forProtocol) {
6796   auto method = builder.beginStruct(ObjCTypes.MethodTy);
6797   method.addBitCast(GetMethodVarName(MD->getSelector()),
6798                     ObjCTypes.SelectorPtrTy);
6799   method.add(GetMethodVarType(MD));
6800 
6801   if (forProtocol) {
6802     // Protocol methods have no implementation. So, this entry is always NULL.
6803     method.addNullPointer(ObjCTypes.Int8PtrTy);
6804   } else {
6805     llvm::Function *fn = GetMethodDefinition(MD);
6806     assert(fn && "no definition for method?");
6807     method.addBitCast(fn, ObjCTypes.Int8PtrTy);
6808   }
6809 
6810   method.finishAndAddTo(builder);
6811 }
6812 
6813 /// Build meta-data for method declarations.
6814 ///
6815 /// struct _method_list_t {
6816 ///   uint32_t entsize;  // sizeof(struct _objc_method)
6817 ///   uint32_t method_count;
6818 ///   struct _objc_method method_list[method_count];
6819 /// }
6820 ///
6821 llvm::Constant *
6822 CGObjCNonFragileABIMac::emitMethodList(Twine name, MethodListType kind,
6823                               ArrayRef<const ObjCMethodDecl *> methods) {
6824   // Return null for empty list.
6825   if (methods.empty())
6826     return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
6827 
6828   StringRef prefix;
6829   bool forProtocol;
6830   switch (kind) {
6831   case MethodListType::CategoryInstanceMethods:
6832     prefix = "_OBJC_$_CATEGORY_INSTANCE_METHODS_";
6833     forProtocol = false;
6834     break;
6835   case MethodListType::CategoryClassMethods:
6836     prefix = "_OBJC_$_CATEGORY_CLASS_METHODS_";
6837     forProtocol = false;
6838     break;
6839   case MethodListType::InstanceMethods:
6840     prefix = "_OBJC_$_INSTANCE_METHODS_";
6841     forProtocol = false;
6842     break;
6843   case MethodListType::ClassMethods:
6844     prefix = "_OBJC_$_CLASS_METHODS_";
6845     forProtocol = false;
6846     break;
6847 
6848   case MethodListType::ProtocolInstanceMethods:
6849     prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_";
6850     forProtocol = true;
6851     break;
6852   case MethodListType::ProtocolClassMethods:
6853     prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_";
6854     forProtocol = true;
6855     break;
6856   case MethodListType::OptionalProtocolInstanceMethods:
6857     prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_";
6858     forProtocol = true;
6859     break;
6860   case MethodListType::OptionalProtocolClassMethods:
6861     prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_";
6862     forProtocol = true;
6863     break;
6864   }
6865 
6866   ConstantInitBuilder builder(CGM);
6867   auto values = builder.beginStruct();
6868 
6869   // sizeof(struct _objc_method)
6870   unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
6871   values.addInt(ObjCTypes.IntTy, Size);
6872   // method_count
6873   values.addInt(ObjCTypes.IntTy, methods.size());
6874   auto methodArray = values.beginArray(ObjCTypes.MethodTy);
6875   for (auto MD : methods)
6876     emitMethodConstant(methodArray, MD, forProtocol);
6877   methodArray.finishAndAddTo(values);
6878 
6879   llvm::GlobalVariable *GV = finishAndCreateGlobal(values, prefix + name, CGM);
6880   CGM.addCompilerUsedGlobal(GV);
6881   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6882 }
6883 
6884 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6885 /// the given ivar.
6886 llvm::GlobalVariable *
6887 CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
6888                                                const ObjCIvarDecl *Ivar) {
6889   const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
6890   llvm::SmallString<64> Name("OBJC_IVAR_$_");
6891   Name += Container->getObjCRuntimeNameAsString();
6892   Name += ".";
6893   Name += Ivar->getName();
6894   llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name);
6895   if (!IvarOffsetGV) {
6896     IvarOffsetGV =
6897         new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.IvarOffsetVarTy,
6898                                  false, llvm::GlobalValue::ExternalLinkage,
6899                                  nullptr, Name.str());
6900     if (CGM.getTriple().isOSBinFormatCOFF()) {
6901       bool IsPrivateOrPackage =
6902           Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6903           Ivar->getAccessControl() == ObjCIvarDecl::Package;
6904 
6905       const ObjCInterfaceDecl *ContainingID = Ivar->getContainingInterface();
6906 
6907       if (ContainingID->hasAttr<DLLImportAttr>())
6908         IvarOffsetGV
6909             ->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6910       else if (ContainingID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage)
6911         IvarOffsetGV
6912             ->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6913     }
6914   }
6915   return IvarOffsetGV;
6916 }
6917 
6918 llvm::Constant *
6919 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
6920                                           const ObjCIvarDecl *Ivar,
6921                                           unsigned long int Offset) {
6922   llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
6923   IvarOffsetGV->setInitializer(
6924       llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
6925   IvarOffsetGV->setAlignment(llvm::Align(
6926       CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy)));
6927 
6928   if (!CGM.getTriple().isOSBinFormatCOFF()) {
6929     // FIXME: This matches gcc, but shouldn't the visibility be set on the use
6930     // as well (i.e., in ObjCIvarOffsetVariable).
6931     if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6932         Ivar->getAccessControl() == ObjCIvarDecl::Package ||
6933         ID->getVisibility() == HiddenVisibility)
6934       IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6935     else
6936       IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
6937   }
6938 
6939   // If ID's layout is known, then make the global constant. This serves as a
6940   // useful assertion: we'll never use this variable to calculate ivar offsets,
6941   // so if the runtime tries to patch it then we should crash.
6942   if (isClassLayoutKnownStatically(ID))
6943     IvarOffsetGV->setConstant(true);
6944 
6945   if (CGM.getTriple().isOSBinFormatMachO())
6946     IvarOffsetGV->setSection("__DATA, __objc_ivar");
6947   return IvarOffsetGV;
6948 }
6949 
6950 /// EmitIvarList - Emit the ivar list for the given
6951 /// implementation. The return value has type
6952 /// IvarListnfABIPtrTy.
6953 ///  struct _ivar_t {
6954 ///   unsigned [long] int *offset;  // pointer to ivar offset location
6955 ///   char *name;
6956 ///   char *type;
6957 ///   uint32_t alignment;
6958 ///   uint32_t size;
6959 /// }
6960 /// struct _ivar_list_t {
6961 ///   uint32 entsize;  // sizeof(struct _ivar_t)
6962 ///   uint32 count;
6963 ///   struct _iver_t list[count];
6964 /// }
6965 ///
6966 
6967 llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
6968   const ObjCImplementationDecl *ID) {
6969 
6970   ConstantInitBuilder builder(CGM);
6971   auto ivarList = builder.beginStruct();
6972   ivarList.addInt(ObjCTypes.IntTy,
6973                   CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy));
6974   auto ivarCountSlot = ivarList.addPlaceholder();
6975   auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy);
6976 
6977   const ObjCInterfaceDecl *OID = ID->getClassInterface();
6978   assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
6979 
6980   // FIXME. Consolidate this with similar code in GenerateClass.
6981 
6982   for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
6983        IVD; IVD = IVD->getNextIvar()) {
6984     // Ignore unnamed bit-fields.
6985     if (!IVD->getDeclName())
6986       continue;
6987 
6988     auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy);
6989     ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD,
6990                                ComputeIvarBaseOffset(CGM, ID, IVD)));
6991     ivar.add(GetMethodVarName(IVD->getIdentifier()));
6992     ivar.add(GetMethodVarType(IVD));
6993     llvm::Type *FieldTy =
6994       CGM.getTypes().ConvertTypeForMem(IVD->getType());
6995     unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
6996     unsigned Align = CGM.getContext().getPreferredTypeAlign(
6997       IVD->getType().getTypePtr()) >> 3;
6998     Align = llvm::Log2_32(Align);
6999     ivar.addInt(ObjCTypes.IntTy, Align);
7000     // NOTE. Size of a bitfield does not match gcc's, because of the
7001     // way bitfields are treated special in each. But I am told that
7002     // 'size' for bitfield ivars is ignored by the runtime so it does
7003     // not matter.  If it matters, there is enough info to get the
7004     // bitfield right!
7005     ivar.addInt(ObjCTypes.IntTy, Size);
7006     ivar.finishAndAddTo(ivars);
7007   }
7008   // Return null for empty list.
7009   if (ivars.empty()) {
7010     ivars.abandon();
7011     ivarList.abandon();
7012     return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
7013   }
7014 
7015   auto ivarCount = ivars.size();
7016   ivars.finishAndAddTo(ivarList);
7017   ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount);
7018 
7019   const char *Prefix = "_OBJC_$_INSTANCE_VARIABLES_";
7020   llvm::GlobalVariable *GV = finishAndCreateGlobal(
7021       ivarList, Prefix + OID->getObjCRuntimeNameAsString(), CGM);
7022   CGM.addCompilerUsedGlobal(GV);
7023   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
7024 }
7025 
7026 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
7027   const ObjCProtocolDecl *PD) {
7028   llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
7029 
7030   assert(!PD->isNonRuntimeProtocol() &&
7031          "attempting to GetOrEmit a non-runtime protocol");
7032   if (!Entry) {
7033     // We use the initializer as a marker of whether this is a forward
7034     // reference or not. At module finalization we add the empty
7035     // contents for protocols which were referenced but never defined.
7036     llvm::SmallString<64> Protocol;
7037     llvm::raw_svector_ostream(Protocol) << "_OBJC_PROTOCOL_$_"
7038                                         << PD->getObjCRuntimeNameAsString();
7039 
7040     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
7041                                      false, llvm::GlobalValue::ExternalLinkage,
7042                                      nullptr, Protocol);
7043     if (!CGM.getTriple().isOSBinFormatMachO())
7044       Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol));
7045   }
7046 
7047   return Entry;
7048 }
7049 
7050 /// GetOrEmitProtocol - Generate the protocol meta-data:
7051 /// @code
7052 /// struct _protocol_t {
7053 ///   id isa;  // NULL
7054 ///   const char * const protocol_name;
7055 ///   const struct _protocol_list_t * protocol_list; // super protocols
7056 ///   const struct method_list_t * const instance_methods;
7057 ///   const struct method_list_t * const class_methods;
7058 ///   const struct method_list_t *optionalInstanceMethods;
7059 ///   const struct method_list_t *optionalClassMethods;
7060 ///   const struct _prop_list_t * properties;
7061 ///   const uint32_t size;  // sizeof(struct _protocol_t)
7062 ///   const uint32_t flags;  // = 0
7063 ///   const char ** extendedMethodTypes;
7064 ///   const char *demangledName;
7065 ///   const struct _prop_list_t * class_properties;
7066 /// }
7067 /// @endcode
7068 ///
7069 
7070 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
7071   const ObjCProtocolDecl *PD) {
7072   llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
7073 
7074   // Early exit if a defining object has already been generated.
7075   if (Entry && Entry->hasInitializer())
7076     return Entry;
7077 
7078   // Use the protocol definition, if there is one.
7079   assert(PD->hasDefinition() &&
7080          "emitting protocol metadata without definition");
7081   PD = PD->getDefinition();
7082 
7083   auto methodLists = ProtocolMethodLists::get(PD);
7084 
7085   ConstantInitBuilder builder(CGM);
7086   auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy);
7087 
7088   // isa is NULL
7089   values.addNullPointer(ObjCTypes.ObjectPtrTy);
7090   values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
7091   values.add(EmitProtocolList("_OBJC_$_PROTOCOL_REFS_"
7092                                 + PD->getObjCRuntimeNameAsString(),
7093                                PD->protocol_begin(),
7094                                PD->protocol_end()));
7095   values.add(methodLists.emitMethodList(this, PD,
7096                                  ProtocolMethodLists::RequiredInstanceMethods));
7097   values.add(methodLists.emitMethodList(this, PD,
7098                                  ProtocolMethodLists::RequiredClassMethods));
7099   values.add(methodLists.emitMethodList(this, PD,
7100                                  ProtocolMethodLists::OptionalInstanceMethods));
7101   values.add(methodLists.emitMethodList(this, PD,
7102                                  ProtocolMethodLists::OptionalClassMethods));
7103   values.add(EmitPropertyList(
7104                "_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
7105                nullptr, PD, ObjCTypes, false));
7106   uint32_t Size =
7107     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
7108   values.addInt(ObjCTypes.IntTy, Size);
7109   values.addInt(ObjCTypes.IntTy, 0);
7110   values.add(EmitProtocolMethodTypes("_OBJC_$_PROTOCOL_METHOD_TYPES_"
7111                                        + PD->getObjCRuntimeNameAsString(),
7112                                      methodLists.emitExtendedTypesArray(this),
7113                                      ObjCTypes));
7114 
7115   // const char *demangledName;
7116   values.addNullPointer(ObjCTypes.Int8PtrTy);
7117 
7118   values.add(EmitPropertyList(
7119       "_OBJC_$_CLASS_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
7120       nullptr, PD, ObjCTypes, true));
7121 
7122   if (Entry) {
7123     // Already created, fix the linkage and update the initializer.
7124     Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
7125     values.finishAndSetAsInitializer(Entry);
7126   } else {
7127     llvm::SmallString<64> symbolName;
7128     llvm::raw_svector_ostream(symbolName)
7129       << "_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString();
7130 
7131     Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(),
7132                                          /*constant*/ false,
7133                                          llvm::GlobalValue::WeakAnyLinkage);
7134     if (!CGM.getTriple().isOSBinFormatMachO())
7135       Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName));
7136 
7137     Protocols[PD->getIdentifier()] = Entry;
7138   }
7139   Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7140   CGM.addUsedGlobal(Entry);
7141 
7142   // Use this protocol meta-data to build protocol list table in section
7143   // __DATA, __objc_protolist
7144   llvm::SmallString<64> ProtocolRef;
7145   llvm::raw_svector_ostream(ProtocolRef) << "_OBJC_LABEL_PROTOCOL_$_"
7146                                          << PD->getObjCRuntimeNameAsString();
7147 
7148   llvm::GlobalVariable *PTGV =
7149     new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
7150                              false, llvm::GlobalValue::WeakAnyLinkage, Entry,
7151                              ProtocolRef);
7152   if (!CGM.getTriple().isOSBinFormatMachO())
7153     PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef));
7154   PTGV->setAlignment(llvm::Align(
7155       CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy)));
7156   PTGV->setSection(GetSectionName("__objc_protolist",
7157                                   "coalesced,no_dead_strip"));
7158   PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
7159   CGM.addUsedGlobal(PTGV);
7160   return Entry;
7161 }
7162 
7163 /// EmitProtocolList - Generate protocol list meta-data:
7164 /// @code
7165 /// struct _protocol_list_t {
7166 ///   long protocol_count;   // Note, this is 32/64 bit
7167 ///   struct _protocol_t[protocol_count];
7168 /// }
7169 /// @endcode
7170 ///
7171 llvm::Constant *
7172 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
7173                                       ObjCProtocolDecl::protocol_iterator begin,
7174                                       ObjCProtocolDecl::protocol_iterator end) {
7175   // Just return null for empty protocol lists
7176   auto Protocols = GetRuntimeProtocolList(begin, end);
7177   if (Protocols.empty())
7178     return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
7179 
7180   SmallVector<llvm::Constant *, 16> ProtocolRefs;
7181   ProtocolRefs.reserve(Protocols.size());
7182 
7183   for (const auto *PD : Protocols)
7184     ProtocolRefs.push_back(GetProtocolRef(PD));
7185 
7186   // If all of the protocols in the protocol list are objc_non_runtime_protocol
7187   // just return null
7188   if (ProtocolRefs.size() == 0)
7189     return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
7190 
7191   // FIXME: We shouldn't need to do this lookup here, should we?
7192   SmallString<256> TmpName;
7193   Name.toVector(TmpName);
7194   llvm::GlobalVariable *GV =
7195     CGM.getModule().getGlobalVariable(TmpName.str(), true);
7196   if (GV)
7197     return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
7198 
7199   ConstantInitBuilder builder(CGM);
7200   auto values = builder.beginStruct();
7201   auto countSlot = values.addPlaceholder();
7202 
7203   // A null-terminated array of protocols.
7204   auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy);
7205   for (auto const &proto : ProtocolRefs)
7206     array.add(proto);
7207   auto count = array.size();
7208   array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy);
7209 
7210   array.finishAndAddTo(values);
7211   values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
7212 
7213   GV = finishAndCreateGlobal(values, Name, CGM);
7214   CGM.addCompilerUsedGlobal(GV);
7215   return llvm::ConstantExpr::getBitCast(GV,
7216                                         ObjCTypes.ProtocolListnfABIPtrTy);
7217 }
7218 
7219 /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
7220 /// This code gen. amounts to generating code for:
7221 /// @code
7222 /// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
7223 /// @encode
7224 ///
7225 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
7226                                                CodeGen::CodeGenFunction &CGF,
7227                                                QualType ObjectTy,
7228                                                llvm::Value *BaseValue,
7229                                                const ObjCIvarDecl *Ivar,
7230                                                unsigned CVRQualifiers) {
7231   ObjCInterfaceDecl *ID = ObjectTy->castAs<ObjCObjectType>()->getInterface();
7232   llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
7233   return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
7234                                   Offset);
7235 }
7236 
7237 llvm::Value *
7238 CGObjCNonFragileABIMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
7239                                        const ObjCInterfaceDecl *Interface,
7240                                        const ObjCIvarDecl *Ivar) {
7241   llvm::Value *IvarOffsetValue;
7242   if (isClassLayoutKnownStatically(Interface)) {
7243     IvarOffsetValue = llvm::ConstantInt::get(
7244         ObjCTypes.IvarOffsetVarTy,
7245         ComputeIvarBaseOffset(CGM, Interface->getImplementation(), Ivar));
7246   } else {
7247     llvm::GlobalVariable *GV = ObjCIvarOffsetVariable(Interface, Ivar);
7248     IvarOffsetValue =
7249         CGF.Builder.CreateAlignedLoad(GV, CGF.getSizeAlign(), "ivar");
7250     if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
7251       cast<llvm::LoadInst>(IvarOffsetValue)
7252           ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7253                         llvm::MDNode::get(VMContext, None));
7254   }
7255 
7256   // This could be 32bit int or 64bit integer depending on the architecture.
7257   // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
7258   //  as this is what caller always expects.
7259   if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
7260     IvarOffsetValue = CGF.Builder.CreateIntCast(
7261         IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
7262   return IvarOffsetValue;
7263 }
7264 
7265 static void appendSelectorForMessageRefTable(std::string &buffer,
7266                                              Selector selector) {
7267   if (selector.isUnarySelector()) {
7268     buffer += selector.getNameForSlot(0);
7269     return;
7270   }
7271 
7272   for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
7273     buffer += selector.getNameForSlot(i);
7274     buffer += '_';
7275   }
7276 }
7277 
7278 /// Emit a "vtable" message send.  We emit a weak hidden-visibility
7279 /// struct, initially containing the selector pointer and a pointer to
7280 /// a "fixup" variant of the appropriate objc_msgSend.  To call, we
7281 /// load and call the function pointer, passing the address of the
7282 /// struct as the second parameter.  The runtime determines whether
7283 /// the selector is currently emitted using vtable dispatch; if so, it
7284 /// substitutes a stub function which simply tail-calls through the
7285 /// appropriate vtable slot, and if not, it substitues a stub function
7286 /// which tail-calls objc_msgSend.  Both stubs adjust the selector
7287 /// argument to correctly point to the selector.
7288 RValue
7289 CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
7290                                               ReturnValueSlot returnSlot,
7291                                               QualType resultType,
7292                                               Selector selector,
7293                                               llvm::Value *arg0,
7294                                               QualType arg0Type,
7295                                               bool isSuper,
7296                                               const CallArgList &formalArgs,
7297                                               const ObjCMethodDecl *method) {
7298   // Compute the actual arguments.
7299   CallArgList args;
7300 
7301   // First argument: the receiver / super-call structure.
7302   if (!isSuper)
7303     arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
7304   args.add(RValue::get(arg0), arg0Type);
7305 
7306   // Second argument: a pointer to the message ref structure.  Leave
7307   // the actual argument value blank for now.
7308   args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);
7309 
7310   args.insert(args.end(), formalArgs.begin(), formalArgs.end());
7311 
7312   MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);
7313 
7314   NullReturnState nullReturn;
7315 
7316   // Find the function to call and the mangled name for the message
7317   // ref structure.  Using a different mangled name wouldn't actually
7318   // be a problem; it would just be a waste.
7319   //
7320   // The runtime currently never uses vtable dispatch for anything
7321   // except normal, non-super message-sends.
7322   // FIXME: don't use this for that.
7323   llvm::FunctionCallee fn = nullptr;
7324   std::string messageRefName("_");
7325   if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
7326     if (isSuper) {
7327       fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
7328       messageRefName += "objc_msgSendSuper2_stret_fixup";
7329     } else {
7330       nullReturn.init(CGF, arg0);
7331       fn = ObjCTypes.getMessageSendStretFixupFn();
7332       messageRefName += "objc_msgSend_stret_fixup";
7333     }
7334   } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
7335     fn = ObjCTypes.getMessageSendFpretFixupFn();
7336     messageRefName += "objc_msgSend_fpret_fixup";
7337   } else {
7338     if (isSuper) {
7339       fn = ObjCTypes.getMessageSendSuper2FixupFn();
7340       messageRefName += "objc_msgSendSuper2_fixup";
7341     } else {
7342       fn = ObjCTypes.getMessageSendFixupFn();
7343       messageRefName += "objc_msgSend_fixup";
7344     }
7345   }
7346   assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend");
7347   messageRefName += '_';
7348 
7349   // Append the selector name, except use underscores anywhere we
7350   // would have used colons.
7351   appendSelectorForMessageRefTable(messageRefName, selector);
7352 
7353   llvm::GlobalVariable *messageRef
7354     = CGM.getModule().getGlobalVariable(messageRefName);
7355   if (!messageRef) {
7356     // Build the message ref structure.
7357     ConstantInitBuilder builder(CGM);
7358     auto values = builder.beginStruct();
7359     values.add(cast<llvm::Constant>(fn.getCallee()));
7360     values.add(GetMethodVarName(selector));
7361     messageRef = values.finishAndCreateGlobal(messageRefName,
7362                                               CharUnits::fromQuantity(16),
7363                                               /*constant*/ false,
7364                                         llvm::GlobalValue::WeakAnyLinkage);
7365     messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
7366     messageRef->setSection(GetSectionName("__objc_msgrefs", "coalesced"));
7367   }
7368 
7369   bool requiresnullCheck = false;
7370   if (CGM.getLangOpts().ObjCAutoRefCount && method)
7371     for (const auto *ParamDecl : method->parameters()) {
7372       if (ParamDecl->isDestroyedInCallee()) {
7373         if (!nullReturn.NullBB)
7374           nullReturn.init(CGF, arg0);
7375         requiresnullCheck = true;
7376         break;
7377       }
7378     }
7379 
7380   Address mref =
7381     Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
7382             CGF.getPointerAlign());
7383 
7384   // Update the message ref argument.
7385   args[1].setRValue(RValue::get(mref.getPointer()));
7386 
7387   // Load the function to call from the message ref table.
7388   Address calleeAddr = CGF.Builder.CreateStructGEP(mref, 0);
7389   llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn");
7390 
7391   calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
7392   CGCallee callee(CGCalleeInfo(), calleePtr);
7393 
7394   RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
7395   return nullReturn.complete(CGF, returnSlot, result, resultType, formalArgs,
7396                              requiresnullCheck ? method : nullptr);
7397 }
7398 
7399 /// Generate code for a message send expression in the nonfragile abi.
7400 CodeGen::RValue
7401 CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
7402                                             ReturnValueSlot Return,
7403                                             QualType ResultType,
7404                                             Selector Sel,
7405                                             llvm::Value *Receiver,
7406                                             const CallArgList &CallArgs,
7407                                             const ObjCInterfaceDecl *Class,
7408                                             const ObjCMethodDecl *Method) {
7409   return isVTableDispatchedSelector(Sel)
7410     ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7411                             Receiver, CGF.getContext().getObjCIdType(),
7412                             false, CallArgs, Method)
7413     : EmitMessageSend(CGF, Return, ResultType, Sel,
7414                       Receiver, CGF.getContext().getObjCIdType(),
7415                       false, CallArgs, Method, Class, ObjCTypes);
7416 }
7417 
7418 llvm::Constant *
7419 CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID,
7420                                        bool metaclass,
7421                                        ForDefinition_t isForDefinition) {
7422   auto prefix =
7423     (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix());
7424   return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(),
7425                         isForDefinition,
7426                         ID->isWeakImported(),
7427                         !isForDefinition
7428                           && CGM.getTriple().isOSBinFormatCOFF()
7429                           && ID->hasAttr<DLLImportAttr>());
7430 }
7431 
7432 llvm::Constant *
7433 CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
7434                                        ForDefinition_t IsForDefinition,
7435                                        bool Weak, bool DLLImport) {
7436   llvm::GlobalValue::LinkageTypes L =
7437       Weak ? llvm::GlobalValue::ExternalWeakLinkage
7438            : llvm::GlobalValue::ExternalLinkage;
7439 
7440   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
7441   if (!GV || GV->getType() != ObjCTypes.ClassnfABITy->getPointerTo()) {
7442     auto *NewGV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, L,
7443                                            nullptr, Name);
7444 
7445     if (DLLImport)
7446       NewGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
7447 
7448     if (GV) {
7449       GV->replaceAllUsesWith(
7450           llvm::ConstantExpr::getBitCast(NewGV, GV->getType()));
7451       GV->eraseFromParent();
7452     }
7453     GV = NewGV;
7454     CGM.getModule().getGlobalList().push_back(GV);
7455   }
7456 
7457   assert(GV->getLinkage() == L);
7458   return GV;
7459 }
7460 
7461 llvm::Constant *
7462 CGObjCNonFragileABIMac::GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID) {
7463   llvm::Constant *ClassGV = GetClassGlobal(ID, /*metaclass*/ false,
7464                                            NotForDefinition);
7465 
7466   if (!ID->hasAttr<ObjCClassStubAttr>())
7467     return ClassGV;
7468 
7469   ClassGV = llvm::ConstantExpr::getPointerCast(ClassGV, ObjCTypes.Int8PtrTy);
7470 
7471   // Stub classes are pointer-aligned. Classrefs pointing at stub classes
7472   // must set the least significant bit set to 1.
7473   auto *Idx = llvm::ConstantInt::get(CGM.Int32Ty, 1);
7474   return llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, ClassGV, Idx);
7475 }
7476 
7477 llvm::Value *
7478 CGObjCNonFragileABIMac::EmitLoadOfClassRef(CodeGenFunction &CGF,
7479                                            const ObjCInterfaceDecl *ID,
7480                                            llvm::GlobalVariable *Entry) {
7481   if (ID && ID->hasAttr<ObjCClassStubAttr>()) {
7482     // Classrefs pointing at Objective-C stub classes must be loaded by calling
7483     // a special runtime function.
7484     return CGF.EmitRuntimeCall(
7485       ObjCTypes.getLoadClassrefFn(), Entry, "load_classref_result");
7486   }
7487 
7488   CharUnits Align = CGF.getPointerAlign();
7489   return CGF.Builder.CreateAlignedLoad(Entry, Align);
7490 }
7491 
7492 llvm::Value *
7493 CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
7494                                            IdentifierInfo *II,
7495                                            const ObjCInterfaceDecl *ID) {
7496   llvm::GlobalVariable *&Entry = ClassReferences[II];
7497 
7498   if (!Entry) {
7499     llvm::Constant *ClassGV;
7500     if (ID) {
7501       ClassGV = GetClassGlobalForClassRef(ID);
7502     } else {
7503       ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(),
7504                                NotForDefinition);
7505       assert(ClassGV->getType() == ObjCTypes.ClassnfABIPtrTy &&
7506              "classref was emitted with the wrong type?");
7507     }
7508 
7509     std::string SectionName =
7510         GetSectionName("__objc_classrefs", "regular,no_dead_strip");
7511     Entry = new llvm::GlobalVariable(
7512         CGM.getModule(), ClassGV->getType(), false,
7513         getLinkageTypeForObjCMetadata(CGM, SectionName), ClassGV,
7514         "OBJC_CLASSLIST_REFERENCES_$_");
7515     Entry->setAlignment(CGF.getPointerAlign().getAsAlign());
7516     if (!ID || !ID->hasAttr<ObjCClassStubAttr>())
7517       Entry->setSection(SectionName);
7518 
7519     CGM.addCompilerUsedGlobal(Entry);
7520   }
7521 
7522   return EmitLoadOfClassRef(CGF, ID, Entry);
7523 }
7524 
7525 llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
7526                                                   const ObjCInterfaceDecl *ID) {
7527   // If the class has the objc_runtime_visible attribute, we need to
7528   // use the Objective-C runtime to get the class.
7529   if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
7530     return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
7531 
7532   return EmitClassRefFromId(CGF, ID->getIdentifier(), ID);
7533 }
7534 
7535 llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
7536                                                     CodeGenFunction &CGF) {
7537   IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
7538   return EmitClassRefFromId(CGF, II, nullptr);
7539 }
7540 
7541 llvm::Value *
7542 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
7543                                           const ObjCInterfaceDecl *ID) {
7544   llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
7545 
7546   if (!Entry) {
7547     llvm::Constant *ClassGV = GetClassGlobalForClassRef(ID);
7548     std::string SectionName =
7549         GetSectionName("__objc_superrefs", "regular,no_dead_strip");
7550     Entry = new llvm::GlobalVariable(CGM.getModule(), ClassGV->getType(), false,
7551                                      llvm::GlobalValue::PrivateLinkage, ClassGV,
7552                                      "OBJC_CLASSLIST_SUP_REFS_$_");
7553     Entry->setAlignment(CGF.getPointerAlign().getAsAlign());
7554     Entry->setSection(SectionName);
7555     CGM.addCompilerUsedGlobal(Entry);
7556   }
7557 
7558   return EmitLoadOfClassRef(CGF, ID, Entry);
7559 }
7560 
7561 /// EmitMetaClassRef - Return a Value * of the address of _class_t
7562 /// meta-data
7563 ///
7564 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
7565                                                       const ObjCInterfaceDecl *ID,
7566                                                       bool Weak) {
7567   CharUnits Align = CGF.getPointerAlign();
7568   llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
7569   if (!Entry) {
7570     auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition);
7571     std::string SectionName =
7572         GetSectionName("__objc_superrefs", "regular,no_dead_strip");
7573     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABIPtrTy,
7574                                      false, llvm::GlobalValue::PrivateLinkage,
7575                                      MetaClassGV, "OBJC_CLASSLIST_SUP_REFS_$_");
7576     Entry->setAlignment(Align.getAsAlign());
7577     Entry->setSection(SectionName);
7578     CGM.addCompilerUsedGlobal(Entry);
7579   }
7580 
7581   return CGF.Builder.CreateAlignedLoad(Entry, Align);
7582 }
7583 
7584 /// GetClass - Return a reference to the class for the given interface
7585 /// decl.
7586 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
7587                                               const ObjCInterfaceDecl *ID) {
7588   if (ID->isWeakImported()) {
7589     auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7590     (void)ClassGV;
7591     assert(!isa<llvm::GlobalVariable>(ClassGV) ||
7592            cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage());
7593   }
7594 
7595   return EmitClassRef(CGF, ID);
7596 }
7597 
7598 /// Generates a message send where the super is the receiver.  This is
7599 /// a message send to self with special delivery semantics indicating
7600 /// which class's method should be called.
7601 CodeGen::RValue
7602 CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
7603                                                  ReturnValueSlot Return,
7604                                                  QualType ResultType,
7605                                                  Selector Sel,
7606                                                  const ObjCInterfaceDecl *Class,
7607                                                  bool isCategoryImpl,
7608                                                  llvm::Value *Receiver,
7609                                                  bool IsClassMessage,
7610                                                  const CodeGen::CallArgList &CallArgs,
7611                                                  const ObjCMethodDecl *Method) {
7612   // ...
7613   // Create and init a super structure; this is a (receiver, class)
7614   // pair we will pass to objc_msgSendSuper.
7615   Address ObjCSuper =
7616     CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
7617                          "objc_super");
7618 
7619   llvm::Value *ReceiverAsObject =
7620     CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
7621   CGF.Builder.CreateStore(ReceiverAsObject,
7622                           CGF.Builder.CreateStructGEP(ObjCSuper, 0));
7623 
7624   // If this is a class message the metaclass is passed as the target.
7625   llvm::Value *Target;
7626   if (IsClassMessage)
7627       Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported());
7628   else
7629     Target = EmitSuperClassRef(CGF, Class);
7630 
7631   // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
7632   // ObjCTypes types.
7633   llvm::Type *ClassTy =
7634     CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
7635   Target = CGF.Builder.CreateBitCast(Target, ClassTy);
7636   CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
7637 
7638   return (isVTableDispatchedSelector(Sel))
7639     ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7640                             ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7641                             true, CallArgs, Method)
7642     : EmitMessageSend(CGF, Return, ResultType, Sel,
7643                       ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7644                       true, CallArgs, Method, Class, ObjCTypes);
7645 }
7646 
7647 llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
7648                                                   Selector Sel) {
7649   Address Addr = EmitSelectorAddr(Sel);
7650 
7651   llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr);
7652   LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7653                   llvm::MDNode::get(VMContext, None));
7654   return LI;
7655 }
7656 
7657 Address CGObjCNonFragileABIMac::EmitSelectorAddr(Selector Sel) {
7658   llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
7659   CharUnits Align = CGM.getPointerAlign();
7660   if (!Entry) {
7661     llvm::Constant *Casted =
7662       llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
7663                                      ObjCTypes.SelectorPtrTy);
7664     std::string SectionName =
7665         GetSectionName("__objc_selrefs", "literal_pointers,no_dead_strip");
7666     Entry = new llvm::GlobalVariable(
7667         CGM.getModule(), ObjCTypes.SelectorPtrTy, false,
7668         getLinkageTypeForObjCMetadata(CGM, SectionName), Casted,
7669         "OBJC_SELECTOR_REFERENCES_");
7670     Entry->setExternallyInitialized(true);
7671     Entry->setSection(SectionName);
7672     Entry->setAlignment(Align.getAsAlign());
7673     CGM.addCompilerUsedGlobal(Entry);
7674   }
7675 
7676   return Address(Entry, Align);
7677 }
7678 
7679 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
7680 /// objc_assign_ivar (id src, id *dst, ptrdiff_t)
7681 ///
7682 void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
7683                                                 llvm::Value *src,
7684                                                 Address dst,
7685                                                 llvm::Value *ivarOffset) {
7686   llvm::Type * SrcTy = src->getType();
7687   if (!isa<llvm::PointerType>(SrcTy)) {
7688     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7689     assert(Size <= 8 && "does not support size > 8");
7690     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7691            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7692     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7693   }
7694   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7695   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7696   llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
7697   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
7698 }
7699 
7700 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
7701 /// objc_assign_strongCast (id src, id *dst)
7702 ///
7703 void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
7704   CodeGen::CodeGenFunction &CGF,
7705   llvm::Value *src, Address dst) {
7706   llvm::Type * SrcTy = src->getType();
7707   if (!isa<llvm::PointerType>(SrcTy)) {
7708     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7709     assert(Size <= 8 && "does not support size > 8");
7710     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7711            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7712     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7713   }
7714   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7715   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7716   llvm::Value *args[] = { src, dst.getPointer() };
7717   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
7718                               args, "weakassign");
7719 }
7720 
7721 void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
7722   CodeGen::CodeGenFunction &CGF,
7723   Address DestPtr,
7724   Address SrcPtr,
7725   llvm::Value *Size) {
7726   SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
7727   DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
7728   llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), Size };
7729   CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
7730 }
7731 
7732 /// EmitObjCWeakRead - Code gen for loading value of a __weak
7733 /// object: objc_read_weak (id *src)
7734 ///
7735 llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
7736   CodeGen::CodeGenFunction &CGF,
7737   Address AddrWeakObj) {
7738   llvm::Type *DestTy = AddrWeakObj.getElementType();
7739   AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
7740   llvm::Value *read_weak =
7741     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
7742                                 AddrWeakObj.getPointer(), "weakread");
7743   read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
7744   return read_weak;
7745 }
7746 
7747 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
7748 /// objc_assign_weak (id src, id *dst)
7749 ///
7750 void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
7751                                                 llvm::Value *src, Address dst) {
7752   llvm::Type * SrcTy = src->getType();
7753   if (!isa<llvm::PointerType>(SrcTy)) {
7754     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7755     assert(Size <= 8 && "does not support size > 8");
7756     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7757            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7758     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7759   }
7760   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7761   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7762   llvm::Value *args[] = { src, dst.getPointer() };
7763   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
7764                               args, "weakassign");
7765 }
7766 
7767 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
7768 /// objc_assign_global (id src, id *dst)
7769 ///
7770 void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
7771                                           llvm::Value *src, Address dst,
7772                                           bool threadlocal) {
7773   llvm::Type * SrcTy = src->getType();
7774   if (!isa<llvm::PointerType>(SrcTy)) {
7775     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7776     assert(Size <= 8 && "does not support size > 8");
7777     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7778            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7779     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7780   }
7781   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7782   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7783   llvm::Value *args[] = { src, dst.getPointer() };
7784   if (!threadlocal)
7785     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
7786                                 args, "globalassign");
7787   else
7788     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
7789                                 args, "threadlocalassign");
7790 }
7791 
7792 void
7793 CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
7794                                              const ObjCAtSynchronizedStmt &S) {
7795   EmitAtSynchronizedStmt(CGF, S, ObjCTypes.getSyncEnterFn(),
7796                          ObjCTypes.getSyncExitFn());
7797 }
7798 
7799 llvm::Constant *
7800 CGObjCNonFragileABIMac::GetEHType(QualType T) {
7801   // There's a particular fixed type info for 'id'.
7802   if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
7803     auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
7804     if (!IDEHType) {
7805       IDEHType =
7806           new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7807                                    llvm::GlobalValue::ExternalLinkage, nullptr,
7808                                    "OBJC_EHTYPE_id");
7809       if (CGM.getTriple().isOSBinFormatCOFF())
7810         IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id"));
7811     }
7812     return IDEHType;
7813   }
7814 
7815   // All other types should be Objective-C interface pointer types.
7816   const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
7817   assert(PT && "Invalid @catch type.");
7818 
7819   const ObjCInterfaceType *IT = PT->getInterfaceType();
7820   assert(IT && "Invalid @catch type.");
7821 
7822   return GetInterfaceEHType(IT->getDecl(), NotForDefinition);
7823 }
7824 
7825 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
7826                                          const ObjCAtTryStmt &S) {
7827   EmitTryCatchStmt(CGF, S, ObjCTypes.getObjCBeginCatchFn(),
7828                    ObjCTypes.getObjCEndCatchFn(),
7829                    ObjCTypes.getExceptionRethrowFn());
7830 }
7831 
7832 /// EmitThrowStmt - Generate code for a throw statement.
7833 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
7834                                            const ObjCAtThrowStmt &S,
7835                                            bool ClearInsertionPoint) {
7836   if (const Expr *ThrowExpr = S.getThrowExpr()) {
7837     llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
7838     Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7839     llvm::CallBase *Call =
7840         CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception);
7841     Call->setDoesNotReturn();
7842   } else {
7843     llvm::CallBase *Call =
7844         CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn());
7845     Call->setDoesNotReturn();
7846   }
7847 
7848   CGF.Builder.CreateUnreachable();
7849   if (ClearInsertionPoint)
7850     CGF.Builder.ClearInsertionPoint();
7851 }
7852 
7853 llvm::Constant *
7854 CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
7855                                            ForDefinition_t IsForDefinition) {
7856   llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
7857   StringRef ClassName = ID->getObjCRuntimeNameAsString();
7858 
7859   // If we don't need a definition, return the entry if found or check
7860   // if we use an external reference.
7861   if (!IsForDefinition) {
7862     if (Entry)
7863       return Entry;
7864 
7865     // If this type (or a super class) has the __objc_exception__
7866     // attribute, emit an external reference.
7867     if (hasObjCExceptionAttribute(CGM.getContext(), ID)) {
7868       std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str();
7869       Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
7870                                        false, llvm::GlobalValue::ExternalLinkage,
7871                                        nullptr, EHTypeName);
7872       CGM.setGVProperties(Entry, ID);
7873       return Entry;
7874     }
7875   }
7876 
7877   // Otherwise we need to either make a new entry or fill in the initializer.
7878   assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
7879 
7880   std::string VTableName = "objc_ehtype_vtable";
7881   auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName);
7882   if (!VTableGV) {
7883     VTableGV =
7884         new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false,
7885                                  llvm::GlobalValue::ExternalLinkage, nullptr,
7886                                  VTableName);
7887     if (CGM.getTriple().isOSBinFormatCOFF())
7888       VTableGV->setDLLStorageClass(getStorage(CGM, VTableName));
7889   }
7890 
7891   llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
7892   ConstantInitBuilder builder(CGM);
7893   auto values = builder.beginStruct(ObjCTypes.EHTypeTy);
7894   values.add(
7895     llvm::ConstantExpr::getInBoundsGetElementPtr(VTableGV->getValueType(),
7896                                                  VTableGV, VTableIdx));
7897   values.add(GetClassName(ClassName));
7898   values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition));
7899 
7900   llvm::GlobalValue::LinkageTypes L = IsForDefinition
7901                                           ? llvm::GlobalValue::ExternalLinkage
7902                                           : llvm::GlobalValue::WeakAnyLinkage;
7903   if (Entry) {
7904     values.finishAndSetAsInitializer(Entry);
7905     Entry->setAlignment(CGM.getPointerAlign().getAsAlign());
7906   } else {
7907     Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName,
7908                                          CGM.getPointerAlign(),
7909                                          /*constant*/ false,
7910                                          L);
7911     if (hasObjCExceptionAttribute(CGM.getContext(), ID))
7912       CGM.setGVProperties(Entry, ID);
7913   }
7914   assert(Entry->getLinkage() == L);
7915 
7916   if (!CGM.getTriple().isOSBinFormatCOFF())
7917     if (ID->getVisibility() == HiddenVisibility)
7918       Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7919 
7920   if (IsForDefinition)
7921     if (CGM.getTriple().isOSBinFormatMachO())
7922       Entry->setSection("__DATA,__objc_const");
7923 
7924   return Entry;
7925 }
7926 
7927 /* *** */
7928 
7929 CodeGen::CGObjCRuntime *
7930 CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
7931   switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
7932   case ObjCRuntime::FragileMacOSX:
7933   return new CGObjCMac(CGM);
7934 
7935   case ObjCRuntime::MacOSX:
7936   case ObjCRuntime::iOS:
7937   case ObjCRuntime::WatchOS:
7938     return new CGObjCNonFragileABIMac(CGM);
7939 
7940   case ObjCRuntime::GNUstep:
7941   case ObjCRuntime::GCC:
7942   case ObjCRuntime::ObjFW:
7943     llvm_unreachable("these runtimes are not Mac runtimes");
7944   }
7945   llvm_unreachable("bad runtime");
7946 }
7947