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