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