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