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