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