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