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