clang  10.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/RecordLayout.h"
24 #include "clang/AST/StmtObjC.h"
29 #include "llvm/ADT/CachedHashString.h"
30 #include "llvm/ADT/DenseSet.h"
31 #include "llvm/ADT/SetVector.h"
32 #include "llvm/ADT/SmallPtrSet.h"
33 #include "llvm/ADT/SmallString.h"
34 #include "llvm/IR/DataLayout.h"
35 #include "llvm/IR/InlineAsm.h"
36 #include "llvm/IR/IntrinsicInst.h"
37 #include "llvm/IR/LLVMContext.h"
38 #include "llvm/IR/Module.h"
39 #include "llvm/Support/ScopedPrinter.h"
40 #include "llvm/Support/raw_ostream.h"
41 #include <cstdio>
42 
43 using namespace clang;
44 using namespace CodeGen;
45 
46 namespace {
47 
48 // FIXME: We should find a nicer way to make the labels for metadata, string
49 // concatenation is lame.
50 
51 class ObjCCommonTypesHelper {
52 protected:
53  llvm::LLVMContext &VMContext;
54 
55 private:
56  // The types of these functions don't really matter because we
57  // should always bitcast before calling them.
58 
59  /// id objc_msgSend (id, SEL, ...)
60  ///
61  /// The default messenger, used for sends whose ABI is unchanged from
62  /// the all-integer/pointer case.
63  llvm::FunctionCallee getMessageSendFn() const {
64  // Add the non-lazy-bind attribute, since objc_msgSend is likely to
65  // be called a lot.
66  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
67  return CGM.CreateRuntimeFunction(
68  llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend",
69  llvm::AttributeList::get(CGM.getLLVMContext(),
70  llvm::AttributeList::FunctionIndex,
71  llvm::Attribute::NonLazyBind));
72  }
73 
74  /// void objc_msgSend_stret (id, SEL, ...)
75  ///
76  /// The messenger used when the return value is an aggregate returned
77  /// by indirect reference in the first argument, and therefore the
78  /// self and selector parameters are shifted over by one.
79  llvm::FunctionCallee getMessageSendStretFn() const {
80  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
81  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
82  params, true),
83  "objc_msgSend_stret");
84  }
85 
86  /// [double | long double] objc_msgSend_fpret(id self, SEL op, ...)
87  ///
88  /// The messenger used when the return value is returned on the x87
89  /// floating-point stack; without a special entrypoint, the nil case
90  /// would be unbalanced.
91  llvm::FunctionCallee getMessageSendFpretFn() const {
92  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
93  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
94  params, true),
95  "objc_msgSend_fpret");
96  }
97 
98  /// _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...)
99  ///
100  /// The messenger used when the return value is returned in two values on the
101  /// x87 floating point stack; without a special entrypoint, the nil case
102  /// would be unbalanced. Only used on 64-bit X86.
103  llvm::FunctionCallee getMessageSendFp2retFn() const {
104  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
105  llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext);
106  llvm::Type *resultType =
107  llvm::StructType::get(longDoubleType, longDoubleType);
108 
109  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType,
110  params, true),
111  "objc_msgSend_fp2ret");
112  }
113 
114  /// id objc_msgSendSuper(struct objc_super *super, SEL op, ...)
115  ///
116  /// The messenger used for super calls, which have different dispatch
117  /// semantics. The class passed is the superclass of the current
118  /// class.
119  llvm::FunctionCallee getMessageSendSuperFn() const {
120  llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
121  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
122  params, true),
123  "objc_msgSendSuper");
124  }
125 
126  /// id objc_msgSendSuper2(struct objc_super *super, SEL op, ...)
127  ///
128  /// A slightly different messenger used for super calls. The class
129  /// passed is the current class.
130  llvm::FunctionCallee getMessageSendSuperFn2() const {
131  llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
132  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
133  params, true),
134  "objc_msgSendSuper2");
135  }
136 
137  /// void objc_msgSendSuper_stret(void *stretAddr, struct objc_super *super,
138  /// SEL op, ...)
139  ///
140  /// The messenger used for super calls which return an aggregate indirectly.
141  llvm::FunctionCallee getMessageSendSuperStretFn() const {
142  llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
143  return CGM.CreateRuntimeFunction(
144  llvm::FunctionType::get(CGM.VoidTy, params, true),
145  "objc_msgSendSuper_stret");
146  }
147 
148  /// void objc_msgSendSuper2_stret(void * stretAddr, struct objc_super *super,
149  /// SEL op, ...)
150  ///
151  /// objc_msgSendSuper_stret with the super2 semantics.
152  llvm::FunctionCallee getMessageSendSuperStretFn2() const {
153  llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
154  return CGM.CreateRuntimeFunction(
155  llvm::FunctionType::get(CGM.VoidTy, params, true),
156  "objc_msgSendSuper2_stret");
157  }
158 
159  llvm::FunctionCallee getMessageSendSuperFpretFn() const {
160  // There is no objc_msgSendSuper_fpret? How can that work?
161  return getMessageSendSuperFn();
162  }
163 
164  llvm::FunctionCallee getMessageSendSuperFpretFn2() const {
165  // There is no objc_msgSendSuper_fpret? How can that work?
166  return getMessageSendSuperFn2();
167  }
168 
169 protected:
171 
172 public:
173  llvm::IntegerType *ShortTy, *IntTy, *LongTy;
174  llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy;
175  llvm::Type *IvarOffsetVarTy;
176 
177  /// ObjectPtrTy - LLVM type for object handles (typeof(id))
178  llvm::PointerType *ObjectPtrTy;
179 
180  /// PtrObjectPtrTy - LLVM type for id *
181  llvm::PointerType *PtrObjectPtrTy;
182 
183  /// SelectorPtrTy - LLVM type for selector handles (typeof(SEL))
184  llvm::PointerType *SelectorPtrTy;
185 
186 private:
187  /// ProtocolPtrTy - LLVM type for external protocol handles
188  /// (typeof(Protocol))
189  llvm::Type *ExternalProtocolPtrTy;
190 
191 public:
192  llvm::Type *getExternalProtocolPtrTy() {
193  if (!ExternalProtocolPtrTy) {
194  // FIXME: It would be nice to unify this with the opaque type, so that the
195  // IR comes out a bit cleaner.
196  CodeGen::CodeGenTypes &Types = CGM.getTypes();
197  ASTContext &Ctx = CGM.getContext();
198  llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
199  ExternalProtocolPtrTy = llvm::PointerType::getUnqual(T);
200  }
201 
202  return ExternalProtocolPtrTy;
203  }
204 
205  // SuperCTy - clang type for struct objc_super.
206  QualType SuperCTy;
207  // SuperPtrCTy - clang type for struct objc_super *.
208  QualType SuperPtrCTy;
209 
210  /// SuperTy - LLVM type for struct objc_super.
211  llvm::StructType *SuperTy;
212  /// SuperPtrTy - LLVM type for struct objc_super *.
213  llvm::PointerType *SuperPtrTy;
214 
215  /// PropertyTy - LLVM type for struct objc_property (struct _prop_t
216  /// in GCC parlance).
217  llvm::StructType *PropertyTy;
218 
219  /// PropertyListTy - LLVM type for struct objc_property_list
220  /// (_prop_list_t in GCC parlance).
221  llvm::StructType *PropertyListTy;
222  /// PropertyListPtrTy - LLVM type for struct objc_property_list*.
223  llvm::PointerType *PropertyListPtrTy;
224 
225  // MethodTy - LLVM type for struct objc_method.
226  llvm::StructType *MethodTy;
227 
228  /// CacheTy - LLVM type for struct objc_cache.
229  llvm::Type *CacheTy;
230  /// CachePtrTy - LLVM type for struct objc_cache *.
231  llvm::PointerType *CachePtrTy;
232 
233  llvm::FunctionCallee getGetPropertyFn() {
234  CodeGen::CodeGenTypes &Types = CGM.getTypes();
235  ASTContext &Ctx = CGM.getContext();
236  // id objc_getProperty (id, SEL, ptrdiff_t, bool)
237  CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
238  CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
239  CanQualType Params[] = {
240  IdType, SelType,
242  llvm::FunctionType *FTy =
243  Types.GetFunctionType(
244  Types.arrangeBuiltinFunctionDeclaration(IdType, Params));
245  return CGM.CreateRuntimeFunction(FTy, "objc_getProperty");
246  }
247 
248  llvm::FunctionCallee getSetPropertyFn() {
249  CodeGen::CodeGenTypes &Types = CGM.getTypes();
250  ASTContext &Ctx = CGM.getContext();
251  // void objc_setProperty (id, SEL, ptrdiff_t, id, bool, bool)
252  CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
253  CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
254  CanQualType Params[] = {
255  IdType,
256  SelType,
258  IdType,
259  Ctx.BoolTy,
260  Ctx.BoolTy};
261  llvm::FunctionType *FTy =
262  Types.GetFunctionType(
263  Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
264  return CGM.CreateRuntimeFunction(FTy, "objc_setProperty");
265  }
266 
267  llvm::FunctionCallee getOptimizedSetPropertyFn(bool atomic, bool copy) {
268  CodeGen::CodeGenTypes &Types = CGM.getTypes();
269  ASTContext &Ctx = CGM.getContext();
270  // void objc_setProperty_atomic(id self, SEL _cmd,
271  // id newValue, ptrdiff_t offset);
272  // void objc_setProperty_nonatomic(id self, SEL _cmd,
273  // id newValue, ptrdiff_t offset);
274  // void objc_setProperty_atomic_copy(id self, SEL _cmd,
275  // id newValue, ptrdiff_t offset);
276  // void objc_setProperty_nonatomic_copy(id self, SEL _cmd,
277  // id newValue, ptrdiff_t offset);
278 
280  CanQualType IdType = Ctx.getCanonicalParamType(Ctx.getObjCIdType());
281  CanQualType SelType = Ctx.getCanonicalParamType(Ctx.getObjCSelType());
282  Params.push_back(IdType);
283  Params.push_back(SelType);
284  Params.push_back(IdType);
285  Params.push_back(Ctx.getPointerDiffType()->getCanonicalTypeUnqualified());
286  llvm::FunctionType *FTy =
287  Types.GetFunctionType(
288  Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
289  const char *name;
290  if (atomic && copy)
291  name = "objc_setProperty_atomic_copy";
292  else if (atomic && !copy)
293  name = "objc_setProperty_atomic";
294  else if (!atomic && copy)
295  name = "objc_setProperty_nonatomic_copy";
296  else
297  name = "objc_setProperty_nonatomic";
298 
299  return CGM.CreateRuntimeFunction(FTy, name);
300  }
301 
302  llvm::FunctionCallee getCopyStructFn() {
303  CodeGen::CodeGenTypes &Types = CGM.getTypes();
304  ASTContext &Ctx = CGM.getContext();
305  // void objc_copyStruct (void *, const void *, size_t, bool, bool)
307  Params.push_back(Ctx.VoidPtrTy);
308  Params.push_back(Ctx.VoidPtrTy);
309  Params.push_back(Ctx.getSizeType());
310  Params.push_back(Ctx.BoolTy);
311  Params.push_back(Ctx.BoolTy);
312  llvm::FunctionType *FTy =
313  Types.GetFunctionType(
314  Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
315  return CGM.CreateRuntimeFunction(FTy, "objc_copyStruct");
316  }
317 
318  /// This routine declares and returns address of:
319  /// void objc_copyCppObjectAtomic(
320  /// void *dest, const void *src,
321  /// void (*copyHelper) (void *dest, const void *source));
322  llvm::FunctionCallee getCppAtomicObjectFunction() {
323  CodeGen::CodeGenTypes &Types = CGM.getTypes();
324  ASTContext &Ctx = CGM.getContext();
325  /// void objc_copyCppObjectAtomic(void *dest, const void *src, void *helper);
327  Params.push_back(Ctx.VoidPtrTy);
328  Params.push_back(Ctx.VoidPtrTy);
329  Params.push_back(Ctx.VoidPtrTy);
330  llvm::FunctionType *FTy =
331  Types.GetFunctionType(
332  Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
333  return CGM.CreateRuntimeFunction(FTy, "objc_copyCppObjectAtomic");
334  }
335 
336  llvm::FunctionCallee getEnumerationMutationFn() {
337  CodeGen::CodeGenTypes &Types = CGM.getTypes();
338  ASTContext &Ctx = CGM.getContext();
339  // void objc_enumerationMutation (id)
341  Params.push_back(Ctx.getCanonicalParamType(Ctx.getObjCIdType()));
342  llvm::FunctionType *FTy =
343  Types.GetFunctionType(
344  Types.arrangeBuiltinFunctionDeclaration(Ctx.VoidTy, Params));
345  return CGM.CreateRuntimeFunction(FTy, "objc_enumerationMutation");
346  }
347 
348  llvm::FunctionCallee getLookUpClassFn() {
349  CodeGen::CodeGenTypes &Types = CGM.getTypes();
350  ASTContext &Ctx = CGM.getContext();
351  // Class objc_lookUpClass (const char *)
353  Params.push_back(
355  llvm::FunctionType *FTy =
358  Params));
359  return CGM.CreateRuntimeFunction(FTy, "objc_lookUpClass");
360  }
361 
362  /// GcReadWeakFn -- LLVM objc_read_weak (id *src) function.
363  llvm::FunctionCallee getGcReadWeakFn() {
364  // id objc_read_weak (id *)
365  llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
366  llvm::FunctionType *FTy =
367  llvm::FunctionType::get(ObjectPtrTy, args, false);
368  return CGM.CreateRuntimeFunction(FTy, "objc_read_weak");
369  }
370 
371  /// GcAssignWeakFn -- LLVM objc_assign_weak function.
372  llvm::FunctionCallee getGcAssignWeakFn() {
373  // id objc_assign_weak (id, id *)
374  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
375  llvm::FunctionType *FTy =
376  llvm::FunctionType::get(ObjectPtrTy, args, false);
377  return CGM.CreateRuntimeFunction(FTy, "objc_assign_weak");
378  }
379 
380  /// GcAssignGlobalFn -- LLVM objc_assign_global function.
381  llvm::FunctionCallee getGcAssignGlobalFn() {
382  // id objc_assign_global(id, id *)
383  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
384  llvm::FunctionType *FTy =
385  llvm::FunctionType::get(ObjectPtrTy, args, false);
386  return CGM.CreateRuntimeFunction(FTy, "objc_assign_global");
387  }
388 
389  /// GcAssignThreadLocalFn -- LLVM objc_assign_threadlocal function.
390  llvm::FunctionCallee getGcAssignThreadLocalFn() {
391  // id objc_assign_threadlocal(id src, id * dest)
392  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
393  llvm::FunctionType *FTy =
394  llvm::FunctionType::get(ObjectPtrTy, args, false);
395  return CGM.CreateRuntimeFunction(FTy, "objc_assign_threadlocal");
396  }
397 
398  /// GcAssignIvarFn -- LLVM objc_assign_ivar function.
399  llvm::FunctionCallee getGcAssignIvarFn() {
400  // id objc_assign_ivar(id, id *, ptrdiff_t)
401  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
402  CGM.PtrDiffTy };
403  llvm::FunctionType *FTy =
404  llvm::FunctionType::get(ObjectPtrTy, args, false);
405  return CGM.CreateRuntimeFunction(FTy, "objc_assign_ivar");
406  }
407 
408  /// GcMemmoveCollectableFn -- LLVM objc_memmove_collectable function.
409  llvm::FunctionCallee GcMemmoveCollectableFn() {
410  // void *objc_memmove_collectable(void *dst, const void *src, size_t size)
411  llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
412  llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
413  return CGM.CreateRuntimeFunction(FTy, "objc_memmove_collectable");
414  }
415 
416  /// GcAssignStrongCastFn -- LLVM objc_assign_strongCast function.
417  llvm::FunctionCallee getGcAssignStrongCastFn() {
418  // id objc_assign_strongCast(id, id *)
419  llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
420  llvm::FunctionType *FTy =
421  llvm::FunctionType::get(ObjectPtrTy, args, false);
422  return CGM.CreateRuntimeFunction(FTy, "objc_assign_strongCast");
423  }
424 
425  /// ExceptionThrowFn - LLVM objc_exception_throw function.
426  llvm::FunctionCallee getExceptionThrowFn() {
427  // void objc_exception_throw(id)
428  llvm::Type *args[] = { ObjectPtrTy };
429  llvm::FunctionType *FTy =
430  llvm::FunctionType::get(CGM.VoidTy, args, false);
431  return CGM.CreateRuntimeFunction(FTy, "objc_exception_throw");
432  }
433 
434  /// ExceptionRethrowFn - LLVM objc_exception_rethrow function.
435  llvm::FunctionCallee getExceptionRethrowFn() {
436  // void objc_exception_rethrow(void)
437  llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
438  return CGM.CreateRuntimeFunction(FTy, "objc_exception_rethrow");
439  }
440 
441  /// SyncEnterFn - LLVM object_sync_enter function.
442  llvm::FunctionCallee getSyncEnterFn() {
443  // int objc_sync_enter (id)
444  llvm::Type *args[] = { ObjectPtrTy };
445  llvm::FunctionType *FTy =
446  llvm::FunctionType::get(CGM.IntTy, args, false);
447  return CGM.CreateRuntimeFunction(FTy, "objc_sync_enter");
448  }
449 
450  /// SyncExitFn - LLVM object_sync_exit function.
451  llvm::FunctionCallee getSyncExitFn() {
452  // int objc_sync_exit (id)
453  llvm::Type *args[] = { ObjectPtrTy };
454  llvm::FunctionType *FTy =
455  llvm::FunctionType::get(CGM.IntTy, args, false);
456  return CGM.CreateRuntimeFunction(FTy, "objc_sync_exit");
457  }
458 
459  llvm::FunctionCallee getSendFn(bool IsSuper) const {
460  return IsSuper ? getMessageSendSuperFn() : getMessageSendFn();
461  }
462 
463  llvm::FunctionCallee getSendFn2(bool IsSuper) const {
464  return IsSuper ? getMessageSendSuperFn2() : getMessageSendFn();
465  }
466 
467  llvm::FunctionCallee getSendStretFn(bool IsSuper) const {
468  return IsSuper ? getMessageSendSuperStretFn() : getMessageSendStretFn();
469  }
470 
471  llvm::FunctionCallee getSendStretFn2(bool IsSuper) const {
472  return IsSuper ? getMessageSendSuperStretFn2() : getMessageSendStretFn();
473  }
474 
475  llvm::FunctionCallee getSendFpretFn(bool IsSuper) const {
476  return IsSuper ? getMessageSendSuperFpretFn() : getMessageSendFpretFn();
477  }
478 
479  llvm::FunctionCallee getSendFpretFn2(bool IsSuper) const {
480  return IsSuper ? getMessageSendSuperFpretFn2() : getMessageSendFpretFn();
481  }
482 
483  llvm::FunctionCallee getSendFp2retFn(bool IsSuper) const {
484  return IsSuper ? getMessageSendSuperFn() : getMessageSendFp2retFn();
485  }
486 
487  llvm::FunctionCallee getSendFp2RetFn2(bool IsSuper) const {
488  return IsSuper ? getMessageSendSuperFn2() : getMessageSendFp2retFn();
489  }
490 
491  ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm);
492 };
493 
494 /// ObjCTypesHelper - Helper class that encapsulates lazy
495 /// construction of varies types used during ObjC generation.
496 class ObjCTypesHelper : public ObjCCommonTypesHelper {
497 public:
498  /// SymtabTy - LLVM type for struct objc_symtab.
499  llvm::StructType *SymtabTy;
500  /// SymtabPtrTy - LLVM type for struct objc_symtab *.
501  llvm::PointerType *SymtabPtrTy;
502  /// ModuleTy - LLVM type for struct objc_module.
503  llvm::StructType *ModuleTy;
504 
505  /// ProtocolTy - LLVM type for struct objc_protocol.
506  llvm::StructType *ProtocolTy;
507  /// ProtocolPtrTy - LLVM type for struct objc_protocol *.
508  llvm::PointerType *ProtocolPtrTy;
509  /// ProtocolExtensionTy - LLVM type for struct
510  /// objc_protocol_extension.
511  llvm::StructType *ProtocolExtensionTy;
512  /// ProtocolExtensionTy - LLVM type for struct
513  /// objc_protocol_extension *.
514  llvm::PointerType *ProtocolExtensionPtrTy;
515  /// MethodDescriptionTy - LLVM type for struct
516  /// objc_method_description.
517  llvm::StructType *MethodDescriptionTy;
518  /// MethodDescriptionListTy - LLVM type for struct
519  /// objc_method_description_list.
520  llvm::StructType *MethodDescriptionListTy;
521  /// MethodDescriptionListPtrTy - LLVM type for struct
522  /// objc_method_description_list *.
523  llvm::PointerType *MethodDescriptionListPtrTy;
524  /// ProtocolListTy - LLVM type for struct objc_property_list.
525  llvm::StructType *ProtocolListTy;
526  /// ProtocolListPtrTy - LLVM type for struct objc_property_list*.
527  llvm::PointerType *ProtocolListPtrTy;
528  /// CategoryTy - LLVM type for struct objc_category.
529  llvm::StructType *CategoryTy;
530  /// ClassTy - LLVM type for struct objc_class.
531  llvm::StructType *ClassTy;
532  /// ClassPtrTy - LLVM type for struct objc_class *.
533  llvm::PointerType *ClassPtrTy;
534  /// ClassExtensionTy - LLVM type for struct objc_class_ext.
535  llvm::StructType *ClassExtensionTy;
536  /// ClassExtensionPtrTy - LLVM type for struct objc_class_ext *.
537  llvm::PointerType *ClassExtensionPtrTy;
538  // IvarTy - LLVM type for struct objc_ivar.
539  llvm::StructType *IvarTy;
540  /// IvarListTy - LLVM type for struct objc_ivar_list.
541  llvm::StructType *IvarListTy;
542  /// IvarListPtrTy - LLVM type for struct objc_ivar_list *.
543  llvm::PointerType *IvarListPtrTy;
544  /// MethodListTy - LLVM type for struct objc_method_list.
545  llvm::StructType *MethodListTy;
546  /// MethodListPtrTy - LLVM type for struct objc_method_list *.
547  llvm::PointerType *MethodListPtrTy;
548 
549  /// ExceptionDataTy - LLVM type for struct _objc_exception_data.
550  llvm::StructType *ExceptionDataTy;
551 
552  /// ExceptionTryEnterFn - LLVM objc_exception_try_enter function.
553  llvm::FunctionCallee getExceptionTryEnterFn() {
554  llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
555  return CGM.CreateRuntimeFunction(
556  llvm::FunctionType::get(CGM.VoidTy, params, false),
557  "objc_exception_try_enter");
558  }
559 
560  /// ExceptionTryExitFn - LLVM objc_exception_try_exit function.
561  llvm::FunctionCallee getExceptionTryExitFn() {
562  llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
563  return CGM.CreateRuntimeFunction(
564  llvm::FunctionType::get(CGM.VoidTy, params, false),
565  "objc_exception_try_exit");
566  }
567 
568  /// ExceptionExtractFn - LLVM objc_exception_extract function.
569  llvm::FunctionCallee getExceptionExtractFn() {
570  llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
571  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
572  params, false),
573  "objc_exception_extract");
574  }
575 
576  /// ExceptionMatchFn - LLVM objc_exception_match function.
577  llvm::FunctionCallee getExceptionMatchFn() {
578  llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
579  return CGM.CreateRuntimeFunction(
580  llvm::FunctionType::get(CGM.Int32Ty, params, false),
581  "objc_exception_match");
582  }
583 
584  /// SetJmpFn - LLVM _setjmp function.
585  llvm::FunctionCallee getSetJmpFn() {
586  // This is specifically the prototype for x86.
587  llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
588  return CGM.CreateRuntimeFunction(
589  llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp",
590  llvm::AttributeList::get(CGM.getLLVMContext(),
591  llvm::AttributeList::FunctionIndex,
592  llvm::Attribute::NonLazyBind));
593  }
594 
595 public:
596  ObjCTypesHelper(CodeGen::CodeGenModule &cgm);
597 };
598 
599 /// ObjCNonFragileABITypesHelper - will have all types needed by objective-c's
600 /// modern abi
601 class ObjCNonFragileABITypesHelper : public ObjCCommonTypesHelper {
602 public:
603  // MethodListnfABITy - LLVM for struct _method_list_t
604  llvm::StructType *MethodListnfABITy;
605 
606  // MethodListnfABIPtrTy - LLVM for struct _method_list_t*
607  llvm::PointerType *MethodListnfABIPtrTy;
608 
609  // ProtocolnfABITy = LLVM for struct _protocol_t
610  llvm::StructType *ProtocolnfABITy;
611 
612  // ProtocolnfABIPtrTy = LLVM for struct _protocol_t*
613  llvm::PointerType *ProtocolnfABIPtrTy;
614 
615  // ProtocolListnfABITy - LLVM for struct _objc_protocol_list
616  llvm::StructType *ProtocolListnfABITy;
617 
618  // ProtocolListnfABIPtrTy - LLVM for struct _objc_protocol_list*
619  llvm::PointerType *ProtocolListnfABIPtrTy;
620 
621  // ClassnfABITy - LLVM for struct _class_t
622  llvm::StructType *ClassnfABITy;
623 
624  // ClassnfABIPtrTy - LLVM for struct _class_t*
625  llvm::PointerType *ClassnfABIPtrTy;
626 
627  // IvarnfABITy - LLVM for struct _ivar_t
628  llvm::StructType *IvarnfABITy;
629 
630  // IvarListnfABITy - LLVM for struct _ivar_list_t
631  llvm::StructType *IvarListnfABITy;
632 
633  // IvarListnfABIPtrTy = LLVM for struct _ivar_list_t*
634  llvm::PointerType *IvarListnfABIPtrTy;
635 
636  // ClassRonfABITy - LLVM for struct _class_ro_t
637  llvm::StructType *ClassRonfABITy;
638 
639  // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
640  llvm::PointerType *ImpnfABITy;
641 
642  // CategorynfABITy - LLVM for struct _category_t
643  llvm::StructType *CategorynfABITy;
644 
645  // New types for nonfragile abi messaging.
646 
647  // MessageRefTy - LLVM for:
648  // struct _message_ref_t {
649  // IMP messenger;
650  // SEL name;
651  // };
652  llvm::StructType *MessageRefTy;
653  // MessageRefCTy - clang type for struct _message_ref_t
654  QualType MessageRefCTy;
655 
656  // MessageRefPtrTy - LLVM for struct _message_ref_t*
657  llvm::Type *MessageRefPtrTy;
658  // MessageRefCPtrTy - clang type for struct _message_ref_t*
659  QualType MessageRefCPtrTy;
660 
661  // SuperMessageRefTy - LLVM for:
662  // struct _super_message_ref_t {
663  // SUPER_IMP messenger;
664  // SEL name;
665  // };
666  llvm::StructType *SuperMessageRefTy;
667 
668  // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
669  llvm::PointerType *SuperMessageRefPtrTy;
670 
671  llvm::FunctionCallee getMessageSendFixupFn() {
672  // id objc_msgSend_fixup(id, struct message_ref_t*, ...)
673  llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
674  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
675  params, true),
676  "objc_msgSend_fixup");
677  }
678 
679  llvm::FunctionCallee getMessageSendFpretFixupFn() {
680  // id objc_msgSend_fpret_fixup(id, struct message_ref_t*, ...)
681  llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
682  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
683  params, true),
684  "objc_msgSend_fpret_fixup");
685  }
686 
687  llvm::FunctionCallee getMessageSendStretFixupFn() {
688  // id objc_msgSend_stret_fixup(id, struct message_ref_t*, ...)
689  llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
690  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
691  params, true),
692  "objc_msgSend_stret_fixup");
693  }
694 
695  llvm::FunctionCallee getMessageSendSuper2FixupFn() {
696  // id objc_msgSendSuper2_fixup (struct objc_super *,
697  // struct _super_message_ref_t*, ...)
698  llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
699  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
700  params, true),
701  "objc_msgSendSuper2_fixup");
702  }
703 
704  llvm::FunctionCallee getMessageSendSuper2StretFixupFn() {
705  // id objc_msgSendSuper2_stret_fixup(struct objc_super *,
706  // struct _super_message_ref_t*, ...)
707  llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
708  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
709  params, true),
710  "objc_msgSendSuper2_stret_fixup");
711  }
712 
713  llvm::FunctionCallee getObjCEndCatchFn() {
714  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
715  "objc_end_catch");
716  }
717 
718  llvm::FunctionCallee getObjCBeginCatchFn() {
719  llvm::Type *params[] = { Int8PtrTy };
720  return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
721  params, false),
722  "objc_begin_catch");
723  }
724 
725  /// Class objc_loadClassref (void *)
726  ///
727  /// Loads from a classref. For Objective-C stub classes, this invokes the
728  /// initialization callback stored inside the stub. For all other classes
729  /// this simply dereferences the pointer.
730  llvm::FunctionCallee getLoadClassrefFn() const {
731  // Add the non-lazy-bind attribute, since objc_loadClassref is likely to
732  // be called a lot.
733  //
734  // Also it is safe to make it readnone, since we never load or store the
735  // classref except by calling this function.
736  llvm::Type *params[] = { Int8PtrPtrTy };
737  llvm::FunctionCallee F = CGM.CreateRuntimeFunction(
738  llvm::FunctionType::get(ClassnfABIPtrTy, params, false),
739  "objc_loadClassref",
740  llvm::AttributeList::get(CGM.getLLVMContext(),
741  llvm::AttributeList::FunctionIndex,
742  {llvm::Attribute::NonLazyBind,
743  llvm::Attribute::ReadNone,
744  llvm::Attribute::NoUnwind}));
745  if (!CGM.getTriple().isOSBinFormatCOFF())
746  cast<llvm::Function>(F.getCallee())->setLinkage(
747  llvm::Function::ExternalWeakLinkage);
748 
749  return F;
750  }
751 
752  llvm::StructType *EHTypeTy;
753  llvm::Type *EHTypePtrTy;
754 
755  ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm);
756 };
757 
758 enum class ObjCLabelType {
759  ClassName,
760  MethodVarName,
761  MethodVarType,
762  PropertyName,
763 };
764 
765 class CGObjCCommonMac : public CodeGen::CGObjCRuntime {
766 public:
767  class SKIP_SCAN {
768  public:
769  unsigned skip;
770  unsigned scan;
771  SKIP_SCAN(unsigned _skip = 0, unsigned _scan = 0)
772  : skip(_skip), scan(_scan) {}
773  };
774 
775  /// opcode for captured block variables layout 'instructions'.
776  /// In the following descriptions, 'I' is the value of the immediate field.
777  /// (field following the opcode).
778  ///
779  enum BLOCK_LAYOUT_OPCODE {
780  /// An operator which affects how the following layout should be
781  /// interpreted.
782  /// I == 0: Halt interpretation and treat everything else as
783  /// a non-pointer. Note that this instruction is equal
784  /// to '\0'.
785  /// I != 0: Currently unused.
786  BLOCK_LAYOUT_OPERATOR = 0,
787 
788  /// The next I+1 bytes do not contain a value of object pointer type.
789  /// Note that this can leave the stream unaligned, meaning that
790  /// subsequent word-size instructions do not begin at a multiple of
791  /// the pointer size.
792  BLOCK_LAYOUT_NON_OBJECT_BYTES = 1,
793 
794  /// The next I+1 words do not contain a value of object pointer type.
795  /// This is simply an optimized version of BLOCK_LAYOUT_BYTES for
796  /// when the required skip quantity is a multiple of the pointer size.
797  BLOCK_LAYOUT_NON_OBJECT_WORDS = 2,
798 
799  /// The next I+1 words are __strong pointers to Objective-C
800  /// objects or blocks.
801  BLOCK_LAYOUT_STRONG = 3,
802 
803  /// The next I+1 words are pointers to __block variables.
804  BLOCK_LAYOUT_BYREF = 4,
805 
806  /// The next I+1 words are __weak pointers to Objective-C
807  /// objects or blocks.
808  BLOCK_LAYOUT_WEAK = 5,
809 
810  /// The next I+1 words are __unsafe_unretained pointers to
811  /// Objective-C objects or blocks.
812  BLOCK_LAYOUT_UNRETAINED = 6
813 
814  /// The next I+1 words are block or object pointers with some
815  /// as-yet-unspecified ownership semantics. If we add more
816  /// flavors of ownership semantics, values will be taken from
817  /// this range.
818  ///
819  /// This is included so that older tools can at least continue
820  /// processing the layout past such things.
821  //BLOCK_LAYOUT_OWNERSHIP_UNKNOWN = 7..10,
822 
823  /// All other opcodes are reserved. Halt interpretation and
824  /// treat everything else as opaque.
825  };
826 
827  class RUN_SKIP {
828  public:
829  enum BLOCK_LAYOUT_OPCODE opcode;
830  CharUnits block_var_bytepos;
831  CharUnits block_var_size;
832  RUN_SKIP(enum BLOCK_LAYOUT_OPCODE Opcode = BLOCK_LAYOUT_OPERATOR,
833  CharUnits BytePos = CharUnits::Zero(),
834  CharUnits Size = CharUnits::Zero())
835  : opcode(Opcode), block_var_bytepos(BytePos), block_var_size(Size) {}
836 
837  // Allow sorting based on byte pos.
838  bool operator<(const RUN_SKIP &b) const {
839  return block_var_bytepos < b.block_var_bytepos;
840  }
841  };
842 
843 protected:
844  llvm::LLVMContext &VMContext;
845  // FIXME! May not be needing this after all.
846  unsigned ObjCABI;
847 
848  // arc/mrr layout of captured block literal variables.
849  SmallVector<RUN_SKIP, 16> RunSkipBlockVars;
850 
851  /// LazySymbols - Symbols to generate a lazy reference for. See
852  /// DefinedSymbols and FinishModule().
853  llvm::SetVector<IdentifierInfo*> LazySymbols;
854 
855  /// DefinedSymbols - External symbols which are defined by this
856  /// module. The symbols in this list and LazySymbols are used to add
857  /// special linker symbols which ensure that Objective-C modules are
858  /// linked properly.
859  llvm::SetVector<IdentifierInfo*> DefinedSymbols;
860 
861  /// ClassNames - uniqued class names.
862  llvm::StringMap<llvm::GlobalVariable*> ClassNames;
863 
864  /// MethodVarNames - uniqued method variable names.
865  llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
866 
867  /// DefinedCategoryNames - list of category names in form Class_Category.
869 
870  /// MethodVarTypes - uniqued method type signatures. We have to use
871  /// a StringMap here because have no other unique reference.
872  llvm::StringMap<llvm::GlobalVariable*> MethodVarTypes;
873 
874  /// MethodDefinitions - map of methods which have been defined in
875  /// this translation unit.
876  llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
877 
878  /// DirectMethodDefinitions - map of direct methods which have been defined in
879  /// this translation unit.
880  llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> DirectMethodDefinitions;
881 
882  /// PropertyNames - uniqued method variable names.
883  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
884 
885  /// ClassReferences - uniqued class references.
886  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
887 
888  /// SelectorReferences - uniqued selector references.
889  llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
890 
891  /// Protocols - Protocols for which an objc_protocol structure has
892  /// been emitted. Forward declarations are handled by creating an
893  /// empty structure whose initializer is filled in when/if defined.
894  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
895 
896  /// DefinedProtocols - Protocols which have actually been
897  /// defined. We should not need this, see FIXME in GenerateProtocol.
898  llvm::DenseSet<IdentifierInfo*> DefinedProtocols;
899 
900  /// DefinedClasses - List of defined classes.
902 
903  /// ImplementedClasses - List of @implemented classes.
905 
906  /// DefinedNonLazyClasses - List of defined "non-lazy" classes.
907  SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyClasses;
908 
909  /// DefinedCategories - List of defined categories.
910  SmallVector<llvm::GlobalValue*, 16> DefinedCategories;
911 
912  /// DefinedStubCategories - List of defined categories on class stubs.
913  SmallVector<llvm::GlobalValue*, 16> DefinedStubCategories;
914 
915  /// DefinedNonLazyCategories - List of defined "non-lazy" categories.
916  SmallVector<llvm::GlobalValue*, 16> DefinedNonLazyCategories;
917 
918  /// Cached reference to the class for constant strings. This value has type
919  /// int * but is actually an Obj-C class pointer.
920  llvm::WeakTrackingVH ConstantStringClassRef;
921 
922  /// The LLVM type corresponding to NSConstantString.
923  llvm::StructType *NSConstantStringType = nullptr;
924 
925  llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap;
926 
927  /// GetNameForMethod - Return a name for the given method.
928  /// \param[out] NameOut - The return value.
929  void GetNameForMethod(const ObjCMethodDecl *OMD,
930  const ObjCContainerDecl *CD,
931  SmallVectorImpl<char> &NameOut,
932  bool ignoreCategoryNamespace = false);
933 
934  /// GetMethodVarName - Return a unique constant for the given
935  /// selector's name. The return value has type char *.
936  llvm::Constant *GetMethodVarName(Selector Sel);
937  llvm::Constant *GetMethodVarName(IdentifierInfo *Ident);
938 
939  /// GetMethodVarType - Return a unique constant for the given
940  /// method's type encoding string. The return value has type char *.
941 
942  // FIXME: This is a horrible name.
943  llvm::Constant *GetMethodVarType(const ObjCMethodDecl *D,
944  bool Extended = false);
945  llvm::Constant *GetMethodVarType(const FieldDecl *D);
946 
947  /// GetPropertyName - Return a unique constant for the given
948  /// name. The return value has type char *.
949  llvm::Constant *GetPropertyName(IdentifierInfo *Ident);
950 
951  // FIXME: This can be dropped once string functions are unified.
952  llvm::Constant *GetPropertyTypeString(const ObjCPropertyDecl *PD,
953  const Decl *Container);
954 
955  /// GetClassName - Return a unique constant for the given selector's
956  /// runtime name (which may change via use of objc_runtime_name attribute on
957  /// class or protocol definition. The return value has type char *.
958  llvm::Constant *GetClassName(StringRef RuntimeName);
959 
960  llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
961 
962  /// BuildIvarLayout - Builds ivar layout bitmap for the class
963  /// implementation for the __strong or __weak case.
964  ///
965  /// \param hasMRCWeakIvars - Whether we are compiling in MRC and there
966  /// are any weak ivars defined directly in the class. Meaningless unless
967  /// building a weak layout. Does not guarantee that the layout will
968  /// actually have any entries, because the ivar might be under-aligned.
969  llvm::Constant *BuildIvarLayout(const ObjCImplementationDecl *OI,
970  CharUnits beginOffset,
971  CharUnits endOffset,
972  bool forStrongLayout,
973  bool hasMRCWeakIvars);
974 
975  llvm::Constant *BuildStrongIvarLayout(const ObjCImplementationDecl *OI,
976  CharUnits beginOffset,
977  CharUnits endOffset) {
978  return BuildIvarLayout(OI, beginOffset, endOffset, true, false);
979  }
980 
981  llvm::Constant *BuildWeakIvarLayout(const ObjCImplementationDecl *OI,
982  CharUnits beginOffset,
983  CharUnits endOffset,
984  bool hasMRCWeakIvars) {
985  return BuildIvarLayout(OI, beginOffset, endOffset, false, hasMRCWeakIvars);
986  }
987 
988  Qualifiers::ObjCLifetime getBlockCaptureLifetime(QualType QT, bool ByrefLayout);
989 
990  void UpdateRunSkipBlockVars(bool IsByref,
991  Qualifiers::ObjCLifetime LifeTime,
992  CharUnits FieldOffset,
993  CharUnits FieldSize);
994 
995  void BuildRCBlockVarRecordLayout(const RecordType *RT,
996  CharUnits BytePos, bool &HasUnion,
997  bool ByrefLayout=false);
998 
999  void BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
1000  const RecordDecl *RD,
1001  ArrayRef<const FieldDecl*> RecFields,
1002  CharUnits BytePos, bool &HasUnion,
1003  bool ByrefLayout);
1004 
1005  uint64_t InlineLayoutInstruction(SmallVectorImpl<unsigned char> &Layout);
1006 
1007  llvm::Constant *getBitmapBlockLayout(bool ComputeByrefLayout);
1008 
1009  /// GetIvarLayoutName - Returns a unique constant for the given
1010  /// ivar layout bitmap.
1011  llvm::Constant *GetIvarLayoutName(IdentifierInfo *Ident,
1012  const ObjCCommonTypesHelper &ObjCTypes);
1013 
1014  /// EmitPropertyList - Emit the given property list. The return
1015  /// value has type PropertyListPtrTy.
1016  llvm::Constant *EmitPropertyList(Twine Name,
1017  const Decl *Container,
1018  const ObjCContainerDecl *OCD,
1019  const ObjCCommonTypesHelper &ObjCTypes,
1020  bool IsClassProperty);
1021 
1022  /// EmitProtocolMethodTypes - Generate the array of extended method type
1023  /// strings. The return value has type Int8PtrPtrTy.
1024  llvm::Constant *EmitProtocolMethodTypes(Twine Name,
1025  ArrayRef<llvm::Constant*> MethodTypes,
1026  const ObjCCommonTypesHelper &ObjCTypes);
1027 
1028  /// GetProtocolRef - Return a reference to the internal protocol
1029  /// description, creating an empty one if it has not been
1030  /// defined. The return value has type ProtocolPtrTy.
1031  llvm::Constant *GetProtocolRef(const ObjCProtocolDecl *PD);
1032 
1033  /// Return a reference to the given Class using runtime calls rather than
1034  /// by a symbol reference.
1035  llvm::Value *EmitClassRefViaRuntime(CodeGenFunction &CGF,
1036  const ObjCInterfaceDecl *ID,
1037  ObjCCommonTypesHelper &ObjCTypes);
1038 
1039  std::string GetSectionName(StringRef Section, StringRef MachOAttributes);
1040 
1041 public:
1042  /// CreateMetadataVar - Create a global variable with internal
1043  /// linkage for use by the Objective-C runtime.
1044  ///
1045  /// This is a convenience wrapper which not only creates the
1046  /// variable, but also sets the section and alignment and adds the
1047  /// global to the "llvm.used" list.
1048  ///
1049  /// \param Name - The variable name.
1050  /// \param Init - The variable initializer; this is also used to
1051  /// define the type of the variable.
1052  /// \param Section - The section the variable should go into, or empty.
1053  /// \param Align - The alignment for the variable, or 0.
1054  /// \param AddToUsed - Whether the variable should be added to
1055  /// "llvm.used".
1056  llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1057  ConstantStructBuilder &Init,
1058  StringRef Section, CharUnits Align,
1059  bool AddToUsed);
1060  llvm::GlobalVariable *CreateMetadataVar(Twine Name,
1061  llvm::Constant *Init,
1062  StringRef Section, CharUnits Align,
1063  bool AddToUsed);
1064 
1065  llvm::GlobalVariable *CreateCStringLiteral(StringRef Name,
1066  ObjCLabelType LabelType,
1067  bool ForceNonFragileABI = false,
1068  bool NullTerminate = true);
1069 
1070 protected:
1071  CodeGen::RValue EmitMessageSend(CodeGen::CodeGenFunction &CGF,
1072  ReturnValueSlot Return,
1073  QualType ResultType,
1074  Selector Sel,
1075  llvm::Value *Arg0,
1076  QualType Arg0Ty,
1077  bool IsSuper,
1078  const CallArgList &CallArgs,
1079  const ObjCMethodDecl *OMD,
1080  const ObjCInterfaceDecl *ClassReceiver,
1081  const ObjCCommonTypesHelper &ObjCTypes);
1082 
1083  /// EmitImageInfo - Emit the image info marker used to encode some module
1084  /// level information.
1085  void EmitImageInfo();
1086 
1087 public:
1088  CGObjCCommonMac(CodeGen::CodeGenModule &cgm) :
1089  CGObjCRuntime(cgm), VMContext(cgm.getLLVMContext()) { }
1090 
1091  bool isNonFragileABI() const {
1092  return ObjCABI == 2;
1093  }
1094 
1095  ConstantAddress GenerateConstantString(const StringLiteral *SL) override;
1096  ConstantAddress GenerateConstantNSString(const StringLiteral *SL);
1097 
1098  llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
1099  const ObjCContainerDecl *CD=nullptr) override;
1100 
1101  llvm::Function *GenerateDirectMethod(const ObjCMethodDecl *OMD,
1102  const ObjCContainerDecl *CD);
1103 
1104  void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn,
1105  const ObjCMethodDecl *OMD,
1106  const ObjCContainerDecl *CD) override;
1107 
1108  void GenerateProtocol(const ObjCProtocolDecl *PD) override;
1109 
1110  /// GetOrEmitProtocol - Get the protocol object for the given
1111  /// declaration, emitting it if necessary. The return value has type
1112  /// ProtocolPtrTy.
1113  virtual llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0;
1114 
1115  /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1116  /// object for the given declaration, emitting it if needed. These
1117  /// forward references will be filled in with empty bodies if no
1118  /// definition is seen. The return value has type ProtocolPtrTy.
1119  virtual llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD)=0;
1120 
1121  virtual llvm::Constant *getNSConstantStringClassRef() = 0;
1122 
1123  llvm::Constant *BuildGCBlockLayout(CodeGen::CodeGenModule &CGM,
1124  const CGBlockInfo &blockInfo) override;
1125  llvm::Constant *BuildRCBlockLayout(CodeGen::CodeGenModule &CGM,
1126  const CGBlockInfo &blockInfo) override;
1127  std::string getRCBlockLayoutStr(CodeGen::CodeGenModule &CGM,
1128  const CGBlockInfo &blockInfo) override;
1129 
1130  llvm::Constant *BuildByrefLayout(CodeGen::CodeGenModule &CGM,
1131  QualType T) override;
1132 
1133 private:
1134  void fillRunSkipBlockVars(CodeGenModule &CGM, const CGBlockInfo &blockInfo);
1135 };
1136 
1137 namespace {
1138 
1139 enum class MethodListType {
1140  CategoryInstanceMethods,
1141  CategoryClassMethods,
1142  InstanceMethods,
1143  ClassMethods,
1144  ProtocolInstanceMethods,
1145  ProtocolClassMethods,
1146  OptionalProtocolInstanceMethods,
1147  OptionalProtocolClassMethods,
1148 };
1149 
1150 /// A convenience class for splitting the methods of a protocol into
1151 /// the four interesting groups.
1152 class ProtocolMethodLists {
1153 public:
1154  enum Kind {
1155  RequiredInstanceMethods,
1156  RequiredClassMethods,
1157  OptionalInstanceMethods,
1158  OptionalClassMethods
1159  };
1160  enum {
1161  NumProtocolMethodLists = 4
1162  };
1163 
1164  static MethodListType getMethodListKind(Kind kind) {
1165  switch (kind) {
1166  case RequiredInstanceMethods:
1167  return MethodListType::ProtocolInstanceMethods;
1168  case RequiredClassMethods:
1169  return MethodListType::ProtocolClassMethods;
1170  case OptionalInstanceMethods:
1171  return MethodListType::OptionalProtocolInstanceMethods;
1172  case OptionalClassMethods:
1173  return MethodListType::OptionalProtocolClassMethods;
1174  }
1175  llvm_unreachable("bad kind");
1176  }
1177 
1178  SmallVector<const ObjCMethodDecl *, 4> Methods[NumProtocolMethodLists];
1179 
1180  static ProtocolMethodLists get(const ObjCProtocolDecl *PD) {
1181  ProtocolMethodLists result;
1182 
1183  for (auto MD : PD->methods()) {
1184  size_t index = (2 * size_t(MD->isOptional()))
1185  + (size_t(MD->isClassMethod()));
1186  result.Methods[index].push_back(MD);
1187  }
1188 
1189  return result;
1190  }
1191 
1192  template <class Self>
1193  SmallVector<llvm::Constant*, 8> emitExtendedTypesArray(Self *self) const {
1194  // In both ABIs, the method types list is parallel with the
1195  // concatenation of the methods arrays in the following order:
1196  // instance methods
1197  // class methods
1198  // optional instance methods
1199  // optional class methods
1201 
1202  // Methods is already in the correct order for both ABIs.
1203  for (auto &list : Methods) {
1204  for (auto MD : list) {
1205  result.push_back(self->GetMethodVarType(MD, true));
1206  }
1207  }
1208 
1209  return result;
1210  }
1211 
1212  template <class Self>
1213  llvm::Constant *emitMethodList(Self *self, const ObjCProtocolDecl *PD,
1214  Kind kind) const {
1215  return self->emitMethodList(PD->getObjCRuntimeNameAsString(),
1216  getMethodListKind(kind), Methods[kind]);
1217  }
1218 };
1219 
1220 } // end anonymous namespace
1221 
1222 class CGObjCMac : public CGObjCCommonMac {
1223 private:
1224  friend ProtocolMethodLists;
1225 
1226  ObjCTypesHelper ObjCTypes;
1227 
1228  /// EmitModuleInfo - Another marker encoding module level
1229  /// information.
1230  void EmitModuleInfo();
1231 
1232  /// EmitModuleSymols - Emit module symbols, the list of defined
1233  /// classes and categories. The result has type SymtabPtrTy.
1234  llvm::Constant *EmitModuleSymbols();
1235 
1236  /// FinishModule - Write out global data structures at the end of
1237  /// processing a translation unit.
1238  void FinishModule();
1239 
1240  /// EmitClassExtension - Generate the class extension structure used
1241  /// to store the weak ivar layout and properties. The return value
1242  /// has type ClassExtensionPtrTy.
1243  llvm::Constant *EmitClassExtension(const ObjCImplementationDecl *ID,
1244  CharUnits instanceSize,
1245  bool hasMRCWeakIvars,
1246  bool isMetaclass);
1247 
1248  /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1249  /// for the given class.
1250  llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1251  const ObjCInterfaceDecl *ID);
1252 
1253  llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1254  IdentifierInfo *II);
1255 
1256  llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1257 
1258  /// EmitSuperClassRef - Emits reference to class's main metadata class.
1259  llvm::Value *EmitSuperClassRef(const ObjCInterfaceDecl *ID);
1260 
1261  /// EmitIvarList - Emit the ivar list for the given
1262  /// implementation. If ForClass is true the list of class ivars
1263  /// (i.e. metaclass ivars) is emitted, otherwise the list of
1264  /// interface ivars will be emitted. The return value has type
1265  /// IvarListPtrTy.
1266  llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID,
1267  bool ForClass);
1268 
1269  /// EmitMetaClass - Emit a forward reference to the class structure
1270  /// for the metaclass of the given interface. The return value has
1271  /// type ClassPtrTy.
1272  llvm::Constant *EmitMetaClassRef(const ObjCInterfaceDecl *ID);
1273 
1274  /// EmitMetaClass - Emit a class structure for the metaclass of the
1275  /// given implementation. The return value has type ClassPtrTy.
1276  llvm::Constant *EmitMetaClass(const ObjCImplementationDecl *ID,
1277  llvm::Constant *Protocols,
1279 
1280  void emitMethodConstant(ConstantArrayBuilder &builder,
1281  const ObjCMethodDecl *MD);
1282 
1283  void emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
1284  const ObjCMethodDecl *MD);
1285 
1286  /// EmitMethodList - Emit the method list for the given
1287  /// implementation. The return value has type MethodListPtrTy.
1288  llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1290 
1291  /// GetOrEmitProtocol - Get the protocol object for the given
1292  /// declaration, emitting it if necessary. The return value has type
1293  /// ProtocolPtrTy.
1294  llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1295 
1296  /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1297  /// object for the given declaration, emitting it if needed. These
1298  /// forward references will be filled in with empty bodies if no
1299  /// definition is seen. The return value has type ProtocolPtrTy.
1300  llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1301 
1302  /// EmitProtocolExtension - Generate the protocol extension
1303  /// structure used to store optional instance and class methods, and
1304  /// protocol properties. The return value has type
1305  /// ProtocolExtensionPtrTy.
1306  llvm::Constant *
1307  EmitProtocolExtension(const ObjCProtocolDecl *PD,
1308  const ProtocolMethodLists &methodLists);
1309 
1310  /// EmitProtocolList - Generate the list of referenced
1311  /// protocols. The return value has type ProtocolListPtrTy.
1312  llvm::Constant *EmitProtocolList(Twine Name,
1315 
1316  /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1317  /// for the given selector.
1318  llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1319  Address EmitSelectorAddr(Selector Sel);
1320 
1321 public:
1322  CGObjCMac(CodeGen::CodeGenModule &cgm);
1323 
1324  llvm::Constant *getNSConstantStringClassRef() override;
1325 
1326  llvm::Function *ModuleInitFunction() override;
1327 
1328  CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1329  ReturnValueSlot Return,
1330  QualType ResultType,
1331  Selector Sel, llvm::Value *Receiver,
1332  const CallArgList &CallArgs,
1333  const ObjCInterfaceDecl *Class,
1334  const ObjCMethodDecl *Method) override;
1335 
1337  GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1338  ReturnValueSlot Return, QualType ResultType,
1339  Selector Sel, const ObjCInterfaceDecl *Class,
1340  bool isCategoryImpl, llvm::Value *Receiver,
1341  bool IsClassMessage, const CallArgList &CallArgs,
1342  const ObjCMethodDecl *Method) override;
1343 
1344  llvm::Value *GetClass(CodeGenFunction &CGF,
1345  const ObjCInterfaceDecl *ID) override;
1346 
1347  llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
1348  Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
1349 
1350  /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1351  /// untyped one.
1352  llvm::Value *GetSelector(CodeGenFunction &CGF,
1353  const ObjCMethodDecl *Method) override;
1354 
1355  llvm::Constant *GetEHType(QualType T) override;
1356 
1357  void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1358 
1359  void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1360 
1361  void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1362 
1363  llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1364  const ObjCProtocolDecl *PD) override;
1365 
1366  llvm::FunctionCallee GetPropertyGetFunction() override;
1367  llvm::FunctionCallee GetPropertySetFunction() override;
1368  llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
1369  bool copy) override;
1370  llvm::FunctionCallee GetGetStructFunction() override;
1371  llvm::FunctionCallee GetSetStructFunction() override;
1372  llvm::FunctionCallee GetCppAtomicObjectGetFunction() override;
1373  llvm::FunctionCallee GetCppAtomicObjectSetFunction() override;
1374  llvm::FunctionCallee EnumerationMutationFunction() override;
1375 
1376  void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1377  const ObjCAtTryStmt &S) override;
1378  void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1379  const ObjCAtSynchronizedStmt &S) override;
1380  void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
1381  void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1382  bool ClearInsertionPoint=true) override;
1383  llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1384  Address AddrWeakObj) override;
1385  void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1386  llvm::Value *src, Address dst) override;
1387  void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1388  llvm::Value *src, Address dest,
1389  bool threadlocal = false) override;
1390  void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1391  llvm::Value *src, Address dest,
1392  llvm::Value *ivarOffset) override;
1393  void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1394  llvm::Value *src, Address dest) override;
1395  void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1396  Address dest, Address src,
1397  llvm::Value *size) override;
1398 
1399  LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1400  llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1401  unsigned CVRQualifiers) override;
1402  llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1403  const ObjCInterfaceDecl *Interface,
1404  const ObjCIvarDecl *Ivar) override;
1405 };
1406 
1407 class CGObjCNonFragileABIMac : public CGObjCCommonMac {
1408 private:
1409  friend ProtocolMethodLists;
1410  ObjCNonFragileABITypesHelper ObjCTypes;
1411  llvm::GlobalVariable* ObjCEmptyCacheVar;
1412  llvm::Constant* ObjCEmptyVtableVar;
1413 
1414  /// SuperClassReferences - uniqued super class references.
1415  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
1416 
1417  /// MetaClassReferences - uniqued meta class references.
1418  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
1419 
1420  /// EHTypeReferences - uniqued class ehtype references.
1421  llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
1422 
1423  /// VTableDispatchMethods - List of methods for which we generate
1424  /// vtable-based message dispatch.
1425  llvm::DenseSet<Selector> VTableDispatchMethods;
1426 
1427  /// DefinedMetaClasses - List of defined meta-classes.
1428  std::vector<llvm::GlobalValue*> DefinedMetaClasses;
1429 
1430  /// isVTableDispatchedSelector - Returns true if SEL is a
1431  /// vtable-based selector.
1432  bool isVTableDispatchedSelector(Selector Sel);
1433 
1434  /// FinishNonFragileABIModule - Write out global data structures at the end of
1435  /// processing a translation unit.
1436  void FinishNonFragileABIModule();
1437 
1438  /// AddModuleClassList - Add the given list of class pointers to the
1439  /// module with the provided symbol and section names.
1440  void AddModuleClassList(ArrayRef<llvm::GlobalValue *> Container,
1441  StringRef SymbolName, StringRef SectionName);
1442 
1443  llvm::GlobalVariable * BuildClassRoTInitializer(unsigned flags,
1444  unsigned InstanceStart,
1445  unsigned InstanceSize,
1446  const ObjCImplementationDecl *ID);
1447  llvm::GlobalVariable *BuildClassObject(const ObjCInterfaceDecl *CI,
1448  bool isMetaclass,
1449  llvm::Constant *IsAGV,
1450  llvm::Constant *SuperClassGV,
1451  llvm::Constant *ClassRoGV,
1452  bool HiddenVisibility);
1453 
1454  void emitMethodConstant(ConstantArrayBuilder &builder,
1455  const ObjCMethodDecl *MD,
1456  bool forProtocol);
1457 
1458  /// Emit the method list for the given implementation. The return value
1459  /// has type MethodListnfABITy.
1460  llvm::Constant *emitMethodList(Twine Name, MethodListType MLT,
1462 
1463  /// EmitIvarList - Emit the ivar list for the given
1464  /// implementation. If ForClass is true the list of class ivars
1465  /// (i.e. metaclass ivars) is emitted, otherwise the list of
1466  /// interface ivars will be emitted. The return value has type
1467  /// IvarListnfABIPtrTy.
1468  llvm::Constant *EmitIvarList(const ObjCImplementationDecl *ID);
1469 
1470  llvm::Constant *EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
1471  const ObjCIvarDecl *Ivar,
1472  unsigned long int offset);
1473 
1474  /// GetOrEmitProtocol - Get the protocol object for the given
1475  /// declaration, emitting it if necessary. The return value has type
1476  /// ProtocolPtrTy.
1477  llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override;
1478 
1479  /// GetOrEmitProtocolRef - Get a forward reference to the protocol
1480  /// object for the given declaration, emitting it if needed. These
1481  /// forward references will be filled in with empty bodies if no
1482  /// definition is seen. The return value has type ProtocolPtrTy.
1483  llvm::Constant *GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) override;
1484 
1485  /// EmitProtocolList - Generate the list of referenced
1486  /// protocols. The return value has type ProtocolListPtrTy.
1487  llvm::Constant *EmitProtocolList(Twine Name,
1490 
1491  CodeGen::RValue EmitVTableMessageSend(CodeGen::CodeGenFunction &CGF,
1492  ReturnValueSlot Return,
1493  QualType ResultType,
1494  Selector Sel,
1495  llvm::Value *Receiver,
1496  QualType Arg0Ty,
1497  bool IsSuper,
1498  const CallArgList &CallArgs,
1499  const ObjCMethodDecl *Method);
1500 
1501  /// GetClassGlobal - Return the global variable for the Objective-C
1502  /// class of the given name.
1503  llvm::Constant *GetClassGlobal(StringRef Name,
1504  ForDefinition_t IsForDefinition,
1505  bool Weak = false, bool DLLImport = false);
1506  llvm::Constant *GetClassGlobal(const ObjCInterfaceDecl *ID,
1507  bool isMetaclass,
1508  ForDefinition_t isForDefinition);
1509 
1510  llvm::Constant *GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID);
1511 
1512  llvm::Value *EmitLoadOfClassRef(CodeGenFunction &CGF,
1513  const ObjCInterfaceDecl *ID,
1514  llvm::GlobalVariable *Entry);
1515 
1516  /// EmitClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1517  /// for the given class reference.
1518  llvm::Value *EmitClassRef(CodeGenFunction &CGF,
1519  const ObjCInterfaceDecl *ID);
1520 
1521  llvm::Value *EmitClassRefFromId(CodeGenFunction &CGF,
1522  IdentifierInfo *II,
1523  const ObjCInterfaceDecl *ID);
1524 
1525  llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
1526 
1527  /// EmitSuperClassRef - Return a Value*, of type ObjCTypes.ClassPtrTy,
1528  /// for the given super class reference.
1529  llvm::Value *EmitSuperClassRef(CodeGenFunction &CGF,
1530  const ObjCInterfaceDecl *ID);
1531 
1532  /// EmitMetaClassRef - Return a Value * of the address of _class_t
1533  /// meta-data
1534  llvm::Value *EmitMetaClassRef(CodeGenFunction &CGF,
1535  const ObjCInterfaceDecl *ID, bool Weak);
1536 
1537  /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
1538  /// the given ivar.
1539  ///
1540  llvm::GlobalVariable * ObjCIvarOffsetVariable(
1541  const ObjCInterfaceDecl *ID,
1542  const ObjCIvarDecl *Ivar);
1543 
1544  /// EmitSelector - Return a Value*, of type ObjCTypes.SelectorPtrTy,
1545  /// for the given selector.
1546  llvm::Value *EmitSelector(CodeGenFunction &CGF, Selector Sel);
1547  Address EmitSelectorAddr(Selector Sel);
1548 
1549  /// GetInterfaceEHType - Get the cached ehtype for the given Objective-C
1550  /// interface. The return value has type EHTypePtrTy.
1551  llvm::Constant *GetInterfaceEHType(const ObjCInterfaceDecl *ID,
1552  ForDefinition_t IsForDefinition);
1553 
1554  StringRef getMetaclassSymbolPrefix() const { return "OBJC_METACLASS_$_"; }
1555 
1556  StringRef getClassSymbolPrefix() const { return "OBJC_CLASS_$_"; }
1557 
1558  void GetClassSizeInfo(const ObjCImplementationDecl *OID,
1559  uint32_t &InstanceStart,
1560  uint32_t &InstanceSize);
1561 
1562  // Shamelessly stolen from Analysis/CFRefCount.cpp
1563  Selector GetNullarySelector(const char* name) const {
1564  IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1565  return CGM.getContext().Selectors.getSelector(0, &II);
1566  }
1567 
1568  Selector GetUnarySelector(const char* name) const {
1569  IdentifierInfo* II = &CGM.getContext().Idents.get(name);
1570  return CGM.getContext().Selectors.getSelector(1, &II);
1571  }
1572 
1573  /// ImplementationIsNonLazy - Check whether the given category or
1574  /// class implementation is "non-lazy".
1575  bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const;
1576 
1577  bool IsIvarOffsetKnownIdempotent(const CodeGen::CodeGenFunction &CGF,
1578  const ObjCIvarDecl *IV) {
1579  // Annotate the load as an invariant load iff inside an instance method
1580  // and ivar belongs to instance method's class and one of its super class.
1581  // This check is needed because the ivar offset is a lazily
1582  // initialised value that may depend on objc_msgSend to perform a fixup on
1583  // the first message dispatch.
1584  //
1585  // An additional opportunity to mark the load as invariant arises when the
1586  // base of the ivar access is a parameter to an Objective C method.
1587  // However, because the parameters are not available in the current
1588  // interface, we cannot perform this check.
1589  //
1590  // Note that for direct methods, because objc_msgSend is skipped,
1591  // and that the method may be inlined, this optimization actually
1592  // can't be performed.
1593  if (const ObjCMethodDecl *MD =
1594  dyn_cast_or_null<ObjCMethodDecl>(CGF.CurFuncDecl))
1595  if (MD->isInstanceMethod() && !MD->isDirectMethod())
1596  if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
1597  return IV->getContainingInterface()->isSuperClassOf(ID);
1598  return false;
1599  }
1600 
1601  bool isClassLayoutKnownStatically(const ObjCInterfaceDecl *ID) {
1602  // NSObject is a fixed size. If we can see the @implementation of a class
1603  // which inherits from NSObject then we know that all it's offsets also must
1604  // be fixed. FIXME: Can we do this if see a chain of super classes with
1605  // implementations leading to NSObject?
1606  return ID->getImplementation() && ID->getSuperClass() &&
1607  ID->getSuperClass()->getName() == "NSObject";
1608  }
1609 
1610 public:
1611  CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm);
1612 
1613  llvm::Constant *getNSConstantStringClassRef() override;
1614 
1615  llvm::Function *ModuleInitFunction() override;
1616 
1617  CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
1618  ReturnValueSlot Return,
1619  QualType ResultType, Selector Sel,
1620  llvm::Value *Receiver,
1621  const CallArgList &CallArgs,
1622  const ObjCInterfaceDecl *Class,
1623  const ObjCMethodDecl *Method) override;
1624 
1626  GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
1627  ReturnValueSlot Return, QualType ResultType,
1628  Selector Sel, const ObjCInterfaceDecl *Class,
1629  bool isCategoryImpl, llvm::Value *Receiver,
1630  bool IsClassMessage, const CallArgList &CallArgs,
1631  const ObjCMethodDecl *Method) override;
1632 
1633  llvm::Value *GetClass(CodeGenFunction &CGF,
1634  const ObjCInterfaceDecl *ID) override;
1635 
1636  llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override
1637  { return EmitSelector(CGF, Sel); }
1638  Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override
1639  { return EmitSelectorAddr(Sel); }
1640 
1641  /// The NeXT/Apple runtimes do not support typed selectors; just emit an
1642  /// untyped one.
1643  llvm::Value *GetSelector(CodeGenFunction &CGF,
1644  const ObjCMethodDecl *Method) override
1645  { return EmitSelector(CGF, Method->getSelector()); }
1646 
1647  void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
1648 
1649  void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
1650 
1651  void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override {}
1652 
1653  llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1654  const ObjCProtocolDecl *PD) override;
1655 
1656  llvm::Constant *GetEHType(QualType T) override;
1657 
1658  llvm::FunctionCallee GetPropertyGetFunction() override {
1659  return ObjCTypes.getGetPropertyFn();
1660  }
1661  llvm::FunctionCallee GetPropertySetFunction() override {
1662  return ObjCTypes.getSetPropertyFn();
1663  }
1664 
1665  llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
1666  bool copy) override {
1667  return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
1668  }
1669 
1670  llvm::FunctionCallee GetSetStructFunction() override {
1671  return ObjCTypes.getCopyStructFn();
1672  }
1673 
1674  llvm::FunctionCallee GetGetStructFunction() override {
1675  return ObjCTypes.getCopyStructFn();
1676  }
1677 
1678  llvm::FunctionCallee GetCppAtomicObjectSetFunction() override {
1679  return ObjCTypes.getCppAtomicObjectFunction();
1680  }
1681 
1682  llvm::FunctionCallee GetCppAtomicObjectGetFunction() override {
1683  return ObjCTypes.getCppAtomicObjectFunction();
1684  }
1685 
1686  llvm::FunctionCallee EnumerationMutationFunction() override {
1687  return ObjCTypes.getEnumerationMutationFn();
1688  }
1689 
1690  void EmitTryStmt(CodeGen::CodeGenFunction &CGF,
1691  const ObjCAtTryStmt &S) override;
1692  void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
1693  const ObjCAtSynchronizedStmt &S) override;
1694  void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S,
1695  bool ClearInsertionPoint=true) override;
1696  llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
1697  Address AddrWeakObj) override;
1698  void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
1699  llvm::Value *src, Address edst) override;
1700  void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
1701  llvm::Value *src, Address dest,
1702  bool threadlocal = false) override;
1703  void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
1704  llvm::Value *src, Address dest,
1705  llvm::Value *ivarOffset) override;
1706  void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
1707  llvm::Value *src, Address dest) override;
1708  void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
1709  Address dest, Address src,
1710  llvm::Value *size) override;
1711  LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy,
1712  llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
1713  unsigned CVRQualifiers) override;
1714  llvm::Value *EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
1715  const ObjCInterfaceDecl *Interface,
1716  const ObjCIvarDecl *Ivar) override;
1717 };
1718 
1719 /// A helper class for performing the null-initialization of a return
1720 /// value.
1721 struct NullReturnState {
1722  llvm::BasicBlock *NullBB;
1723  NullReturnState() : NullBB(nullptr) {}
1724 
1725  /// Perform a null-check of the given receiver.
1726  void init(CodeGenFunction &CGF, llvm::Value *receiver) {
1727  // Make blocks for the null-receiver and call edges.
1728  NullBB = CGF.createBasicBlock("msgSend.null-receiver");
1729  llvm::BasicBlock *callBB = CGF.createBasicBlock("msgSend.call");
1730 
1731  // Check for a null receiver and, if there is one, jump to the
1732  // null-receiver block. There's no point in trying to avoid it:
1733  // we're always going to put *something* there, because otherwise
1734  // we shouldn't have done this null-check in the first place.
1735  llvm::Value *isNull = CGF.Builder.CreateIsNull(receiver);
1736  CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
1737 
1738  // Otherwise, start performing the call.
1739  CGF.EmitBlock(callBB);
1740  }
1741 
1742  /// Complete the null-return operation. It is valid to call this
1743  /// regardless of whether 'init' has been called.
1744  RValue complete(CodeGenFunction &CGF,
1745  ReturnValueSlot returnSlot,
1746  RValue result,
1747  QualType resultType,
1748  const CallArgList &CallArgs,
1749  const ObjCMethodDecl *Method) {
1750  // If we never had to do a null-check, just use the raw result.
1751  if (!NullBB) return result;
1752 
1753  // The continuation block. This will be left null if we don't have an
1754  // IP, which can happen if the method we're calling is marked noreturn.
1755  llvm::BasicBlock *contBB = nullptr;
1756 
1757  // Finish the call path.
1758  llvm::BasicBlock *callBB = CGF.Builder.GetInsertBlock();
1759  if (callBB) {
1760  contBB = CGF.createBasicBlock("msgSend.cont");
1761  CGF.Builder.CreateBr(contBB);
1762  }
1763 
1764  // Okay, start emitting the null-receiver block.
1765  CGF.EmitBlock(NullBB);
1766 
1767  // Release any consumed arguments we've got.
1768  if (Method) {
1769  CallArgList::const_iterator I = CallArgs.begin();
1771  e = Method->param_end(); i != e; ++i, ++I) {
1772  const ParmVarDecl *ParamDecl = (*i);
1773  if (ParamDecl->hasAttr<NSConsumedAttr>()) {
1774  RValue RV = I->getRValue(CGF);
1775  assert(RV.isScalar() &&
1776  "NullReturnState::complete - arg not on object");
1778  }
1779  }
1780  }
1781 
1782  // The phi code below assumes that we haven't needed any control flow yet.
1783  assert(CGF.Builder.GetInsertBlock() == NullBB);
1784 
1785  // If we've got a void return, just jump to the continuation block.
1786  if (result.isScalar() && resultType->isVoidType()) {
1787  // No jumps required if the message-send was noreturn.
1788  if (contBB) CGF.EmitBlock(contBB);
1789  return result;
1790  }
1791 
1792  // If we've got a scalar return, build a phi.
1793  if (result.isScalar()) {
1794  // Derive the null-initialization value.
1795  llvm::Constant *null = CGF.CGM.EmitNullConstant(resultType);
1796 
1797  // If no join is necessary, just flow out.
1798  if (!contBB) return RValue::get(null);
1799 
1800  // Otherwise, build a phi.
1801  CGF.EmitBlock(contBB);
1802  llvm::PHINode *phi = CGF.Builder.CreatePHI(null->getType(), 2);
1803  phi->addIncoming(result.getScalarVal(), callBB);
1804  phi->addIncoming(null, NullBB);
1805  return RValue::get(phi);
1806  }
1807 
1808  // If we've got an aggregate return, null the buffer out.
1809  // FIXME: maybe we should be doing things differently for all the
1810  // cases where the ABI has us returning (1) non-agg values in
1811  // memory or (2) agg values in registers.
1812  if (result.isAggregate()) {
1813  assert(result.isAggregate() && "null init of non-aggregate result?");
1814  if (!returnSlot.isUnused())
1815  CGF.EmitNullInitialization(result.getAggregateAddress(), resultType);
1816  if (contBB) CGF.EmitBlock(contBB);
1817  return result;
1818  }
1819 
1820  // Complex types.
1821  CGF.EmitBlock(contBB);
1822  CodeGenFunction::ComplexPairTy callResult = result.getComplexVal();
1823 
1824  // Find the scalar type and its zero value.
1825  llvm::Type *scalarTy = callResult.first->getType();
1826  llvm::Constant *scalarZero = llvm::Constant::getNullValue(scalarTy);
1827 
1828  // Build phis for both coordinates.
1829  llvm::PHINode *real = CGF.Builder.CreatePHI(scalarTy, 2);
1830  real->addIncoming(callResult.first, callBB);
1831  real->addIncoming(scalarZero, NullBB);
1832  llvm::PHINode *imag = CGF.Builder.CreatePHI(scalarTy, 2);
1833  imag->addIncoming(callResult.second, callBB);
1834  imag->addIncoming(scalarZero, NullBB);
1835  return RValue::getComplex(real, imag);
1836  }
1837 };
1838 
1839 } // end anonymous namespace
1840 
1841 /* *** Helper Functions *** */
1842 
1843 /// getConstantGEP() - Help routine to construct simple GEPs.
1844 static llvm::Constant *getConstantGEP(llvm::LLVMContext &VMContext,
1845  llvm::GlobalVariable *C, unsigned idx0,
1846  unsigned idx1) {
1847  llvm::Value *Idxs[] = {
1848  llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1849  llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1850  };
1851  return llvm::ConstantExpr::getGetElementPtr(C->getValueType(), C, Idxs);
1852 }
1853 
1854 /// hasObjCExceptionAttribute - Return true if this class or any super
1855 /// class has the __objc_exception__ attribute.
1857  const ObjCInterfaceDecl *OID) {
1858  if (OID->hasAttr<ObjCExceptionAttr>())
1859  return true;
1860  if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
1861  return hasObjCExceptionAttribute(Context, Super);
1862  return false;
1863 }
1864 
1865 static llvm::GlobalValue::LinkageTypes
1867  if (CGM.getTriple().isOSBinFormatMachO() &&
1868  (Section.empty() || Section.startswith("__DATA")))
1870  return llvm::GlobalValue::PrivateLinkage;
1871 }
1872 
1873 /// A helper function to create an internal or private global variable.
1874 static llvm::GlobalVariable *
1876  const llvm::Twine &Name, CodeGenModule &CGM) {
1877  std::string SectionName;
1878  if (CGM.getTriple().isOSBinFormatMachO())
1879  SectionName = "__DATA, __objc_const";
1880  auto *GV = Builder.finishAndCreateGlobal(
1881  Name, CGM.getPointerAlign(), /*constant*/ false,
1882  getLinkageTypeForObjCMetadata(CGM, SectionName));
1883  GV->setSection(SectionName);
1884  return GV;
1885 }
1886 
1887 /* *** CGObjCMac Public Interface *** */
1888 
1889 CGObjCMac::CGObjCMac(CodeGen::CodeGenModule &cgm) : CGObjCCommonMac(cgm),
1890  ObjCTypes(cgm) {
1891  ObjCABI = 1;
1892  EmitImageInfo();
1893 }
1894 
1895 /// GetClass - Return a reference to the class for the given interface
1896 /// decl.
1897 llvm::Value *CGObjCMac::GetClass(CodeGenFunction &CGF,
1898  const ObjCInterfaceDecl *ID) {
1899  return EmitClassRef(CGF, ID);
1900 }
1901 
1902 /// GetSelector - Return the pointer to the unique'd string for this selector.
1903 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, Selector Sel) {
1904  return EmitSelector(CGF, Sel);
1905 }
1906 Address CGObjCMac::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
1907  return EmitSelectorAddr(Sel);
1908 }
1909 llvm::Value *CGObjCMac::GetSelector(CodeGenFunction &CGF, const ObjCMethodDecl
1910  *Method) {
1911  return EmitSelector(CGF, Method->getSelector());
1912 }
1913 
1914 llvm::Constant *CGObjCMac::GetEHType(QualType T) {
1915  if (T->isObjCIdType() ||
1916  T->isObjCQualifiedIdType()) {
1917  return CGM.GetAddrOfRTTIDescriptor(
1918  CGM.getContext().getObjCIdRedefinitionType(), /*ForEH=*/true);
1919  }
1920  if (T->isObjCClassType() ||
1921  T->isObjCQualifiedClassType()) {
1922  return CGM.GetAddrOfRTTIDescriptor(
1923  CGM.getContext().getObjCClassRedefinitionType(), /*ForEH=*/true);
1924  }
1925  if (T->isObjCObjectPointerType())
1926  return CGM.GetAddrOfRTTIDescriptor(T, /*ForEH=*/true);
1927 
1928  llvm_unreachable("asking for catch type for ObjC type in fragile runtime");
1929 }
1930 
1931 /// Generate a constant CFString object.
1932 /*
1933  struct __builtin_CFString {
1934  const int *isa; // point to __CFConstantStringClassReference
1935  int flags;
1936  const char *str;
1937  long length;
1938  };
1939 */
1940 
1941 /// or Generate a constant NSString object.
1942 /*
1943  struct __builtin_NSString {
1944  const int *isa; // point to __NSConstantStringClassReference
1945  const char *str;
1946  unsigned int length;
1947  };
1948 */
1949 
1951 CGObjCCommonMac::GenerateConstantString(const StringLiteral *SL) {
1952  return (!CGM.getLangOpts().NoConstantCFStrings
1953  ? CGM.GetAddrOfConstantCFString(SL)
1954  : GenerateConstantNSString(SL));
1955 }
1956 
1957 static llvm::StringMapEntry<llvm::GlobalVariable *> &
1958 GetConstantStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
1959  const StringLiteral *Literal, unsigned &StringLength) {
1960  StringRef String = Literal->getString();
1961  StringLength = String.size();
1962  return *Map.insert(std::make_pair(String, nullptr)).first;
1963 }
1964 
1965 llvm::Constant *CGObjCMac::getNSConstantStringClassRef() {
1966  if (llvm::Value *V = ConstantStringClassRef)
1967  return cast<llvm::Constant>(V);
1968 
1969  auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1970  std::string str =
1971  StringClass.empty() ? "_NSConstantStringClassReference"
1972  : "_" + StringClass + "ClassReference";
1973 
1974  llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
1975  auto GV = CGM.CreateRuntimeVariable(PTy, str);
1976  auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1977  ConstantStringClassRef = V;
1978  return V;
1979 }
1980 
1981 llvm::Constant *CGObjCNonFragileABIMac::getNSConstantStringClassRef() {
1982  if (llvm::Value *V = ConstantStringClassRef)
1983  return cast<llvm::Constant>(V);
1984 
1985  auto &StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1986  std::string str =
1987  StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
1988  : "OBJC_CLASS_$_" + StringClass;
1989  llvm::Constant *GV = GetClassGlobal(str, NotForDefinition);
1990 
1991  // Make sure the result is of the correct type.
1992  auto V = llvm::ConstantExpr::getBitCast(GV, CGM.IntTy->getPointerTo());
1993 
1994  ConstantStringClassRef = V;
1995  return V;
1996 }
1997 
1999 CGObjCCommonMac::GenerateConstantNSString(const StringLiteral *Literal) {
2000  unsigned StringLength = 0;
2001  llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
2002  GetConstantStringEntry(NSConstantStringMap, Literal, StringLength);
2003 
2004  if (auto *C = Entry.second)
2005  return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
2006 
2007  // If we don't already have it, get _NSConstantStringClassReference.
2008  llvm::Constant *Class = getNSConstantStringClassRef();
2009 
2010  // If we don't already have it, construct the type for a constant NSString.
2011  if (!NSConstantStringType) {
2012  NSConstantStringType =
2014  CGM.Int32Ty->getPointerTo(),
2015  CGM.Int8PtrTy,
2016  CGM.IntTy
2017  }, "struct.__builtin_NSString");
2018  }
2019 
2020  ConstantInitBuilder Builder(CGM);
2021  auto Fields = Builder.beginStruct(NSConstantStringType);
2022 
2023  // Class pointer.
2024  Fields.add(Class);
2025 
2026  // String pointer.
2027  llvm::Constant *C =
2028  llvm::ConstantDataArray::getString(VMContext, Entry.first());
2029 
2030  llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::PrivateLinkage;
2031  bool isConstant = !CGM.getLangOpts().WritableStrings;
2032 
2033  auto *GV = new llvm::GlobalVariable(CGM.getModule(), C->getType(), isConstant,
2034  Linkage, C, ".str");
2035  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2036  // Don't enforce the target's minimum global alignment, since the only use
2037  // of the string is via this class initializer.
2038  GV->setAlignment(llvm::Align::None());
2039  Fields.addBitCast(GV, CGM.Int8PtrTy);
2040 
2041  // String length.
2042  Fields.addInt(CGM.IntTy, StringLength);
2043 
2044  // The struct.
2045  CharUnits Alignment = CGM.getPointerAlign();
2046  GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
2047  /*constant*/ true,
2048  llvm::GlobalVariable::PrivateLinkage);
2049  const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
2050  const char *NSStringNonFragileABISection =
2051  "__DATA,__objc_stringobj,regular,no_dead_strip";
2052  // FIXME. Fix section.
2053  GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
2054  ? NSStringNonFragileABISection
2055  : NSStringSection);
2056  Entry.second = GV;
2057 
2058  return ConstantAddress(GV, Alignment);
2059 }
2060 
2061 enum {
2063 };
2064 
2065 /// Generates a message send where the super is the receiver. This is
2066 /// a message send to self with special delivery semantics indicating
2067 /// which class's method should be called.
2069 CGObjCMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
2070  ReturnValueSlot Return,
2071  QualType ResultType,
2072  Selector Sel,
2073  const ObjCInterfaceDecl *Class,
2074  bool isCategoryImpl,
2075  llvm::Value *Receiver,
2076  bool IsClassMessage,
2077  const CodeGen::CallArgList &CallArgs,
2078  const ObjCMethodDecl *Method) {
2079  // Create and init a super structure; this is a (receiver, class)
2080  // pair we will pass to objc_msgSendSuper.
2081  Address ObjCSuper =
2082  CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
2083  "objc_super");
2084  llvm::Value *ReceiverAsObject =
2085  CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
2086  CGF.Builder.CreateStore(ReceiverAsObject,
2087  CGF.Builder.CreateStructGEP(ObjCSuper, 0));
2088 
2089  // If this is a class message the metaclass is passed as the target.
2091  if (IsClassMessage) {
2092  if (isCategoryImpl) {
2093  // Message sent to 'super' in a class method defined in a category
2094  // implementation requires an odd treatment.
2095  // If we are in a class method, we must retrieve the
2096  // _metaclass_ for the current class, pointed at by
2097  // the class's "isa" pointer. The following assumes that
2098  // isa" is the first ivar in a class (which it must be).
2099  Target = EmitClassRef(CGF, Class->getSuperClass());
2100  Target = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, Target, 0);
2101  Target = CGF.Builder.CreateAlignedLoad(Target, CGF.getPointerAlign());
2102  } else {
2103  llvm::Constant *MetaClassPtr = EmitMetaClassRef(Class);
2104  llvm::Value *SuperPtr =
2105  CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, MetaClassPtr, 1);
2106  llvm::Value *Super =
2107  CGF.Builder.CreateAlignedLoad(SuperPtr, CGF.getPointerAlign());
2108  Target = Super;
2109  }
2110  } else if (isCategoryImpl)
2111  Target = EmitClassRef(CGF, Class->getSuperClass());
2112  else {
2113  llvm::Value *ClassPtr = EmitSuperClassRef(Class);
2114  ClassPtr = CGF.Builder.CreateStructGEP(ObjCTypes.ClassTy, ClassPtr, 1);
2115  Target = CGF.Builder.CreateAlignedLoad(ClassPtr, CGF.getPointerAlign());
2116  }
2117  // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
2118  // ObjCTypes types.
2119  llvm::Type *ClassTy =
2121  Target = CGF.Builder.CreateBitCast(Target, ClassTy);
2122  CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
2123  return EmitMessageSend(CGF, Return, ResultType, Sel, ObjCSuper.getPointer(),
2124  ObjCTypes.SuperPtrCTy, true, CallArgs, Method, Class,
2125  ObjCTypes);
2126 }
2127 
2128 /// Generate code for a message send expression.
2129 CodeGen::RValue CGObjCMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
2130  ReturnValueSlot Return,
2131  QualType ResultType,
2132  Selector Sel,
2133  llvm::Value *Receiver,
2134  const CallArgList &CallArgs,
2135  const ObjCInterfaceDecl *Class,
2136  const ObjCMethodDecl *Method) {
2137  return EmitMessageSend(CGF, Return, ResultType, Sel, Receiver,
2138  CGF.getContext().getObjCIdType(), false, CallArgs,
2139  Method, Class, ObjCTypes);
2140 }
2141 
2142 static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID) {
2143  do {
2144  if (ID->isWeakImported())
2145  return true;
2146  } while ((ID = ID->getSuperClass()));
2147 
2148  return false;
2149 }
2150 
2152 CGObjCCommonMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
2153  ReturnValueSlot Return,
2154  QualType ResultType,
2155  Selector Sel,
2156  llvm::Value *Arg0,
2157  QualType Arg0Ty,
2158  bool IsSuper,
2159  const CallArgList &CallArgs,
2160  const ObjCMethodDecl *Method,
2161  const ObjCInterfaceDecl *ClassReceiver,
2162  const ObjCCommonTypesHelper &ObjCTypes) {
2163  CodeGenTypes &Types = CGM.getTypes();
2164  auto selTy = CGF.getContext().getObjCSelType();
2165  llvm::Value *SelValue;
2166 
2167  if (Method && Method->isDirectMethod()) {
2168  // Direct methods will synthesize the proper `_cmd` internally,
2169  // so just don't bother with setting the `_cmd` argument.
2170  assert(!IsSuper);
2171  SelValue = llvm::UndefValue::get(Types.ConvertType(selTy));
2172  } else {
2173  SelValue = GetSelector(CGF, Sel);
2174  }
2175 
2176  CallArgList ActualArgs;
2177  if (!IsSuper)
2178  Arg0 = CGF.Builder.CreateBitCast(Arg0, ObjCTypes.ObjectPtrTy);
2179  ActualArgs.add(RValue::get(Arg0), Arg0Ty);
2180  ActualArgs.add(RValue::get(SelValue), selTy);
2181  ActualArgs.addFrom(CallArgs);
2182 
2183  // If we're calling a method, use the formal signature.
2184  MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2185 
2186  if (Method)
2187  assert(CGM.getContext().getCanonicalType(Method->getReturnType()) ==
2188  CGM.getContext().getCanonicalType(ResultType) &&
2189  "Result type mismatch!");
2190 
2191  bool ReceiverCanBeNull = true;
2192 
2193  // Super dispatch assumes that self is non-null; even the messenger
2194  // doesn't have a null check internally.
2195  if (IsSuper) {
2196  ReceiverCanBeNull = false;
2197 
2198  // If this is a direct dispatch of a class method, check whether the class,
2199  // or anything in its hierarchy, was weak-linked.
2200  } else if (ClassReceiver && Method && Method->isClassMethod()) {
2201  ReceiverCanBeNull = isWeakLinkedClass(ClassReceiver);
2202 
2203  // If we're emitting a method, and self is const (meaning just ARC, for now),
2204  // and the receiver is a load of self, then self is a valid object.
2205  } else if (auto CurMethod =
2206  dyn_cast_or_null<ObjCMethodDecl>(CGF.CurCodeDecl)) {
2207  auto Self = CurMethod->getSelfDecl();
2208  if (Self->getType().isConstQualified()) {
2209  if (auto LI = dyn_cast<llvm::LoadInst>(Arg0->stripPointerCasts())) {
2210  llvm::Value *SelfAddr = CGF.GetAddrOfLocalVar(Self).getPointer();
2211  if (SelfAddr == LI->getPointerOperand()) {
2212  ReceiverCanBeNull = false;
2213  }
2214  }
2215  }
2216  }
2217 
2218  bool RequiresNullCheck = false;
2219 
2220  llvm::FunctionCallee Fn = nullptr;
2221  if (Method && Method->isDirectMethod()) {
2222  Fn = GenerateDirectMethod(Method, Method->getClassInterface());
2223  } else if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
2224  if (ReceiverCanBeNull) RequiresNullCheck = true;
2225  Fn = (ObjCABI == 2) ? ObjCTypes.getSendStretFn2(IsSuper)
2226  : ObjCTypes.getSendStretFn(IsSuper);
2227  } else if (CGM.ReturnTypeUsesFPRet(ResultType)) {
2228  Fn = (ObjCABI == 2) ? ObjCTypes.getSendFpretFn2(IsSuper)
2229  : ObjCTypes.getSendFpretFn(IsSuper);
2230  } else if (CGM.ReturnTypeUsesFP2Ret(ResultType)) {
2231  Fn = (ObjCABI == 2) ? ObjCTypes.getSendFp2RetFn2(IsSuper)
2232  : ObjCTypes.getSendFp2retFn(IsSuper);
2233  } else {
2234  // arm64 uses objc_msgSend for stret methods and yet null receiver check
2235  // must be made for it.
2236  if (ReceiverCanBeNull && CGM.ReturnTypeUsesSRet(MSI.CallInfo))
2237  RequiresNullCheck = true;
2238  Fn = (ObjCABI == 2) ? ObjCTypes.getSendFn2(IsSuper)
2239  : ObjCTypes.getSendFn(IsSuper);
2240  }
2241 
2242  // Cast function to proper signature
2243  llvm::Constant *BitcastFn = cast<llvm::Constant>(
2244  CGF.Builder.CreateBitCast(Fn.getCallee(), MSI.MessengerType));
2245 
2246  // We don't need to emit a null check to zero out an indirect result if the
2247  // result is ignored.
2248  if (Return.isUnused())
2249  RequiresNullCheck = false;
2250 
2251  // Emit a null-check if there's a consumed argument other than the receiver.
2252  if (!RequiresNullCheck && CGM.getLangOpts().ObjCAutoRefCount && Method) {
2253  for (const auto *ParamDecl : Method->parameters()) {
2254  if (ParamDecl->hasAttr<NSConsumedAttr>()) {
2255  RequiresNullCheck = true;
2256  break;
2257  }
2258  }
2259  }
2260 
2261  NullReturnState nullReturn;
2262  if (RequiresNullCheck) {
2263  nullReturn.init(CGF, Arg0);
2264  }
2265 
2266  llvm::CallBase *CallSite;
2267  CGCallee Callee = CGCallee::forDirect(BitcastFn);
2268  RValue rvalue = CGF.EmitCall(MSI.CallInfo, Callee, Return, ActualArgs,
2269  &CallSite);
2270 
2271  // Mark the call as noreturn if the method is marked noreturn and the
2272  // receiver cannot be null.
2273  if (Method && Method->hasAttr<NoReturnAttr>() && !ReceiverCanBeNull) {
2274  CallSite->setDoesNotReturn();
2275  }
2276 
2277  return nullReturn.complete(CGF, Return, rvalue, ResultType, CallArgs,
2278  RequiresNullCheck ? Method : nullptr);
2279 }
2280 
2282  bool pointee = false) {
2283  // Note that GC qualification applies recursively to C pointer types
2284  // that aren't otherwise decorated. This is weird, but it's probably
2285  // an intentional workaround to the unreliable placement of GC qualifiers.
2286  if (FQT.isObjCGCStrong())
2287  return Qualifiers::Strong;
2288 
2289  if (FQT.isObjCGCWeak())
2290  return Qualifiers::Weak;
2291 
2292  if (auto ownership = FQT.getObjCLifetime()) {
2293  // Ownership does not apply recursively to C pointer types.
2294  if (pointee) return Qualifiers::GCNone;
2295  switch (ownership) {
2299  case Qualifiers::OCL_Autoreleasing: llvm_unreachable("autoreleasing ivar?");
2300  case Qualifiers::OCL_None: llvm_unreachable("known nonzero");
2301  }
2302  llvm_unreachable("bad objc ownership");
2303  }
2304 
2305  // Treat unqualified retainable pointers as strong.
2306  if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2307  return Qualifiers::Strong;
2308 
2309  // Walk into C pointer types, but only in GC.
2310  if (Ctx.getLangOpts().getGC() != LangOptions::NonGC) {
2311  if (const PointerType *PT = FQT->getAs<PointerType>())
2312  return GetGCAttrTypeForType(Ctx, PT->getPointeeType(), /*pointee*/ true);
2313  }
2314 
2315  return Qualifiers::GCNone;
2316 }
2317 
2318 namespace {
2319  struct IvarInfo {
2320  CharUnits Offset;
2321  uint64_t SizeInWords;
2322  IvarInfo(CharUnits offset, uint64_t sizeInWords)
2323  : Offset(offset), SizeInWords(sizeInWords) {}
2324 
2325  // Allow sorting based on byte pos.
2326  bool operator<(const IvarInfo &other) const {
2327  return Offset < other.Offset;
2328  }
2329  };
2330 
2331  /// A helper class for building GC layout strings.
2332  class IvarLayoutBuilder {
2333  CodeGenModule &CGM;
2334 
2335  /// The start of the layout. Offsets will be relative to this value,
2336  /// and entries less than this value will be silently discarded.
2337  CharUnits InstanceBegin;
2338 
2339  /// The end of the layout. Offsets will never exceed this value.
2340  CharUnits InstanceEnd;
2341 
2342  /// Whether we're generating the strong layout or the weak layout.
2343  bool ForStrongLayout;
2344 
2345  /// Whether the offsets in IvarsInfo might be out-of-order.
2346  bool IsDisordered = false;
2347 
2349 
2350  public:
2351  IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2352  CharUnits instanceEnd, bool forStrongLayout)
2353  : CGM(CGM), InstanceBegin(instanceBegin), InstanceEnd(instanceEnd),
2354  ForStrongLayout(forStrongLayout) {
2355  }
2356 
2357  void visitRecord(const RecordType *RT, CharUnits offset);
2358 
2359  template <class Iterator, class GetOffsetFn>
2360  void visitAggregate(Iterator begin, Iterator end,
2361  CharUnits aggrOffset,
2362  const GetOffsetFn &getOffset);
2363 
2364  void visitField(const FieldDecl *field, CharUnits offset);
2365 
2366  /// Add the layout of a block implementation.
2367  void visitBlock(const CGBlockInfo &blockInfo);
2368 
2369  /// Is there any information for an interesting bitmap?
2370  bool hasBitmapData() const { return !IvarsInfo.empty(); }
2371 
2372  llvm::Constant *buildBitmap(CGObjCCommonMac &CGObjC,
2374 
2375  static void dump(ArrayRef<unsigned char> buffer) {
2376  const unsigned char *s = buffer.data();
2377  for (unsigned i = 0, e = buffer.size(); i < e; i++)
2378  if (!(s[i] & 0xf0))
2379  printf("0x0%x%s", s[i], s[i] != 0 ? ", " : "");
2380  else
2381  printf("0x%x%s", s[i], s[i] != 0 ? ", " : "");
2382  printf("\n");
2383  }
2384  };
2385 } // end anonymous namespace
2386 
2387 llvm::Constant *CGObjCCommonMac::BuildGCBlockLayout(CodeGenModule &CGM,
2388  const CGBlockInfo &blockInfo) {
2389 
2390  llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2391  if (CGM.getLangOpts().getGC() == LangOptions::NonGC)
2392  return nullPtr;
2393 
2394  IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2395  /*for strong layout*/ true);
2396 
2397  builder.visitBlock(blockInfo);
2398 
2399  if (!builder.hasBitmapData())
2400  return nullPtr;
2401 
2403  llvm::Constant *C = builder.buildBitmap(*this, buffer);
2404  if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
2405  printf("\n block variable layout for block: ");
2406  builder.dump(buffer);
2407  }
2408 
2409  return C;
2410 }
2411 
2412 void IvarLayoutBuilder::visitBlock(const CGBlockInfo &blockInfo) {
2413  // __isa is the first field in block descriptor and must assume by runtime's
2414  // convention that it is GC'able.
2415  IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2416 
2417  const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2418 
2419  // Ignore the optional 'this' capture: C++ objects are not assumed
2420  // to be GC'ed.
2421 
2422  CharUnits lastFieldOffset;
2423 
2424  // Walk the captured variables.
2425  for (const auto &CI : blockDecl->captures()) {
2426  const VarDecl *variable = CI.getVariable();
2427  QualType type = variable->getType();
2428 
2429  const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2430 
2431  // Ignore constant captures.
2432  if (capture.isConstant()) continue;
2433 
2434  CharUnits fieldOffset = capture.getOffset();
2435 
2436  // Block fields are not necessarily ordered; if we detect that we're
2437  // adding them out-of-order, make sure we sort later.
2438  if (fieldOffset < lastFieldOffset)
2439  IsDisordered = true;
2440  lastFieldOffset = fieldOffset;
2441 
2442  // __block variables are passed by their descriptor address.
2443  if (CI.isByRef()) {
2444  IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2445  continue;
2446  }
2447 
2448  assert(!type->isArrayType() && "array variable should not be caught");
2449  if (const RecordType *record = type->getAs<RecordType>()) {
2450  visitRecord(record, fieldOffset);
2451  continue;
2452  }
2453 
2455 
2456  if (GCAttr == Qualifiers::Strong) {
2457  assert(CGM.getContext().getTypeSize(type)
2458  == CGM.getTarget().getPointerWidth(0));
2459  IvarsInfo.push_back(IvarInfo(fieldOffset, /*size in words*/ 1));
2460  }
2461  }
2462 }
2463 
2464 /// getBlockCaptureLifetime - This routine returns life time of the captured
2465 /// block variable for the purpose of block layout meta-data generation. FQT is
2466 /// the type of the variable captured in the block.
2467 Qualifiers::ObjCLifetime CGObjCCommonMac::getBlockCaptureLifetime(QualType FQT,
2468  bool ByrefLayout) {
2469  // If it has an ownership qualifier, we're done.
2470  if (auto lifetime = FQT.getObjCLifetime())
2471  return lifetime;
2472 
2473  // If it doesn't, and this is ARC, it has no ownership.
2474  if (CGM.getLangOpts().ObjCAutoRefCount)
2475  return Qualifiers::OCL_None;
2476 
2477  // In MRC, retainable pointers are owned by non-__block variables.
2478  if (FQT->isObjCObjectPointerType() || FQT->isBlockPointerType())
2480 
2481  return Qualifiers::OCL_None;
2482 }
2483 
2484 void CGObjCCommonMac::UpdateRunSkipBlockVars(bool IsByref,
2485  Qualifiers::ObjCLifetime LifeTime,
2486  CharUnits FieldOffset,
2487  CharUnits FieldSize) {
2488  // __block variables are passed by their descriptor address.
2489  if (IsByref)
2490  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_BYREF, FieldOffset,
2491  FieldSize));
2492  else if (LifeTime == Qualifiers::OCL_Strong)
2493  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_STRONG, FieldOffset,
2494  FieldSize));
2495  else if (LifeTime == Qualifiers::OCL_Weak)
2496  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_WEAK, FieldOffset,
2497  FieldSize));
2498  else if (LifeTime == Qualifiers::OCL_ExplicitNone)
2499  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_UNRETAINED, FieldOffset,
2500  FieldSize));
2501  else
2502  RunSkipBlockVars.push_back(RUN_SKIP(BLOCK_LAYOUT_NON_OBJECT_BYTES,
2503  FieldOffset,
2504  FieldSize));
2505 }
2506 
2507 void CGObjCCommonMac::BuildRCRecordLayout(const llvm::StructLayout *RecLayout,
2508  const RecordDecl *RD,
2509  ArrayRef<const FieldDecl*> RecFields,
2510  CharUnits BytePos, bool &HasUnion,
2511  bool ByrefLayout) {
2512  bool IsUnion = (RD && RD->isUnion());
2513  CharUnits MaxUnionSize = CharUnits::Zero();
2514  const FieldDecl *MaxField = nullptr;
2515  const FieldDecl *LastFieldBitfieldOrUnnamed = nullptr;
2516  CharUnits MaxFieldOffset = CharUnits::Zero();
2517  CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2518 
2519  if (RecFields.empty())
2520  return;
2521  unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2522 
2523  for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
2524  const FieldDecl *Field = RecFields[i];
2525  // Note that 'i' here is actually the field index inside RD of Field,
2526  // although this dependency is hidden.
2527  const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2528  CharUnits FieldOffset =
2530 
2531  // Skip over unnamed or bitfields
2532  if (!Field->getIdentifier() || Field->isBitField()) {
2533  LastFieldBitfieldOrUnnamed = Field;
2534  LastBitfieldOrUnnamedOffset = FieldOffset;
2535  continue;
2536  }
2537 
2538  LastFieldBitfieldOrUnnamed = nullptr;
2539  QualType FQT = Field->getType();
2540  if (FQT->isRecordType() || FQT->isUnionType()) {
2541  if (FQT->isUnionType())
2542  HasUnion = true;
2543 
2544  BuildRCBlockVarRecordLayout(FQT->getAs<RecordType>(),
2545  BytePos + FieldOffset, HasUnion);
2546  continue;
2547  }
2548 
2549  if (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2550  auto *CArray = cast<ConstantArrayType>(Array);
2551  uint64_t ElCount = CArray->getSize().getZExtValue();
2552  assert(CArray && "only array with known element size is supported");
2553  FQT = CArray->getElementType();
2554  while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2555  auto *CArray = cast<ConstantArrayType>(Array);
2556  ElCount *= CArray->getSize().getZExtValue();
2557  FQT = CArray->getElementType();
2558  }
2559  if (FQT->isRecordType() && ElCount) {
2560  int OldIndex = RunSkipBlockVars.size() - 1;
2561  const RecordType *RT = FQT->getAs<RecordType>();
2562  BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset,
2563  HasUnion);
2564 
2565  // Replicate layout information for each array element. Note that
2566  // one element is already done.
2567  uint64_t ElIx = 1;
2568  for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2569  CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2570  for (int i = OldIndex+1; i <= FirstIndex; ++i)
2571  RunSkipBlockVars.push_back(
2572  RUN_SKIP(RunSkipBlockVars[i].opcode,
2573  RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2574  RunSkipBlockVars[i].block_var_size));
2575  }
2576  continue;
2577  }
2578  }
2579  CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2580  if (IsUnion) {
2581  CharUnits UnionIvarSize = FieldSize;
2582  if (UnionIvarSize > MaxUnionSize) {
2583  MaxUnionSize = UnionIvarSize;
2584  MaxField = Field;
2585  MaxFieldOffset = FieldOffset;
2586  }
2587  } else {
2588  UpdateRunSkipBlockVars(false,
2589  getBlockCaptureLifetime(FQT, ByrefLayout),
2590  BytePos + FieldOffset,
2591  FieldSize);
2592  }
2593  }
2594 
2595  if (LastFieldBitfieldOrUnnamed) {
2596  if (LastFieldBitfieldOrUnnamed->isBitField()) {
2597  // Last field was a bitfield. Must update the info.
2598  uint64_t BitFieldSize
2599  = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2600  unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2601  ((BitFieldSize % ByteSizeInBits) != 0);
2602  CharUnits Size = CharUnits::fromQuantity(UnsSize);
2603  Size += LastBitfieldOrUnnamedOffset;
2604  UpdateRunSkipBlockVars(false,
2605  getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2606  ByrefLayout),
2607  BytePos + LastBitfieldOrUnnamedOffset,
2608  Size);
2609  } else {
2610  assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2611  // Last field was unnamed. Must update skip info.
2612  CharUnits FieldSize
2613  = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2614  UpdateRunSkipBlockVars(false,
2615  getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2616  ByrefLayout),
2617  BytePos + LastBitfieldOrUnnamedOffset,
2618  FieldSize);
2619  }
2620  }
2621 
2622  if (MaxField)
2623  UpdateRunSkipBlockVars(false,
2624  getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2625  BytePos + MaxFieldOffset,
2626  MaxUnionSize);
2627 }
2628 
2629 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2630  CharUnits BytePos,
2631  bool &HasUnion,
2632  bool ByrefLayout) {
2633  const RecordDecl *RD = RT->getDecl();
2635  llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2636  const llvm::StructLayout *RecLayout =
2637  CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2638 
2639  BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2640 }
2641 
2642 /// InlineLayoutInstruction - This routine produce an inline instruction for the
2643 /// block variable layout if it can. If not, it returns 0. Rules are as follow:
2644 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2645 /// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2646 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2647 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2648 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2649 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2650 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2651 uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2653  uint64_t Result = 0;
2654  if (Layout.size() <= 3) {
2655  unsigned size = Layout.size();
2656  unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2657  unsigned char inst;
2658  enum BLOCK_LAYOUT_OPCODE opcode ;
2659  switch (size) {
2660  case 3:
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
2666  return 0;
2667  inst = Layout[1];
2668  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2669  if (opcode == BLOCK_LAYOUT_BYREF)
2670  byref_word_count = (inst & 0xF)+1;
2671  else
2672  return 0;
2673  inst = Layout[2];
2674  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2675  if (opcode == BLOCK_LAYOUT_WEAK)
2676  weak_word_count = (inst & 0xF)+1;
2677  else
2678  return 0;
2679  break;
2680 
2681  case 2:
2682  inst = Layout[0];
2683  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2684  if (opcode == BLOCK_LAYOUT_STRONG) {
2685  strong_word_count = (inst & 0xF)+1;
2686  inst = Layout[1];
2687  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2688  if (opcode == BLOCK_LAYOUT_BYREF)
2689  byref_word_count = (inst & 0xF)+1;
2690  else if (opcode == BLOCK_LAYOUT_WEAK)
2691  weak_word_count = (inst & 0xF)+1;
2692  else
2693  return 0;
2694  }
2695  else if (opcode == BLOCK_LAYOUT_BYREF) {
2696  byref_word_count = (inst & 0xF)+1;
2697  inst = Layout[1];
2698  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2699  if (opcode == BLOCK_LAYOUT_WEAK)
2700  weak_word_count = (inst & 0xF)+1;
2701  else
2702  return 0;
2703  }
2704  else
2705  return 0;
2706  break;
2707 
2708  case 1:
2709  inst = Layout[0];
2710  opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2711  if (opcode == BLOCK_LAYOUT_STRONG)
2712  strong_word_count = (inst & 0xF)+1;
2713  else if (opcode == BLOCK_LAYOUT_BYREF)
2714  byref_word_count = (inst & 0xF)+1;
2715  else if (opcode == BLOCK_LAYOUT_WEAK)
2716  weak_word_count = (inst & 0xF)+1;
2717  else
2718  return 0;
2719  break;
2720 
2721  default:
2722  return 0;
2723  }
2724 
2725  // Cannot inline when any of the word counts is 15. Because this is one less
2726  // than the actual work count (so 15 means 16 actual word counts),
2727  // and we can only display 0 thru 15 word counts.
2728  if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2729  return 0;
2730 
2731  unsigned count =
2732  (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2733 
2734  if (size == count) {
2735  if (strong_word_count)
2736  Result = strong_word_count;
2737  Result <<= 4;
2738  if (byref_word_count)
2739  Result += byref_word_count;
2740  Result <<= 4;
2741  if (weak_word_count)
2742  Result += weak_word_count;
2743  }
2744  }
2745  return Result;
2746 }
2747 
2748 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2749  llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2750  if (RunSkipBlockVars.empty())
2751  return nullPtr;
2752  unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2753  unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2754  unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2755 
2756  // Sort on byte position; captures might not be allocated in order,
2757  // and unions can do funny things.
2758  llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2760 
2761  unsigned size = RunSkipBlockVars.size();
2762  for (unsigned i = 0; i < size; i++) {
2763  enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2764  CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2765  CharUnits end_byte_pos = start_byte_pos;
2766  unsigned j = i+1;
2767  while (j < size) {
2768  if (opcode == RunSkipBlockVars[j].opcode) {
2769  end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2770  i++;
2771  }
2772  else
2773  break;
2774  }
2775  CharUnits size_in_bytes =
2776  end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2777  if (j < size) {
2778  CharUnits gap =
2779  RunSkipBlockVars[j].block_var_bytepos -
2780  RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2781  size_in_bytes += gap;
2782  }
2783  CharUnits residue_in_bytes = CharUnits::Zero();
2784  if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2785  residue_in_bytes = size_in_bytes % WordSizeInBytes;
2786  size_in_bytes -= residue_in_bytes;
2787  opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2788  }
2789 
2790  unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2791  while (size_in_words >= 16) {
2792  // Note that value in imm. is one less that the actual
2793  // value. So, 0xf means 16 words follow!
2794  unsigned char inst = (opcode << 4) | 0xf;
2795  Layout.push_back(inst);
2796  size_in_words -= 16;
2797  }
2798  if (size_in_words > 0) {
2799  // Note that value in imm. is one less that the actual
2800  // value. So, we subtract 1 away!
2801  unsigned char inst = (opcode << 4) | (size_in_words-1);
2802  Layout.push_back(inst);
2803  }
2804  if (residue_in_bytes > CharUnits::Zero()) {
2805  unsigned char inst =
2806  (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2807  Layout.push_back(inst);
2808  }
2809  }
2810 
2811  while (!Layout.empty()) {
2812  unsigned char inst = Layout.back();
2813  enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2814  if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2815  Layout.pop_back();
2816  else
2817  break;
2818  }
2819 
2820  uint64_t Result = InlineLayoutInstruction(Layout);
2821  if (Result != 0) {
2822  // Block variable layout instruction has been inlined.
2823  if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2824  if (ComputeByrefLayout)
2825  printf("\n Inline BYREF variable layout: ");
2826  else
2827  printf("\n Inline block variable layout: ");
2828  printf("0x0%" PRIx64 "", Result);
2829  if (auto numStrong = (Result & 0xF00) >> 8)
2830  printf(", BL_STRONG:%d", (int) numStrong);
2831  if (auto numByref = (Result & 0x0F0) >> 4)
2832  printf(", BL_BYREF:%d", (int) numByref);
2833  if (auto numWeak = (Result & 0x00F) >> 0)
2834  printf(", BL_WEAK:%d", (int) numWeak);
2835  printf(", BL_OPERATOR:0\n");
2836  }
2837  return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2838  }
2839 
2840  unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2841  Layout.push_back(inst);
2842  std::string BitMap;
2843  for (unsigned i = 0, e = Layout.size(); i != e; i++)
2844  BitMap += Layout[i];
2845 
2846  if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2847  if (ComputeByrefLayout)
2848  printf("\n Byref variable layout: ");
2849  else
2850  printf("\n Block variable layout: ");
2851  for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2852  unsigned char inst = BitMap[i];
2853  enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2854  unsigned delta = 1;
2855  switch (opcode) {
2856  case BLOCK_LAYOUT_OPERATOR:
2857  printf("BL_OPERATOR:");
2858  delta = 0;
2859  break;
2860  case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2861  printf("BL_NON_OBJECT_BYTES:");
2862  break;
2863  case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2864  printf("BL_NON_OBJECT_WORD:");
2865  break;
2866  case BLOCK_LAYOUT_STRONG:
2867  printf("BL_STRONG:");
2868  break;
2869  case BLOCK_LAYOUT_BYREF:
2870  printf("BL_BYREF:");
2871  break;
2872  case BLOCK_LAYOUT_WEAK:
2873  printf("BL_WEAK:");
2874  break;
2875  case BLOCK_LAYOUT_UNRETAINED:
2876  printf("BL_UNRETAINED:");
2877  break;
2878  }
2879  // Actual value of word count is one more that what is in the imm.
2880  // field of the instruction
2881  printf("%d", (inst & 0xf) + delta);
2882  if (i < e-1)
2883  printf(", ");
2884  else
2885  printf("\n");
2886  }
2887  }
2888 
2889  auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
2890  /*ForceNonFragileABI=*/true,
2891  /*NullTerminate=*/false);
2892  return getConstantGEP(VMContext, Entry, 0, 0);
2893 }
2894 
2895 static std::string getBlockLayoutInfoString(
2896  const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars,
2897  bool HasCopyDisposeHelpers) {
2898  std::string Str;
2899  for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) {
2900  if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) {
2901  // Copy/dispose helpers don't have any information about
2902  // __unsafe_unretained captures, so unconditionally concatenate a string.
2903  Str += "u";
2904  } else if (HasCopyDisposeHelpers) {
2905  // Information about __strong, __weak, or byref captures has already been
2906  // encoded into the names of the copy/dispose helpers. We have to add a
2907  // string here only when the copy/dispose helpers aren't generated (which
2908  // happens when the block is non-escaping).
2909  continue;
2910  } else {
2911  switch (R.opcode) {
2912  case CGObjCCommonMac::BLOCK_LAYOUT_STRONG:
2913  Str += "s";
2914  break;
2915  case CGObjCCommonMac::BLOCK_LAYOUT_BYREF:
2916  Str += "r";
2917  break;
2918  case CGObjCCommonMac::BLOCK_LAYOUT_WEAK:
2919  Str += "w";
2920  break;
2921  default:
2922  continue;
2923  }
2924  }
2925  Str += llvm::to_string(R.block_var_bytepos.getQuantity());
2926  Str += "l" + llvm::to_string(R.block_var_size.getQuantity());
2927  }
2928  return Str;
2929 }
2930 
2931 void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM,
2932  const CGBlockInfo &blockInfo) {
2933  assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2934 
2935  RunSkipBlockVars.clear();
2936  bool hasUnion = false;
2937 
2938  unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2939  unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2940  unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2941 
2942  const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2943 
2944  // Calculate the basic layout of the block structure.
2945  const llvm::StructLayout *layout =
2946  CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2947 
2948  // Ignore the optional 'this' capture: C++ objects are not assumed
2949  // to be GC'ed.
2950  if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2951  UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2952  blockInfo.BlockHeaderForcedGapOffset,
2953  blockInfo.BlockHeaderForcedGapSize);
2954  // Walk the captured variables.
2955  for (const auto &CI : blockDecl->captures()) {
2956  const VarDecl *variable = CI.getVariable();
2957  QualType type = variable->getType();
2958 
2959  const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2960 
2961  // Ignore constant captures.
2962  if (capture.isConstant()) continue;
2963 
2964  CharUnits fieldOffset =
2965  CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2966 
2967  assert(!type->isArrayType() && "array variable should not be caught");
2968  if (!CI.isByRef())
2969  if (const RecordType *record = type->getAs<RecordType>()) {
2970  BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2971  continue;
2972  }
2973  CharUnits fieldSize;
2974  if (CI.isByRef())
2975  fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2976  else
2977  fieldSize = CGM.getContext().getTypeSizeInChars(type);
2978  UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2979  fieldOffset, fieldSize);
2980  }
2981 }
2982 
2983 llvm::Constant *
2984 CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2985  const CGBlockInfo &blockInfo) {
2986  fillRunSkipBlockVars(CGM, blockInfo);
2987  return getBitmapBlockLayout(false);
2988 }
2989 
2990 std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM,
2991  const CGBlockInfo &blockInfo) {
2992  fillRunSkipBlockVars(CGM, blockInfo);
2993  return getBlockLayoutInfoString(RunSkipBlockVars,
2994  blockInfo.needsCopyDisposeHelpers());
2995 }
2996 
2997 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
2998  QualType T) {
2999  assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3000  assert(!T->isArrayType() && "__block array variable should not be caught");
3001  CharUnits fieldOffset;
3002  RunSkipBlockVars.clear();
3003  bool hasUnion = false;
3004  if (const RecordType *record = T->getAs<RecordType>()) {
3005  BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
3006  llvm::Constant *Result = getBitmapBlockLayout(true);
3007  if (isa<llvm::ConstantInt>(Result))
3008  Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
3009  return Result;
3010  }
3011  llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
3012  return nullPtr;
3013 }
3014 
3015 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
3016  const ObjCProtocolDecl *PD) {
3017  // FIXME: I don't understand why gcc generates this, or where it is
3018  // resolved. Investigate. Its also wasteful to look this up over and over.
3019  LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3020 
3021  return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
3022  ObjCTypes.getExternalProtocolPtrTy());
3023 }
3024 
3025 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
3026  // FIXME: We shouldn't need this, the protocol decl should contain enough
3027  // information to tell us whether this was a declaration or a definition.
3028  DefinedProtocols.insert(PD->getIdentifier());
3029 
3030  // If we have generated a forward reference to this protocol, emit
3031  // it now. Otherwise do nothing, the protocol objects are lazily
3032  // emitted.
3033  if (Protocols.count(PD->getIdentifier()))
3034  GetOrEmitProtocol(PD);
3035 }
3036 
3037 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
3038  if (DefinedProtocols.count(PD->getIdentifier()))
3039  return GetOrEmitProtocol(PD);
3040 
3041  return GetOrEmitProtocolRef(PD);
3042 }
3043 
3044 llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
3045  CodeGenFunction &CGF,
3046  const ObjCInterfaceDecl *ID,
3047  ObjCCommonTypesHelper &ObjCTypes) {
3048  llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn();
3049 
3050  llvm::Value *className =
3052  .getPointer();
3053  ASTContext &ctx = CGF.CGM.getContext();
3054  className =
3055  CGF.Builder.CreateBitCast(className,
3056  CGF.ConvertType(
3057  ctx.getPointerType(ctx.CharTy.withConst())));
3058  llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
3059  call->setDoesNotThrow();
3060  return call;
3061 }
3062 
3063 /*
3064 // Objective-C 1.0 extensions
3065 struct _objc_protocol {
3066 struct _objc_protocol_extension *isa;
3067 char *protocol_name;
3068 struct _objc_protocol_list *protocol_list;
3069 struct _objc__method_prototype_list *instance_methods;
3070 struct _objc__method_prototype_list *class_methods
3071 };
3072 
3073 See EmitProtocolExtension().
3074 */
3075 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
3076  llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
3077 
3078  // Early exit if a defining object has already been generated.
3079  if (Entry && Entry->hasInitializer())
3080  return Entry;
3081 
3082  // Use the protocol definition, if there is one.
3083  if (const ObjCProtocolDecl *Def = PD->getDefinition())
3084  PD = Def;
3085 
3086  // FIXME: I don't understand why gcc generates this, or where it is
3087  // resolved. Investigate. Its also wasteful to look this up over and over.
3088  LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3089 
3090  // Construct method lists.
3091  auto methodLists = ProtocolMethodLists::get(PD);
3092 
3093  ConstantInitBuilder builder(CGM);
3094  auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
3095  values.add(EmitProtocolExtension(PD, methodLists));
3096  values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
3097  values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
3098  PD->protocol_begin(), PD->protocol_end()));
3099  values.add(methodLists.emitMethodList(this, PD,
3100  ProtocolMethodLists::RequiredInstanceMethods));
3101  values.add(methodLists.emitMethodList(this, PD,
3102  ProtocolMethodLists::RequiredClassMethods));
3103 
3104  if (Entry) {
3105  // Already created, update the initializer.
3106  assert(Entry->hasPrivateLinkage());
3107  values.finishAndSetAsInitializer(Entry);
3108  } else {
3109  Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
3110  CGM.getPointerAlign(),
3111  /*constant*/ false,
3112  llvm::GlobalValue::PrivateLinkage);
3113  Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3114 
3115  Protocols[PD->getIdentifier()] = Entry;
3116  }
3117  CGM.addCompilerUsedGlobal(Entry);
3118 
3119  return Entry;
3120 }
3121 
3122 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
3123  llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
3124 
3125  if (!Entry) {
3126  // We use the initializer as a marker of whether this is a forward
3127  // reference or not. At module finalization we add the empty
3128  // contents for protocols which were referenced but never defined.
3129  Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
3130  false, llvm::GlobalValue::PrivateLinkage,
3131  nullptr, "OBJC_PROTOCOL_" + PD->getName());
3132  Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3133  // FIXME: Is this necessary? Why only for protocol?
3134  Entry->setAlignment(llvm::Align(4));
3135  }
3136 
3137  return Entry;
3138 }
3139 
3140 /*
3141  struct _objc_protocol_extension {
3142  uint32_t size;
3143  struct objc_method_description_list *optional_instance_methods;
3144  struct objc_method_description_list *optional_class_methods;
3145  struct objc_property_list *instance_properties;
3146  const char ** extendedMethodTypes;
3147  struct objc_property_list *class_properties;
3148  };
3149 */
3150 llvm::Constant *
3151 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
3152  const ProtocolMethodLists &methodLists) {
3153  auto optInstanceMethods =
3154  methodLists.emitMethodList(this, PD,
3155  ProtocolMethodLists::OptionalInstanceMethods);
3156  auto optClassMethods =
3157  methodLists.emitMethodList(this, PD,
3158  ProtocolMethodLists::OptionalClassMethods);
3159 
3160  auto extendedMethodTypes =
3161  EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3162  methodLists.emitExtendedTypesArray(this),
3163  ObjCTypes);
3164 
3165  auto instanceProperties =
3166  EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3167  ObjCTypes, false);
3168  auto classProperties =
3169  EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3170  PD, ObjCTypes, true);
3171 
3172  // Return null if no extension bits are used.
3173  if (optInstanceMethods->isNullValue() &&
3174  optClassMethods->isNullValue() &&
3175  extendedMethodTypes->isNullValue() &&
3176  instanceProperties->isNullValue() &&
3177  classProperties->isNullValue()) {
3178  return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3179  }
3180 
3181  uint64_t size =
3182  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3183 
3184  ConstantInitBuilder builder(CGM);
3185  auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3186  values.addInt(ObjCTypes.IntTy, size);
3187  values.add(optInstanceMethods);
3188  values.add(optClassMethods);
3189  values.add(instanceProperties);
3190  values.add(extendedMethodTypes);
3191  values.add(classProperties);
3192 
3193  // No special section, but goes in llvm.used
3194  return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3195  StringRef(), CGM.getPointerAlign(), true);
3196 }
3197 
3198 /*
3199  struct objc_protocol_list {
3200  struct objc_protocol_list *next;
3201  long count;
3202  Protocol *list[];
3203  };
3204 */
3205 llvm::Constant *
3206 CGObjCMac::EmitProtocolList(Twine name,
3209  // Just return null for empty protocol lists
3210  if (begin == end)
3211  return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3212 
3213  ConstantInitBuilder builder(CGM);
3214  auto values = builder.beginStruct();
3215 
3216  // This field is only used by the runtime.
3217  values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3218 
3219  // Reserve a slot for the count.
3220  auto countSlot = values.addPlaceholder();
3221 
3222  auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3223  for (; begin != end; ++begin) {
3224  refsArray.add(GetProtocolRef(*begin));
3225  }
3226  auto count = refsArray.size();
3227 
3228  // This list is null terminated.
3229  refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3230 
3231  refsArray.finishAndAddTo(values);
3232  values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3233 
3234  StringRef section;
3235  if (CGM.getTriple().isOSBinFormatMachO())
3236  section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3237 
3238  llvm::GlobalVariable *GV =
3239  CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3240  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3241 }
3242 
3243 static void
3244 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
3246  const ObjCProtocolDecl *Proto,
3247  bool IsClassProperty) {
3248  for (const auto *PD : Proto->properties()) {
3249  if (IsClassProperty != PD->isClassProperty())
3250  continue;
3251  if (!PropertySet.insert(PD->getIdentifier()).second)
3252  continue;
3253  Properties.push_back(PD);
3254  }
3255 
3256  for (const auto *P : Proto->protocols())
3257  PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3258 }
3259 
3260 /*
3261  struct _objc_property {
3262  const char * const name;
3263  const char * const attributes;
3264  };
3265 
3266  struct _objc_property_list {
3267  uint32_t entsize; // sizeof (struct _objc_property)
3268  uint32_t prop_count;
3269  struct _objc_property[prop_count];
3270  };
3271 */
3272 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3273  const Decl *Container,
3274  const ObjCContainerDecl *OCD,
3275  const ObjCCommonTypesHelper &ObjCTypes,
3276  bool IsClassProperty) {
3277  if (IsClassProperty) {
3278  // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3279  // with deployment target < 9.0.
3280  const llvm::Triple &Triple = CGM.getTarget().getTriple();
3281  if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
3282  (Triple.isiOS() && Triple.isOSVersionLT(9)))
3283  return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3284  }
3285 
3287  llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3288 
3289  if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3290  for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3291  for (auto *PD : ClassExt->properties()) {
3292  if (IsClassProperty != PD->isClassProperty())
3293  continue;
3294  PropertySet.insert(PD->getIdentifier());
3295  Properties.push_back(PD);
3296  }
3297 
3298  for (const auto *PD : OCD->properties()) {
3299  if (IsClassProperty != PD->isClassProperty())
3300  continue;
3301  // Don't emit duplicate metadata for properties that were already in a
3302  // class extension.
3303  if (!PropertySet.insert(PD->getIdentifier()).second)
3304  continue;
3305  Properties.push_back(PD);
3306  }
3307 
3308  if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3309  for (const auto *P : OID->all_referenced_protocols())
3310  PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3311  }
3312  else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3313  for (const auto *P : CD->protocols())
3314  PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3315  }
3316 
3317  // Return null for empty list.
3318  if (Properties.empty())
3319  return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3320 
3321  unsigned propertySize =
3322  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3323 
3324  ConstantInitBuilder builder(CGM);
3325  auto values = builder.beginStruct();
3326  values.addInt(ObjCTypes.IntTy, propertySize);
3327  values.addInt(ObjCTypes.IntTy, Properties.size());
3328  auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3329  for (auto PD : Properties) {
3330  if (PD->isDirectProperty())
3331  continue;
3332  auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3333  property.add(GetPropertyName(PD->getIdentifier()));
3334  property.add(GetPropertyTypeString(PD, Container));
3335  property.finishAndAddTo(propertiesArray);
3336  }
3337  propertiesArray.finishAndAddTo(values);
3338 
3339  StringRef Section;
3340  if (CGM.getTriple().isOSBinFormatMachO())
3341  Section = (ObjCABI == 2) ? "__DATA, __objc_const"
3342  : "__OBJC,__property,regular,no_dead_strip";
3343 
3344  llvm::GlobalVariable *GV =
3345  CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3346  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3347 }
3348 
3349 llvm::Constant *
3350 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3351  ArrayRef<llvm::Constant*> MethodTypes,
3352  const ObjCCommonTypesHelper &ObjCTypes) {
3353  // Return null for empty list.
3354  if (MethodTypes.empty())
3355  return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3356 
3357  llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3358  MethodTypes.size());
3359  llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3360 
3361  StringRef Section;
3362  if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
3363  Section = "__DATA, __objc_const";
3364 
3365  llvm::GlobalVariable *GV =
3366  CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3367  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3368 }
3369 
3370 /*
3371  struct _objc_category {
3372  char *category_name;
3373  char *class_name;
3374  struct _objc_method_list *instance_methods;
3375  struct _objc_method_list *class_methods;
3376  struct _objc_protocol_list *protocols;
3377  uint32_t size; // <rdar://4585769>
3378  struct _objc_property_list *instance_properties;
3379  struct _objc_property_list *class_properties;
3380  };
3381 */
3382 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3383  unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3384 
3385  // FIXME: This is poor design, the OCD should have a pointer to the category
3386  // decl. Additionally, note that Category can be null for the @implementation
3387  // w/o an @interface case. Sema should just create one for us as it does for
3388  // @implementation so everyone else can live life under a clear blue sky.
3389  const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3390  const ObjCCategoryDecl *Category =
3391  Interface->FindCategoryDeclaration(OCD->getIdentifier());
3392 
3393  SmallString<256> ExtName;
3394  llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3395  << OCD->getName();
3396 
3397  ConstantInitBuilder Builder(CGM);
3398  auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3399 
3400  enum {
3401  InstanceMethods,
3402  ClassMethods,
3403  NumMethodLists
3404  };
3405  SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3406  for (const auto *MD : OCD->methods()) {
3407  if (!MD->isDirectMethod())
3408  Methods[unsigned(MD->isClassMethod())].push_back(MD);
3409  }
3410 
3411  Values.add(GetClassName(OCD->getName()));
3412  Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3413  LazySymbols.insert(Interface->getIdentifier());
3414 
3415  Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3416  Methods[InstanceMethods]));
3417  Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3418  Methods[ClassMethods]));
3419  if (Category) {
3420  Values.add(
3421  EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3422  Category->protocol_begin(), Category->protocol_end()));
3423  } else {
3424  Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3425  }
3426  Values.addInt(ObjCTypes.IntTy, Size);
3427 
3428  // If there is no category @interface then there can be no properties.
3429  if (Category) {
3430  Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
3431  OCD, Category, ObjCTypes, false));
3432  Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3433  OCD, Category, ObjCTypes, true));
3434  } else {
3435  Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3436  Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3437  }
3438 
3439  llvm::GlobalVariable *GV =
3440  CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3441  "__OBJC,__category,regular,no_dead_strip",
3442  CGM.getPointerAlign(), true);
3443  DefinedCategories.push_back(GV);
3444  DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3445  // method definition entries must be clear for next implementation.
3446  MethodDefinitions.clear();
3447 }
3448 
3450  /// Apparently: is not a meta-class.
3452 
3453  /// Is a meta-class.
3455 
3456  /// Has a non-trivial constructor or destructor.
3458 
3459  /// Has hidden visibility.
3461 
3462  /// Class implementation was compiled under ARC.
3464 
3465  /// Class implementation was compiled under MRC and has MRC weak ivars.
3466  /// Exclusive with CompiledByARC.
3468 };
3469 
3471  /// Is a meta-class.
3473 
3474  /// Is a root class.
3476 
3477  /// Has a non-trivial constructor or destructor.
3479 
3480  /// Has hidden visibility.
3482 
3483  /// Has the exception attribute.
3485 
3486  /// (Obsolete) ARC-specific: this class has a .release_ivars method
3488 
3489  /// Class implementation was compiled under ARC.
3491 
3492  /// Class has non-trivial destructors, but zero-initialization is okay.
3494 
3495  /// Class implementation was compiled under MRC and has MRC weak ivars.
3496  /// Exclusive with CompiledByARC.
3498 };
3499 
3501  if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3502  return true;
3503  }
3504 
3505  if (auto recType = type->getAs<RecordType>()) {
3506  for (auto field : recType->getDecl()->fields()) {
3507  if (hasWeakMember(field->getType()))
3508  return true;
3509  }
3510  }
3511 
3512  return false;
3513 }
3514 
3515 /// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3516 /// (and actually fill in a layout string) if we really do have any
3517 /// __weak ivars.
3519  const ObjCImplementationDecl *ID) {
3520  if (!CGM.getLangOpts().ObjCWeak) return false;
3521  assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3522 
3523  for (const ObjCIvarDecl *ivar =
3525  ivar; ivar = ivar->getNextIvar()) {
3526  if (hasWeakMember(ivar->getType()))
3527  return true;
3528  }
3529 
3530  return false;
3531 }
3532 
3533 /*
3534  struct _objc_class {
3535  Class isa;
3536  Class super_class;
3537  const char *name;
3538  long version;
3539  long info;
3540  long instance_size;
3541  struct _objc_ivar_list *ivars;
3542  struct _objc_method_list *methods;
3543  struct _objc_cache *cache;
3544  struct _objc_protocol_list *protocols;
3545  // Objective-C 1.0 extensions (<rdr://4585769>)
3546  const char *ivar_layout;
3547  struct _objc_class_ext *ext;
3548  };
3549 
3550  See EmitClassExtension();
3551 */
3552 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3553  IdentifierInfo *RuntimeName =
3555  DefinedSymbols.insert(RuntimeName);
3556 
3557  std::string ClassName = ID->getNameAsString();
3558  // FIXME: Gross
3559  ObjCInterfaceDecl *Interface =
3560  const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3561  llvm::Constant *Protocols =
3562  EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3563  Interface->all_referenced_protocol_begin(),
3564  Interface->all_referenced_protocol_end());
3565  unsigned Flags = FragileABI_Class_Factory;
3566  if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3568 
3569  bool hasMRCWeak = false;
3570 
3571  if (CGM.getLangOpts().ObjCAutoRefCount)
3573  else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3575 
3576  CharUnits Size =
3578 
3579  // FIXME: Set CXX-structors flag.
3581  Flags |= FragileABI_Class_Hidden;
3582 
3583  enum {
3584  InstanceMethods,
3585  ClassMethods,
3586  NumMethodLists
3587  };
3588  SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3589  for (const auto *MD : ID->methods()) {
3590  if (!MD->isDirectMethod())
3591  Methods[unsigned(MD->isClassMethod())].push_back(MD);
3592  }
3593 
3594  for (const auto *PID : ID->property_impls()) {
3595  if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3596  if (PID->getPropertyDecl()->isDirectProperty())
3597  continue;
3598  if (ObjCMethodDecl *MD = PID->getGetterMethodDecl())
3599  if (GetMethodDefinition(MD))
3600  Methods[InstanceMethods].push_back(MD);
3601  if (ObjCMethodDecl *MD = PID->getSetterMethodDecl())
3602  if (GetMethodDefinition(MD))
3603  Methods[InstanceMethods].push_back(MD);
3604  }
3605  }
3606 
3607  ConstantInitBuilder builder(CGM);
3608  auto values = builder.beginStruct(ObjCTypes.ClassTy);
3609  values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3610  if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3611  // Record a reference to the super class.
3612  LazySymbols.insert(Super->getIdentifier());
3613 
3614  values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3615  ObjCTypes.ClassPtrTy);
3616  } else {
3617  values.addNullPointer(ObjCTypes.ClassPtrTy);
3618  }
3619  values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3620  // Version is always 0.
3621  values.addInt(ObjCTypes.LongTy, 0);
3622  values.addInt(ObjCTypes.LongTy, Flags);
3623  values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3624  values.add(EmitIvarList(ID, false));
3625  values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3626  Methods[InstanceMethods]));
3627  // cache is always NULL.
3628  values.addNullPointer(ObjCTypes.CachePtrTy);
3629  values.add(Protocols);
3630  values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3631  values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3632  /*isMetaclass*/ false));
3633 
3634  std::string Name("OBJC_CLASS_");
3635  Name += ClassName;
3636  const char *Section = "__OBJC,__class,regular,no_dead_strip";
3637  // Check for a forward reference.
3638  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3639  if (GV) {
3640  assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3641  "Forward metaclass reference has incorrect type.");
3642  values.finishAndSetAsInitializer(GV);
3643  GV->setSection(Section);
3644  GV->setAlignment(CGM.getPointerAlign().getAsAlign());
3645  CGM.addCompilerUsedGlobal(GV);
3646  } else
3647  GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3648  DefinedClasses.push_back(GV);
3649  ImplementedClasses.push_back(Interface);
3650  // method definition entries must be clear for next implementation.
3651  MethodDefinitions.clear();
3652 }
3653 
3654 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3655  llvm::Constant *Protocols,
3657  unsigned Flags = FragileABI_Class_Meta;
3658  unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3659 
3661  Flags |= FragileABI_Class_Hidden;
3662 
3663  ConstantInitBuilder builder(CGM);
3664  auto values = builder.beginStruct(ObjCTypes.ClassTy);
3665  // The isa for the metaclass is the root of the hierarchy.
3666  const ObjCInterfaceDecl *Root = ID->getClassInterface();
3667  while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3668  Root = Super;
3669  values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3670  ObjCTypes.ClassPtrTy);
3671  // The super class for the metaclass is emitted as the name of the
3672  // super class. The runtime fixes this up to point to the
3673  // *metaclass* for the super class.
3674  if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3675  values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3676  ObjCTypes.ClassPtrTy);
3677  } else {
3678  values.addNullPointer(ObjCTypes.ClassPtrTy);
3679  }
3680  values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3681  // Version is always 0.
3682  values.addInt(ObjCTypes.LongTy, 0);
3683  values.addInt(ObjCTypes.LongTy, Flags);
3684  values.addInt(ObjCTypes.LongTy, Size);
3685  values.add(EmitIvarList(ID, true));
3686  values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3687  Methods));
3688  // cache is always NULL.
3689  values.addNullPointer(ObjCTypes.CachePtrTy);
3690  values.add(Protocols);
3691  // ivar_layout for metaclass is always NULL.
3692  values.addNullPointer(ObjCTypes.Int8PtrTy);
3693  // The class extension is used to store class properties for metaclasses.
3694  values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3695  /*isMetaclass*/true));
3696 
3697  std::string Name("OBJC_METACLASS_");
3698  Name += ID->getName();
3699 
3700  // Check for a forward reference.
3701  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3702  if (GV) {
3703  assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3704  "Forward metaclass reference has incorrect type.");
3705  values.finishAndSetAsInitializer(GV);
3706  } else {
3707  GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3708  /*constant*/ false,
3709  llvm::GlobalValue::PrivateLinkage);
3710  }
3711  GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3712  CGM.addCompilerUsedGlobal(GV);
3713 
3714  return GV;
3715 }
3716 
3717 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3718  std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3719 
3720  // FIXME: Should we look these up somewhere other than the module. Its a bit
3721  // silly since we only generate these while processing an implementation, so
3722  // exactly one pointer would work if know when we entered/exitted an
3723  // implementation block.
3724 
3725  // Check for an existing forward reference.
3726  // Previously, metaclass with internal linkage may have been defined.
3727  // pass 'true' as 2nd argument so it is returned.
3728  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3729  if (!GV)
3730  GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3731  llvm::GlobalValue::PrivateLinkage, nullptr,
3732  Name);
3733 
3734  assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3735  "Forward metaclass reference has incorrect type.");
3736  return GV;
3737 }
3738 
3739 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3740  std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3741  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3742 
3743  if (!GV)
3744  GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3745  llvm::GlobalValue::PrivateLinkage, nullptr,
3746  Name);
3747 
3748  assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3749  "Forward class metadata reference has incorrect type.");
3750  return GV;
3751 }
3752 
3753 /*
3754  Emit a "class extension", which in this specific context means extra
3755  data that doesn't fit in the normal fragile-ABI class structure, and
3756  has nothing to do with the language concept of a class extension.
3757 
3758  struct objc_class_ext {
3759  uint32_t size;
3760  const char *weak_ivar_layout;
3761  struct _objc_property_list *properties;
3762  };
3763 */
3764 llvm::Constant *
3765 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3766  CharUnits InstanceSize, bool hasMRCWeakIvars,
3767  bool isMetaclass) {
3768  // Weak ivar layout.
3769  llvm::Constant *layout;
3770  if (isMetaclass) {
3771  layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3772  } else {
3773  layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3774  hasMRCWeakIvars);
3775  }
3776 
3777  // Properties.
3778  llvm::Constant *propertyList =
3779  EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_")
3780  : Twine("_OBJC_$_PROP_LIST_"))
3781  + ID->getName(),
3782  ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3783 
3784  // Return null if no extension bits are used.
3785  if (layout->isNullValue() && propertyList->isNullValue()) {
3786  return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3787  }
3788 
3789  uint64_t size =
3790  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3791 
3792  ConstantInitBuilder builder(CGM);
3793  auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3794  values.addInt(ObjCTypes.IntTy, size);
3795  values.add(layout);
3796  values.add(propertyList);
3797 
3798  return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3799  "__OBJC,__class_ext,regular,no_dead_strip",
3800  CGM.getPointerAlign(), true);
3801 }
3802 
3803 /*
3804  struct objc_ivar {
3805  char *ivar_name;
3806  char *ivar_type;
3807  int ivar_offset;
3808  };
3809 
3810  struct objc_ivar_list {
3811  int ivar_count;
3812  struct objc_ivar list[count];
3813  };
3814 */
3815 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3816  bool ForClass) {
3817  // When emitting the root class GCC emits ivar entries for the
3818  // actual class structure. It is not clear if we need to follow this
3819  // behavior; for now lets try and get away with not doing it. If so,
3820  // the cleanest solution would be to make up an ObjCInterfaceDecl
3821  // for the class.
3822  if (ForClass)
3823  return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3824 
3825  const ObjCInterfaceDecl *OID = ID->getClassInterface();
3826 
3827  ConstantInitBuilder builder(CGM);
3828  auto ivarList = builder.beginStruct();
3829  auto countSlot = ivarList.addPlaceholder();
3830  auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3831 
3832  for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3833  IVD; IVD = IVD->getNextIvar()) {
3834  // Ignore unnamed bit-fields.
3835  if (!IVD->getDeclName())
3836  continue;
3837 
3838  auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3839  ivar.add(GetMethodVarName(IVD->getIdentifier()));
3840  ivar.add(GetMethodVarType(IVD));
3841  ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3842  ivar.finishAndAddTo(ivars);
3843  }
3844 
3845  // Return null for empty list.
3846  auto count = ivars.size();
3847  if (count == 0) {
3848  ivars.abandon();
3849  ivarList.abandon();
3850  return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3851  }
3852 
3853  ivars.finishAndAddTo(ivarList);
3854  ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3855 
3856  llvm::GlobalVariable *GV;
3857  if (ForClass)
3858  GV =
3859  CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3860  "__OBJC,__class_vars,regular,no_dead_strip",
3861  CGM.getPointerAlign(), true);
3862  else
3863  GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3864  "__OBJC,__instance_vars,regular,no_dead_strip",
3865  CGM.getPointerAlign(), true);
3866  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3867 }
3868 
3869 /// Build a struct objc_method_description constant for the given method.
3870 ///
3871 /// struct objc_method_description {
3872 /// SEL method_name;
3873 /// char *method_types;
3874 /// };
3875 void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3876  const ObjCMethodDecl *MD) {
3877  auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3878  description.addBitCast(GetMethodVarName(MD->getSelector()),
3879  ObjCTypes.SelectorPtrTy);
3880  description.add(GetMethodVarType(MD));
3881  description.finishAndAddTo(builder);
3882 }
3883 
3884 /// Build a struct objc_method constant for the given method.
3885 ///
3886 /// struct objc_method {
3887 /// SEL method_name;
3888 /// char *method_types;
3889 /// void *method;
3890 /// };
3891 void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3892  const ObjCMethodDecl *MD) {
3893  llvm::Function *fn = GetMethodDefinition(MD);
3894  assert(fn && "no definition registered for method");
3895 
3896  auto method = builder.beginStruct(ObjCTypes.MethodTy);
3897  method.addBitCast(GetMethodVarName(MD->getSelector()),
3898  ObjCTypes.SelectorPtrTy);
3899  method.add(GetMethodVarType(MD));
3900  method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3901  method.finishAndAddTo(builder);
3902 }
3903 
3904 /// Build a struct objc_method_list or struct objc_method_description_list,
3905 /// as appropriate.
3906 ///
3907 /// struct objc_method_list {
3908 /// struct objc_method_list *obsolete;
3909 /// int count;
3910 /// struct objc_method methods_list[count];
3911 /// };
3912 ///
3913 /// struct objc_method_description_list {
3914 /// int count;
3915 /// struct objc_method_description list[count];
3916 /// };
3917 llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3919  StringRef prefix;
3920  StringRef section;
3921  bool forProtocol = false;
3922  switch (MLT) {
3923  case MethodListType::CategoryInstanceMethods:
3924  prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3925  section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3926  forProtocol = false;
3927  break;
3928  case MethodListType::CategoryClassMethods:
3929  prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3930  section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3931  forProtocol = false;
3932  break;
3933  case MethodListType::InstanceMethods:
3934  prefix = "OBJC_INSTANCE_METHODS_";
3935  section = "__OBJC,__inst_meth,regular,no_dead_strip";
3936  forProtocol = false;
3937  break;
3938  case MethodListType::ClassMethods:
3939  prefix = "OBJC_CLASS_METHODS_";
3940  section = "__OBJC,__cls_meth,regular,no_dead_strip";
3941  forProtocol = false;
3942  break;
3943  case MethodListType::ProtocolInstanceMethods:
3944  prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3945  section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3946  forProtocol = true;
3947  break;
3948  case MethodListType::ProtocolClassMethods:
3949  prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3950  section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3951  forProtocol = true;
3952  break;
3953  case MethodListType::OptionalProtocolInstanceMethods:
3954  prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3955  section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3956  forProtocol = true;
3957  break;
3958  case MethodListType::OptionalProtocolClassMethods:
3959  prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3960  section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3961  forProtocol = true;
3962  break;
3963  }
3964 
3965  // Return null for empty list.
3966  if (methods.empty())
3967  return llvm::Constant::getNullValue(forProtocol
3968  ? ObjCTypes.MethodDescriptionListPtrTy
3969  : ObjCTypes.MethodListPtrTy);
3970 
3971  // For protocols, this is an objc_method_description_list, which has
3972  // a slightly different structure.
3973  if (forProtocol) {
3974  ConstantInitBuilder builder(CGM);
3975  auto values = builder.beginStruct();
3976  values.addInt(ObjCTypes.IntTy, methods.size());
3977  auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3978  for (auto MD : methods) {
3979  emitMethodDescriptionConstant(methodArray, MD);
3980  }
3981  methodArray.finishAndAddTo(values);
3982 
3983  llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3984  CGM.getPointerAlign(), true);
3985  return llvm::ConstantExpr::getBitCast(GV,
3986  ObjCTypes.MethodDescriptionListPtrTy);
3987  }
3988 
3989  // Otherwise, it's an objc_method_list.
3990  ConstantInitBuilder builder(CGM);
3991  auto values = builder.beginStruct();
3992  values.addNullPointer(ObjCTypes.Int8PtrTy);
3993  values.addInt(ObjCTypes.IntTy, methods.size());
3994  auto methodArray = values.beginArray(ObjCTypes.MethodTy);
3995  for (auto MD : methods) {
3996  if (!MD->isDirectMethod())
3997  emitMethodConstant(methodArray, MD);
3998  }
3999  methodArray.finishAndAddTo(values);
4000 
4001  llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
4002  CGM.getPointerAlign(), true);
4003  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
4004 }
4005 
4006 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
4007  const ObjCContainerDecl *CD) {
4008  llvm::Function *Method;
4009 
4010  if (OMD->isDirectMethod()) {
4011  Method = GenerateDirectMethod(OMD, CD);
4012  } else {
4013  SmallString<256> Name;
4014  GetNameForMethod(OMD, CD, Name);
4015 
4016  CodeGenTypes &Types = CGM.getTypes();
4017  llvm::FunctionType *MethodTy =
4019  Method =
4021  Name.str(), &CGM.getModule());
4022  }
4023 
4024  MethodDefinitions.insert(std::make_pair(OMD, Method));
4025 
4026  return Method;
4027 }
4028 
4029 llvm::Function *
4030 CGObjCCommonMac::GenerateDirectMethod(const ObjCMethodDecl *OMD,
4031  const ObjCContainerDecl *CD) {
4032  auto I = DirectMethodDefinitions.find(OMD->getCanonicalDecl());
4033  if (I != DirectMethodDefinitions.end())
4034  return I->second;
4035 
4036  SmallString<256> Name;
4037  GetNameForMethod(OMD, CD, Name, /*ignoreCategoryNamespace*/true);
4038 
4039  CodeGenTypes &Types = CGM.getTypes();
4040  llvm::FunctionType *MethodTy =
4042  llvm::Function *Method =
4044  Name.str(), &CGM.getModule());
4045  DirectMethodDefinitions.insert(std::make_pair(OMD->getCanonicalDecl(), Method));
4046 
4047  return Method;
4048 }
4049 
4050 void CGObjCCommonMac::GenerateDirectMethodPrologue(
4051  CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD,
4052  const ObjCContainerDecl *CD) {
4053  auto &Builder = CGF.Builder;
4054  bool ReceiverCanBeNull = true;
4055  auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
4056  auto selfValue = Builder.CreateLoad(selfAddr);
4057 
4058  // Generate:
4059  //
4060  // /* for class methods only to force class lazy initialization */
4061  // self = [self self];
4062  //
4063  // /* unless the receiver is never NULL */
4064  // if (self == nil) {
4065  // return (ReturnType){ };
4066  // }
4067  //
4068  // _cmd = @selector(...)
4069  // ...
4070 
4071  if (OMD->isClassMethod()) {
4072  const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD);
4073  assert(OID &&
4074  "GenerateDirectMethod() should be called with the Class Interface");
4075  Selector SelfSel = GetNullarySelector("self", CGM.getContext());
4076  auto ResultType = CGF.getContext().getObjCIdType();
4077  RValue result;
4078  CallArgList Args;
4079 
4080  // TODO: If this method is inlined, the caller might know that `self` is
4081  // already initialized; for example, it might be an ordinary Objective-C
4082  // method which always receives an initialized `self`, or it might have just
4083  // forced initialization on its own.
4084  //
4085  // We should find a way to eliminate this unnecessary initialization in such
4086  // cases in LLVM.
4087  result = GeneratePossiblySpecializedMessageSend(
4088  CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID,
4089  nullptr, true);
4090  Builder.CreateStore(result.getScalarVal(), selfAddr);
4091 
4092  // Nullable `Class` expressions cannot be messaged with a direct method
4093  // so the only reason why the receive can be null would be because
4094  // of weak linking.
4095  ReceiverCanBeNull = isWeakLinkedClass(OID);
4096  }
4097 
4098  if (ReceiverCanBeNull) {
4099  llvm::BasicBlock *SelfIsNilBlock =
4100  CGF.createBasicBlock("objc_direct_method.self_is_nil");
4101  llvm::BasicBlock *ContBlock =
4102  CGF.createBasicBlock("objc_direct_method.cont");
4103 
4104  // if (self == nil) {
4105  auto selfTy = cast<llvm::PointerType>(selfValue->getType());
4106  auto Zero = llvm::ConstantPointerNull::get(selfTy);
4107 
4108  llvm::MDBuilder MDHelper(CGM.getLLVMContext());
4109  Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero), SelfIsNilBlock,
4110  ContBlock, MDHelper.createBranchWeights(1, 1 << 20));
4111 
4112  CGF.EmitBlock(SelfIsNilBlock);
4113 
4114  // return (ReturnType){ };
4115  auto retTy = OMD->getReturnType();
4116  Builder.SetInsertPoint(SelfIsNilBlock);
4117  if (!retTy->isVoidType()) {
4118  CGF.EmitNullInitialization(CGF.ReturnValue, retTy);
4119  }
4121  // }
4122 
4123  // rest of the body
4124  CGF.EmitBlock(ContBlock);
4125  Builder.SetInsertPoint(ContBlock);
4126  }
4127 
4128  // only synthesize _cmd if it's referenced
4129  if (OMD->getCmdDecl()->isUsed()) {
4130  Builder.CreateStore(GetSelector(CGF, OMD),
4131  CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
4132  }
4133 }
4134 
4135 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4136  ConstantStructBuilder &Init,
4137  StringRef Section,
4138  CharUnits Align,
4139  bool AddToUsed) {
4140  llvm::GlobalValue::LinkageTypes LT =
4141  getLinkageTypeForObjCMetadata(CGM, Section);
4142  llvm::GlobalVariable *GV =
4143  Init.finishAndCreateGlobal(Name, Align, /*constant*/ false, LT);
4144  if (!Section.empty())
4145  GV->setSection(Section);
4146  if (AddToUsed)
4147  CGM.addCompilerUsedGlobal(GV);
4148  return GV;
4149 }
4150 
4151 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4152  llvm::Constant *Init,
4153  StringRef Section,
4154  CharUnits Align,
4155  bool AddToUsed) {
4156  llvm::Type *Ty = Init->getType();
4157  llvm::GlobalValue::LinkageTypes LT =
4158  getLinkageTypeForObjCMetadata(CGM, Section);
4159  llvm::GlobalVariable *GV =
4160  new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name);
4161  if (!Section.empty())
4162  GV->setSection(Section);
4163  GV->setAlignment(Align.getAsAlign());
4164  if (AddToUsed)
4165  CGM.addCompilerUsedGlobal(GV);
4166  return GV;
4167 }
4168 
4169 llvm::GlobalVariable *
4170 CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
4171  bool ForceNonFragileABI,
4172  bool NullTerminate) {
4173  StringRef Label;
4174  switch (Type) {
4175  case ObjCLabelType::ClassName: Label = "OBJC_CLASS_NAME_"; break;
4176  case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
4177  case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
4178  case ObjCLabelType::PropertyName: Label = "OBJC_PROP_NAME_ATTR_"; break;
4179  }
4180 
4181  bool NonFragile = ForceNonFragileABI || isNonFragileABI();
4182 
4183  StringRef Section;
4184  switch (Type) {
4185  case ObjCLabelType::ClassName:
4186  Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
4187  : "__TEXT,__cstring,cstring_literals";
4188  break;
4189  case ObjCLabelType::MethodVarName:
4190  Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4191  : "__TEXT,__cstring,cstring_literals";
4192  break;
4193  case ObjCLabelType::MethodVarType:
4194  Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
4195  : "__TEXT,__cstring,cstring_literals";
4196  break;
4197  case ObjCLabelType::PropertyName:
4198  Section = "__TEXT,__cstring,cstring_literals";
4199  break;
4200  }
4201 
4202  llvm::Constant *Value =
4203  llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
4204  llvm::GlobalVariable *GV =
4205  new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
4206  /*isConstant=*/true,
4207  llvm::GlobalValue::PrivateLinkage, Value, Label);
4208  if (CGM.getTriple().isOSBinFormatMachO())
4209  GV->setSection(Section);
4210  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4211  GV->setAlignment(CharUnits::One().getAsAlign());
4212  CGM.addCompilerUsedGlobal(GV);
4213 
4214  return GV;
4215 }
4216 
4217 llvm::Function *CGObjCMac::ModuleInitFunction() {
4218  // Abuse this interface function as a place to finalize.
4219  FinishModule();
4220  return nullptr;
4221 }
4222 
4223 llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() {
4224  return ObjCTypes.getGetPropertyFn();
4225 }
4226 
4227 llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() {
4228  return ObjCTypes.getSetPropertyFn();
4229 }
4230 
4231 llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
4232  bool copy) {
4233  return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
4234 }
4235 
4236 llvm::FunctionCallee CGObjCMac::GetGetStructFunction() {
4237  return ObjCTypes.getCopyStructFn();
4238 }
4239 
4240 llvm::FunctionCallee CGObjCMac::GetSetStructFunction() {
4241  return ObjCTypes.getCopyStructFn();
4242 }
4243 
4244 llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() {
4245  return ObjCTypes.getCppAtomicObjectFunction();
4246 }
4247 
4248 llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() {
4249  return ObjCTypes.getCppAtomicObjectFunction();
4250 }
4251 
4252 llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() {
4253  return ObjCTypes.getEnumerationMutationFn();
4254 }
4255 
4256 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
4257  return EmitTryOrSynchronizedStmt(CGF, S);
4258 }
4259 
4260 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
4261  const ObjCAtSynchronizedStmt &S) {
4262  return EmitTryOrSynchronizedStmt(CGF, S);
4263 }
4264 
4265 namespace {
4266  struct PerformFragileFinally final : EHScopeStack::Cleanup {
4267  const Stmt &S;
4268  Address SyncArgSlot;
4269  Address CallTryExitVar;
4270  Address ExceptionData;
4271  ObjCTypesHelper &ObjCTypes;
4272  PerformFragileFinally(const Stmt *S,
4273  Address SyncArgSlot,
4274  Address CallTryExitVar,
4275  Address ExceptionData,
4276  ObjCTypesHelper *ObjCTypes)
4277  : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4278  ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4279 
4280  void Emit(CodeGenFunction &CGF, Flags flags) override {
4281  // Check whether we need to call objc_exception_try_exit.
4282  // In optimized code, this branch will always be folded.
4283  llvm::BasicBlock *FinallyCallExit =
4284  CGF.createBasicBlock("finally.call_exit");
4285  llvm::BasicBlock *FinallyNoCallExit =
4286  CGF.createBasicBlock("finally.no_call_exit");
4287  CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4288  FinallyCallExit, FinallyNoCallExit);
4289 
4290  CGF.EmitBlock(FinallyCallExit);
4291  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4292  ExceptionData.getPointer());
4293 
4294  CGF.EmitBlock(FinallyNoCallExit);
4295 
4296  if (isa<ObjCAtTryStmt>(S)) {
4297  if (const ObjCAtFinallyStmt* FinallyStmt =
4298  cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4299  // Don't try to do the @finally if this is an EH cleanup.
4300  if (flags.isForEHCleanup()) return;
4301 
4302  // Save the current cleanup destination in case there's
4303  // control flow inside the finally statement.
4304  llvm::Value *CurCleanupDest =
4306 
4307  CGF.EmitStmt(FinallyStmt->getFinallyBody());
4308 
4309  if (CGF.HaveInsertPoint()) {
4310  CGF.Builder.CreateStore(CurCleanupDest,
4311  CGF.getNormalCleanupDestSlot());
4312  } else {
4313  // Currently, the end of the cleanup must always exist.
4314  CGF.EnsureInsertPoint();
4315  }
4316  }
4317  } else {
4318  // Emit objc_sync_exit(expr); as finally's sole statement for
4319  // @synchronized.
4320  llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4321  CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4322  }
4323  }
4324  };
4325 
4326  class FragileHazards {
4327  CodeGenFunction &CGF;
4329  llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4330 
4331  llvm::InlineAsm *ReadHazard;
4332  llvm::InlineAsm *WriteHazard;
4333 
4334  llvm::FunctionType *GetAsmFnType();
4335 
4336  void collectLocals();
4337  void emitReadHazard(CGBuilderTy &Builder);
4338 
4339  public:
4340  FragileHazards(CodeGenFunction &CGF);
4341 
4342  void emitWriteHazard();
4343  void emitHazardsInNewBlocks();
4344  };
4345 } // end anonymous namespace
4346 
4347 /// Create the fragile-ABI read and write hazards based on the current
4348 /// state of the function, which is presumed to be immediately prior
4349 /// to a @try block. These hazards are used to maintain correct
4350 /// semantics in the face of optimization and the fragile ABI's
4351 /// cavalier use of setjmp/longjmp.
4352 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4353  collectLocals();
4354 
4355  if (Locals.empty()) return;
4356 
4357  // Collect all the blocks in the function.
4358  for (llvm::Function::iterator
4359  I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
4360  BlocksBeforeTry.insert(&*I);
4361 
4362  llvm::FunctionType *AsmFnTy = GetAsmFnType();
4363 
4364  // Create a read hazard for the allocas. This inhibits dead-store
4365  // optimizations and forces the values to memory. This hazard is
4366  // inserted before any 'throwing' calls in the protected scope to
4367  // reflect the possibility that the variables might be read from the
4368  // catch block if the call throws.
4369  {
4370  std::string Constraint;
4371  for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4372  if (I) Constraint += ',';
4373  Constraint += "*m";
4374  }
4375 
4376  ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4377  }
4378 
4379  // Create a write hazard for the allocas. This inhibits folding
4380  // loads across the hazard. This hazard is inserted at the
4381  // beginning of the catch path to reflect the possibility that the
4382  // variables might have been written within the protected scope.
4383  {
4384  std::string Constraint;
4385  for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4386  if (I) Constraint += ',';
4387  Constraint += "=*m";
4388  }
4389 
4390  WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4391  }
4392 }
4393 
4394 /// Emit a write hazard at the current location.
4395 void FragileHazards::emitWriteHazard() {
4396  if (Locals.empty()) return;
4397 
4398  CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4399 }
4400 
4401 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4402  assert(!Locals.empty());
4403  llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4404  call->setDoesNotThrow();
4405  call->setCallingConv(CGF.getRuntimeCC());
4406 }
4407 
4408 /// Emit read hazards in all the protected blocks, i.e. all the blocks
4409 /// which have been inserted since the beginning of the try.
4410 void FragileHazards::emitHazardsInNewBlocks() {
4411  if (Locals.empty()) return;
4412 
4413  CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4414 
4415  // Iterate through all blocks, skipping those prior to the try.
4416  for (llvm::Function::iterator
4417  FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
4418  llvm::BasicBlock &BB = *FI;
4419  if (BlocksBeforeTry.count(&BB)) continue;
4420 
4421  // Walk through all the calls in the block.
4422  for (llvm::BasicBlock::iterator
4423  BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
4424  llvm::Instruction &I = *BI;
4425 
4426  // Ignore instructions that aren't non-intrinsic calls.
4427  // These are the only calls that can possibly call longjmp.
4428  if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I))
4429  continue;
4430  if (isa<llvm::IntrinsicInst>(I))
4431  continue;
4432 
4433  // Ignore call sites marked nounwind. This may be questionable,
4434  // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4435  if (cast<llvm::CallBase>(I).doesNotThrow())
4436  continue;
4437 
4438  // Insert a read hazard before the call. This will ensure that
4439  // any writes to the locals are performed before making the
4440  // call. If the call throws, then this is sufficient to
4441  // guarantee correctness as long as it doesn't also write to any
4442  // locals.
4443  Builder.SetInsertPoint(&BB, BI);
4444  emitReadHazard(Builder);
4445  }
4446  }
4447 }
4448 
4450  if (V.isValid()) S.insert(V.getPointer());
4451 }
4452 
4453 void FragileHazards::collectLocals() {
4454  // Compute a set of allocas to ignore.
4455  llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4456  addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4457  addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4458 
4459  // Collect all the allocas currently in the function. This is
4460  // probably way too aggressive.
4461  llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4462  for (llvm::BasicBlock::iterator
4463  I = Entry.begin(), E = Entry.end(); I != E; ++I)
4464  if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
4465  Locals.push_back(&*I);
4466 }
4467 
4468 llvm::FunctionType *FragileHazards::GetAsmFnType() {
4469  SmallVector<llvm::Type *, 16> tys(Locals.size());
4470  for (unsigned i = 0, e = Locals.size(); i != e; ++i)
4471  tys[i] = Locals[i]->getType();
4472  return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4473 }
4474 
4475 /*
4476 
4477  Objective-C setjmp-longjmp (sjlj) Exception Handling
4478  --
4479 
4480  A catch buffer is a setjmp buffer plus:
4481  - a pointer to the exception that was caught
4482  - a pointer to the previous exception data buffer
4483  - two pointers of reserved storage
4484  Therefore catch buffers form a stack, with a pointer to the top
4485  of the stack kept in thread-local storage.
4486 
4487  objc_exception_try_enter pushes a catch buffer onto the EH stack.
4488  objc_exception_try_exit pops the given catch buffer, which is
4489  required to be the top of the EH stack.
4490  objc_exception_throw pops the top of the EH stack, writes the
4491  thrown exception into the appropriate field, and longjmps
4492  to the setjmp buffer. It crashes the process (with a printf
4493  and an abort()) if there are no catch buffers on the stack.
4494  objc_exception_extract just reads the exception pointer out of the
4495  catch buffer.
4496 
4497  There's no reason an implementation couldn't use a light-weight
4498  setjmp here --- something like __builtin_setjmp, but API-compatible
4499  with the heavyweight setjmp. This will be more important if we ever
4500  want to implement correct ObjC/C++ exception interactions for the
4501  fragile ABI.
4502 
4503  Note that for this use of setjmp/longjmp to be correct, we may need
4504  to mark some local variables volatile: if a non-volatile local
4505  variable is modified between the setjmp and the longjmp, it has
4506  indeterminate value. For the purposes of LLVM IR, it may be
4507  sufficient to make loads and stores within the @try (to variables
4508  declared outside the @try) volatile. This is necessary for
4509  optimized correctness, but is not currently being done; this is
4510  being tracked as rdar://problem/8160285
4511 
4512  The basic framework for a @try-catch-finally is as follows:
4513  {
4514  objc_exception_data d;
4515  id _rethrow = null;
4516  bool _call_try_exit = true;
4517 
4518  objc_exception_try_enter(&d);
4519  if (!setjmp(d.jmp_buf)) {
4520  ... try body ...
4521  } else {
4522  // exception path
4523  id _caught = objc_exception_extract(&d);
4524 
4525  // enter new try scope for handlers
4526  if (!setjmp(d.jmp_buf)) {
4527  ... match exception and execute catch blocks ...
4528 
4529  // fell off end, rethrow.
4530  _rethrow = _caught;
4531  ... jump-through-finally to finally_rethrow ...
4532  } else {
4533  // exception in catch block
4534  _rethrow = objc_exception_extract(&d);
4535  _call_try_exit = false;
4536  ... jump-through-finally to finally_rethrow ...
4537  }
4538  }
4539  ... jump-through-finally to finally_end ...
4540 
4541  finally:
4542  if (_call_try_exit)
4543  objc_exception_try_exit(&d);
4544 
4545  ... finally block ....
4546  ... dispatch to finally destination ...
4547 
4548  finally_rethrow:
4549  objc_exception_throw(_rethrow);
4550 
4551  finally_end:
4552  }
4553 
4554  This framework differs slightly from the one gcc uses, in that gcc
4555  uses _rethrow to determine if objc_exception_try_exit should be called
4556  and if the object should be rethrown. This breaks in the face of
4557  throwing nil and introduces unnecessary branches.
4558 
4559  We specialize this framework for a few particular circumstances:
4560 
4561  - If there are no catch blocks, then we avoid emitting the second
4562  exception handling context.
4563 
4564  - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4565  e)) we avoid emitting the code to rethrow an uncaught exception.
4566 
4567  - FIXME: If there is no @finally block we can do a few more
4568  simplifications.
4569 
4570  Rethrows and Jumps-Through-Finally
4571  --
4572 
4573  '@throw;' is supported by pushing the currently-caught exception
4574  onto ObjCEHStack while the @catch blocks are emitted.
4575 
4576  Branches through the @finally block are handled with an ordinary
4577  normal cleanup. We do not register an EH cleanup; fragile-ABI ObjC
4578  exceptions are not compatible with C++ exceptions, and this is
4579  hardly the only place where this will go wrong.
4580 
4581  @synchronized(expr) { stmt; } is emitted as if it were:
4582  id synch_value = expr;
4583  objc_sync_enter(synch_value);
4584  @try { stmt; } @finally { objc_sync_exit(synch_value); }
4585 */
4586 
4587 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4588  const Stmt &S) {
4589  bool isTry = isa<ObjCAtTryStmt>(S);
4590 
4591  // A destination for the fall-through edges of the catch handlers to
4592  // jump to.
4593  CodeGenFunction::JumpDest FinallyEnd =
4594  CGF.getJumpDestInCurrentScope("finally.end");
4595 
4596  // A destination for the rethrow edge of the catch handlers to jump
4597  // to.
4598  CodeGenFunction::JumpDest FinallyRethrow =
4599  CGF.getJumpDestInCurrentScope("finally.rethrow");
4600 
4601  // For @synchronized, call objc_sync_enter(sync.expr). The
4602  // evaluation of the expression must occur before we enter the
4603  // @synchronized. We can't avoid a temp here because we need the
4604  // value to be preserved. If the backend ever does liveness
4605  // correctly after setjmp, this will be unnecessary.
4606  Address SyncArgSlot = Address::invalid();
4607  if (!isTry) {
4608  llvm::Value *SyncArg =
4609  CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4610  SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4611  CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4612 
4613  SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4614  CGF.getPointerAlign(), "sync.arg");
4615  CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4616  }
4617 
4618  // Allocate memory for the setjmp buffer. This needs to be kept
4619  // live throughout the try and catch blocks.
4620  Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4621  CGF.getPointerAlign(),
4622  "exceptiondata.ptr");
4623 
4624  // Create the fragile hazards. Note that this will not capture any
4625  // of the allocas required for exception processing, but will
4626  // capture the current basic block (which extends all the way to the
4627  // setjmp call) as "before the @try".
4628  FragileHazards Hazards(CGF);
4629 
4630  // Create a flag indicating whether the cleanup needs to call
4631  // objc_exception_try_exit. This is true except when
4632  // - no catches match and we're branching through the cleanup
4633  // just to rethrow the exception, or
4634  // - a catch matched and we're falling out of the catch handler.
4635  // The setjmp-safety rule here is that we should always store to this
4636  // variable in a place that dominates the branch through the cleanup
4637  // without passing through any setjmps.
4638  Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4639  CharUnits::One(),
4640  "_call_try_exit");
4641 
4642  // A slot containing the exception to rethrow. Only needed when we
4643  // have both a @catch and a @finally.
4644  Address PropagatingExnVar = Address::invalid();
4645 
4646  // Push a normal cleanup to leave the try scope.
4647  CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4648  SyncArgSlot,
4649  CallTryExitVar,
4650  ExceptionData,
4651  &ObjCTypes);
4652 
4653  // Enter a try block:
4654  // - Call objc_exception_try_enter to push ExceptionData on top of
4655  // the EH stack.
4656  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4657  ExceptionData.getPointer());
4658 
4659  // - Call setjmp on the exception data buffer.
4660  llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4661  llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4662  llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4663  ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4664  "setjmp_buffer");
4665  llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4666  ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4667  SetJmpResult->setCanReturnTwice();
4668 
4669  // If setjmp returned 0, enter the protected block; otherwise,
4670  // branch to the handler.
4671  llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4672  llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4673  llvm::Value *DidCatch =
4674  CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4675  CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4676 
4677  // Emit the protected block.
4678  CGF.EmitBlock(TryBlock);
4679  CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4680  CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4681  : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4682 
4683  CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4684 
4685  // Emit the exception handler block.
4686  CGF.EmitBlock(TryHandler);
4687 
4688  // Don't optimize loads of the in-scope locals across this point.
4689  Hazards.emitWriteHazard();
4690 
4691  // For a @synchronized (or a @try with no catches), just branch
4692  // through the cleanup to the rethrow block.
4693  if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4694  // Tell the cleanup not to re-pop the exit.
4695  CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4696  CGF.EmitBranchThroughCleanup(FinallyRethrow);
4697 
4698  // Otherwise, we have to match against the caught exceptions.
4699  } else {
4700  // Retrieve the exception object. We may emit multiple blocks but
4701  // nothing can cross this so the value is already in SSA form.
4702  llvm::CallInst *Caught =
4703  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4704  ExceptionData.getPointer(), "caught");
4705 
4706  // Push the exception to rethrow onto the EH value stack for the
4707  // benefit of any @throws in the handlers.
4708  CGF.ObjCEHValueStack.push_back(Caught);
4709 
4710  const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4711 
4712  bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4713 
4714  llvm::BasicBlock *CatchBlock = nullptr;
4715  llvm::BasicBlock *CatchHandler = nullptr;
4716  if (HasFinally) {
4717  // Save the currently-propagating exception before
4718  // objc_exception_try_enter clears the exception slot.
4719  PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4720  CGF.getPointerAlign(),
4721  "propagating_exception");
4722  CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4723 
4724  // Enter a new exception try block (in case a @catch block
4725  // throws an exception).
4726  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4727  ExceptionData.getPointer());
4728 
4729  llvm::CallInst *SetJmpResult =
4730  CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4731  SetJmpBuffer, "setjmp.result");
4732  SetJmpResult->setCanReturnTwice();
4733 
4734  llvm::Value *Threw =
4735  CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4736 
4737  CatchBlock = CGF.createBasicBlock("catch");
4738  CatchHandler = CGF.createBasicBlock("catch_for_catch");
4739  CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4740 
4741  CGF.EmitBlock(CatchBlock);
4742  }
4743 
4744  CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4745 
4746  // Handle catch list. As a special case we check if everything is
4747  // matched and avoid generating code for falling off the end if
4748  // so.
4749  bool AllMatched = false;
4750  for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
4751  const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4752 
4753  const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4754  const ObjCObjectPointerType *OPT = nullptr;
4755 
4756  // catch(...) always matches.
4757  if (!CatchParam) {
4758  AllMatched = true;
4759  } else {
4760  OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4761 
4762  // catch(id e) always matches under this ABI, since only
4763  // ObjC exceptions end up here in the first place.
4764  // FIXME: For the time being we also match id<X>; this should
4765  // be rejected by Sema instead.
4766  if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4767  AllMatched = true;
4768  }
4769 
4770  // If this is a catch-all, we don't need to test anything.
4771  if (AllMatched) {
4772  CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4773 
4774  if (CatchParam) {
4775  CGF.EmitAutoVarDecl(*CatchParam);
4776  assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4777 
4778  // These types work out because ConvertType(id) == i8*.
4779  EmitInitOfCatchParam(CGF, Caught, CatchParam);
4780  }
4781 
4782  CGF.EmitStmt(CatchStmt->getCatchBody());
4783 
4784  // The scope of the catch variable ends right here.
4785  CatchVarCleanups.ForceCleanup();
4786 
4787  CGF.EmitBranchThroughCleanup(FinallyEnd);
4788  break;
4789  }
4790 
4791  assert(OPT && "Unexpected non-object pointer type in @catch");
4792  const ObjCObjectType *ObjTy = OPT->getObjectType();
4793 
4794  // FIXME: @catch (Class c) ?
4795  ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4796  assert(IDecl && "Catch parameter must have Objective-C type!");
4797 
4798  // Check if the @catch block matches the exception object.
4799  llvm::Value *Class = EmitClassRef(CGF, IDecl);
4800 
4801  llvm::Value *matchArgs[] = { Class, Caught };
4802  llvm::CallInst *Match =
4803  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4804  matchArgs, "match");
4805 
4806  llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4807  llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4808 
4809  CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4810  MatchedBlock, NextCatchBlock);
4811 
4812  // Emit the @catch block.
4813  CGF.EmitBlock(MatchedBlock);
4814 
4815  // Collect any cleanups for the catch variable. The scope lasts until
4816  // the end of the catch body.
4817  CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4818 
4819  CGF.EmitAutoVarDecl(*CatchParam);
4820  assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4821 
4822  // Initialize the catch variable.
4823  llvm::Value *Tmp =
4824  CGF.Builder.CreateBitCast(Caught,
4825  CGF.ConvertType(CatchParam->getType()));
4826  EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4827 
4828  CGF.EmitStmt(CatchStmt->getCatchBody());
4829 
4830  // We're done with the catch variable.
4831  CatchVarCleanups.ForceCleanup();
4832 
4833  CGF.EmitBranchThroughCleanup(FinallyEnd);
4834 
4835  CGF.EmitBlock(NextCatchBlock);
4836  }
4837 
4838  CGF.ObjCEHValueStack.pop_back();
4839 
4840  // If nothing wanted anything to do with the caught exception,
4841  // kill the extract call.
4842  if (Caught->use_empty())
4843  Caught->eraseFromParent();
4844 
4845  if (!AllMatched)
4846  CGF.EmitBranchThroughCleanup(FinallyRethrow);
4847 
4848  if (HasFinally) {
4849  // Emit the exception handler for the @catch blocks.
4850  CGF.EmitBlock(CatchHandler);
4851 
4852  // In theory we might now need a write hazard, but actually it's
4853  // unnecessary because there's no local-accessing code between
4854  // the try's write hazard and here.
4855  //Hazards.emitWriteHazard();
4856 
4857  // Extract the new exception and save it to the
4858  // propagating-exception slot.
4859  assert(PropagatingExnVar.isValid());
4860  llvm::CallInst *NewCaught =
4861  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4862  ExceptionData.getPointer(), "caught");
4863  CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4864 
4865  // Don't pop the catch handler; the throw already did.
4866  CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4867  CGF.EmitBranchThroughCleanup(FinallyRethrow);
4868  }
4869  }
4870 
4871  // Insert read hazards as required in the new blocks.
4872  Hazards.emitHazardsInNewBlocks();
4873 
4874  // Pop the cleanup.
4875  CGF.Builder.restoreIP(TryFallthroughIP);
4876  if (CGF.HaveInsertPoint())
4877  CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4878  CGF.PopCleanupBlock();
4879  CGF.EmitBlock(FinallyEnd.getBlock(), true);
4880 
4881  // Emit the rethrow block.
4882  CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4883  CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4884  if (CGF.HaveInsertPoint()) {
4885  // If we have a propagating-exception variable, check it.
4886  llvm::Value *PropagatingExn;
4887  if (PropagatingExnVar.isValid()) {
4888  PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4889 
4890  // Otherwise, just look in the buffer for the exception to throw.
4891  } else {
4892  llvm::CallInst *Caught =
4893  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4894  ExceptionData.getPointer());
4895  PropagatingExn = Caught;
4896  }
4897 
4898  CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4899  PropagatingExn);
4900  CGF.Builder.CreateUnreachable();
4901  }
4902 
4903  CGF.Builder.restoreIP(SavedIP);
4904 }
4905 
4906 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4907  const ObjCAtThrowStmt &S,
4908  bool ClearInsertionPoint) {
4909  llvm::Value *ExceptionAsObject;
4910 
4911  if (const Expr *ThrowExpr = S.getThrowExpr()) {
4912  llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4913  ExceptionAsObject =
4914  CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4915  } else {
4916  assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4917  "Unexpected rethrow outside @catch block.");
4918  ExceptionAsObject = CGF.ObjCEHValueStack.back();
4919  }
4920 
4921  CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4922  ->setDoesNotReturn();
4923  CGF.Builder.CreateUnreachable();
4924 
4925  // Clear the insertion point to indicate we are in unreachable code.
4926  if (ClearInsertionPoint)
4927  CGF.Builder.ClearInsertionPoint();
4928 }
4929 
4930 /// EmitObjCWeakRead - Code gen for loading value of a __weak
4931 /// object: objc_read_weak (id *src)
4932 ///
4933 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4934  Address AddrWeakObj) {
4935  llvm::Type* DestTy = AddrWeakObj.getElementType();
4936  AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4937  ObjCTypes.PtrObjectPtrTy);
4938  llvm::Value *read_weak =
4939  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4940  AddrWeakObj.getPointer(), "weakread");
4941  read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4942  return read_weak;
4943 }
4944 
4945 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4946 /// objc_assign_weak (id src, id *dst)
4947 ///
4948 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4949  llvm::Value *src, Address dst) {
4950  llvm::Type * SrcTy = src->getType();
4951  if (!isa<llvm::PointerType>(SrcTy)) {
4952  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4953  assert(Size <= 8 && "does not support size > 8");
4954  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4955  : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4956  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4957  }
4958  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4959  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4960  llvm::Value *args[] = { src, dst.getPointer() };
4961  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4962  args, "weakassign");
4963 }
4964 
4965 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4966 /// objc_assign_global (id src, id *dst)
4967 ///
4968 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4969  llvm::Value *src, Address dst,
4970  bool threadlocal) {
4971  llvm::Type * SrcTy = src->getType();
4972  if (!isa<llvm::PointerType>(SrcTy)) {
4973  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4974  assert(Size <= 8 && "does not support size > 8");
4975  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4976  : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4977  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4978  }
4979  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4980  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4981  llvm::Value *args[] = { src, dst.getPointer() };
4982  if (!threadlocal)
4983  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4984  args, "globalassign");
4985  else
4986  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4987  args, "threadlocalassign");
4988 }
4989 
4990 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4991 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4992 ///
4993 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4994  llvm::Value *src, Address dst,
4995  llvm::Value *ivarOffset) {
4996  assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
4997  llvm::Type * SrcTy = src->getType();
4998  if (!isa<llvm::PointerType>(SrcTy)) {
4999  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5000  assert(Size <= 8 && "does not support size > 8");
5001  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5002  : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5003  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5004  }
5005  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5006  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5007  llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
5008  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
5009 }
5010 
5011 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
5012 /// objc_assign_strongCast (id src, id *dst)
5013 ///
5014 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
5015  llvm::Value *src, Address dst) {
5016  llvm::Type * SrcTy = src->getType();
5017  if (!isa<llvm::PointerType>(SrcTy)) {
5018  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
5019  assert(Size <= 8 && "does not support size > 8");
5020  src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
5021  : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
5022  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
5023  }
5024  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
5025  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
5026  llvm::Value *args[] = { src, dst.getPointer() };
5027  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
5028  args, "strongassign");
5029 }
5030 
5031 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
5032  Address DestPtr,
5033  Address SrcPtr,
5034  llvm::Value *size) {
5035  SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
5036  DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
5037  llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
5038  CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
5039 }
5040 
5041 /// EmitObjCValueForIvar - Code Gen for ivar reference.
5042 ///
5043 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
5044  QualType ObjectTy,
5045  llvm::Value *BaseValue,
5046  const ObjCIvarDecl *Ivar,
5047  unsigned CVRQualifiers) {
5048  const ObjCInterfaceDecl *ID =
5049  ObjectTy->castAs<ObjCObjectType>()->getInterface();
5050  return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
5051  EmitIvarOffset(CGF, ID, Ivar));
5052 }
5053 
5054 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
5055  const ObjCInterfaceDecl *Interface,
5056  const ObjCIvarDecl *Ivar) {
5057  uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
5058  return llvm::ConstantInt::get(
5059  CGM.getTypes().ConvertType(CGM.getContext().LongTy),
5060  Offset);
5061 }
5062 
5063 /* *** Private Interface *** */
5064 
5065 std::string CGObjCCommonMac::GetSectionName(StringRef Section,
5066  StringRef MachOAttributes) {
5067  switch (CGM.getTriple().getObjectFormat()) {
5068  case llvm::Triple::UnknownObjectFormat:
5069  llvm_unreachable("unexpected object file format");
5070  case llvm::Triple::MachO: {
5071  if (MachOAttributes.empty())
5072  return ("__DATA," + Section).str();
5073  return ("__DATA," + Section + "," + MachOAttributes).str();
5074  }
5075  case llvm::Triple::ELF:
5076  assert(Section.substr(0, 2) == "__" &&
5077  "expected the name to begin with __");
5078  return Section.substr(2).str();
5079  case llvm::Triple::COFF:
5080  assert(Section.substr(0, 2) == "__" &&
5081  "expected the name to begin with __");
5082  return ("." + Section.substr(2) + "$B").str();
5083  case llvm::Triple::Wasm:
5084  case llvm::Triple::XCOFF:
5085  llvm::report_fatal_error(
5086  "Objective-C support is unimplemented for object file format.");
5087  }
5088 
5089  llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum");
5090 }
5091 
5092 /// EmitImageInfo - Emit the image info marker used to encode some module
5093 /// level information.
5094 ///
5095 /// See: <rdr://4810609&4810587&4810587>
5096 /// struct IMAGE_INFO {
5097 /// unsigned version;
5098 /// unsigned flags;
5099 /// };
5100 enum ImageInfoFlags {
5101  eImageInfo_FixAndContinue = (1 << 0), // This flag is no longer set by clang.
5102  eImageInfo_GarbageCollected = (1 << 1),
5103  eImageInfo_GCOnly = (1 << 2),
5104  eImageInfo_OptimizedByDyld = (1 << 3), // This flag is set by the dyld shared cache.
5105 
5106  // A flag indicating that the module has no instances of a @synthesize of a
5107  // superclass variable. <rdar://problem/6803242>
5108  eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
5109  eImageInfo_ImageIsSimulated = (1 << 5),
5110  eImageInfo_ClassProperties = (1 << 6)
5111 };
5112 
5113 void CGObjCCommonMac::EmitImageInfo() {
5114  unsigned version = 0; // Version is unused?
5115  std::string Section =
5116  (ObjCABI == 1)
5117  ? "__OBJC,__image_info,regular"
5118  : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");
5119 
5120  // Generate module-level named metadata to convey this information to the
5121  // linker and code-gen.
5122  llvm::Module &Mod = CGM.getModule();
5123 
5124  // Add the ObjC ABI version to the module flags.
5125  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
5126  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
5127  version);
5128  Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
5129  llvm::MDString::get(VMContext, Section));
5130 
5131  if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5132  // Non-GC overrides those files which specify GC.
5133  Mod.addModuleFlag(llvm::Module::Override,
5134  "Objective-C Garbage Collection", (uint32_t)0);
5135  } else {
5136  // Add the ObjC garbage collection value.
5137  Mod.addModuleFlag(llvm::Module::Error,
5138  "Objective-C Garbage Collection",
5139  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  llvm::Type::getInt32Ty(VMContext), 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, CGF.getPointerAlign());
5247 }
5248 
5249 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
5250  const ObjCInterfaceDecl *ID) {
5251  // If the class has the objc_runtime_visible attribute, we need to
5252  // use the Objective-C runtime to get the class.
5253  if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
5254  return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
5255 
5256  IdentifierInfo *RuntimeName =
5257  &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
5258  return EmitClassRefFromId(CGF, RuntimeName);
5259 }
5260 
5261 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
5262  IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
5263  return EmitClassRefFromId(CGF, II);
5264 }
5265 
5266 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
5267  return CGF.Builder.CreateLoad(EmitSelectorAddr(Sel));
5268 }
5269 
5270 Address CGObjCMac::EmitSelectorAddr(Selector Sel) {
5271  CharUnits Align = CGM.getPointerAlign();
5272 
5273  llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
5274  if (!Entry) {
5275  llvm::Constant *Casted =
5276  llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5277  ObjCTypes.SelectorPtrTy);
5278  Entry = CreateMetadataVar(
5279  "OBJC_SELECTOR_REFERENCES_", Casted,
5280  "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
5281  Entry->setExternallyInitialized(true);
5282  }
5283 
5284  return Address(Entry, Align);
5285 }
5286 
5287 llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
5288  llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
5289  if (!Entry)
5290  Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
5291  return getConstantGEP(VMContext, Entry, 0, 0);
5292 }
5293 
5294 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
5295  llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
5296  I = MethodDefinitions.find(MD);
5297  if (I != MethodDefinitions.end())
5298  return I->second;
5299 
5300  return nullptr;
5301 }
5302 
5303 /// GetIvarLayoutName - Returns a unique constant for the given
5304 /// ivar layout bitmap.
5305 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
5306  const ObjCCommonTypesHelper &ObjCTypes) {
5307  return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5308 }
5309 
5310 void IvarLayoutBuilder::visitRecord(const RecordType *RT,
5311  CharUnits offset) {
5312  const RecordDecl *RD = RT->getDecl();
5313 
5314  // If this is a union, remember that we had one, because it might mess
5315  // up the ordering of layout entries.
5316  if (RD->isUnion())
5317  IsDisordered = true;
5318 
5319  const ASTRecordLayout *recLayout = nullptr;
5320  visitAggregate(RD->field_begin(), RD->field_end(), offset,
5321  [&](const FieldDecl *field) -> CharUnits {
5322  if (!recLayout)
5323  recLayout = &CGM.getContext().getASTRecordLayout(RD);
5324  auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
5325  return CGM.getContext().toCharUnitsFromBits(offsetInBits);
5326  });
5327 }
5328 
5329 template <class Iterator, class GetOffsetFn>
5330 void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
5331  CharUnits aggregateOffset,
5332  const GetOffsetFn &getOffset) {
5333  for (; begin != end; ++begin) {
5334  auto field = *begin;
5335 
5336  // Skip over bitfields.
5337  if (field->isBitField()) {
5338  continue;
5339  }
5340 
5341  // Compute the offset of the field within the aggregate.
5342  CharUnits fieldOffset = aggregateOffset + getOffset(field);
5343 
5344  visitField(field, fieldOffset);
5345  }
5346 }
5347 
5348 /// Collect layout information for the given fields into IvarsInfo.
5349 void IvarLayoutBuilder::visitField(const FieldDecl *field,
5350  CharUnits fieldOffset) {
5351  QualType fieldType = field->getType();
5352 
5353  // Drill down into arrays.
5354  uint64_t numElts = 1;
5355  if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) {
5356  numElts = 0;
5357  fieldType = arrayType->getElementType();
5358  }
5359  // Unlike incomplete arrays, constant arrays can be nested.
5360  while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
5361  numElts *= arrayType->getSize().getZExtValue();
5362  fieldType = arrayType->getElementType();
5363  }
5364 
5365  assert(!fieldType->isArrayType() && "ivar of non-constant array type?");
5366 
5367  // If we ended up with a zero-sized array, we've done what we can do within
5368  // the limits of this layout encoding.
5369  if (numElts == 0) return;
5370 
5371  // Recurse if the base element type is a record type.
5372  if (auto recType = fieldType->getAs<RecordType>()) {
5373  size_t oldEnd = IvarsInfo.size();
5374 
5375  visitRecord(recType, fieldOffset);
5376 
5377  // If we have an array, replicate the first entry's layout information.
5378  auto numEltEntries = IvarsInfo.size() - oldEnd;
5379  if (numElts != 1 && numEltEntries != 0) {
5380  CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5381  for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
5382  // Copy the last numEltEntries onto the end of the array, adjusting
5383  // each for the element size.
5384  for (size_t i = 0; i != numEltEntries; ++i) {
5385  auto firstEntry = IvarsInfo[oldEnd + i];
5386  IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
5387  firstEntry.SizeInWords));
5388  }
5389  }
5390  }
5391 
5392  return;
5393  }
5394 
5395  // Classify the element type.
5396  Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
5397 
5398  // If it matches what we're looking for, add an entry.
5399  if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
5400  || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
5401  assert(CGM.getContext().getTypeSizeInChars(fieldType)
5402  == CGM.getPointerSize());
5403  IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
5404  }
5405 }
5406 
5407 /// buildBitmap - This routine does the horsework of taking the offsets of
5408 /// strong/weak references and creating a bitmap. The bitmap is also
5409 /// returned in the given buffer, suitable for being passed to \c dump().
5410 llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
5411  llvm::SmallVectorImpl<unsigned char> &buffer) {
5412  // The bitmap is a series of skip/scan instructions, aligned to word
5413  // boundaries. The skip is performed first.
5414  const unsigned char MaxNibble = 0xF;
5415  const unsigned char SkipMask = 0xF0, SkipShift = 4;
5416  const unsigned char ScanMask = 0x0F, ScanShift = 0;
5417 
5418  assert(!IvarsInfo.empty() && "generating bitmap for no data");
5419 
5420  // Sort the ivar info on byte position in case we encounterred a
5421  // union nested in the ivar list.
5422  if (IsDisordered) {
5423  // This isn't a stable sort, but our algorithm should handle it fine.
5424  llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
5425  } else {
5426  assert(std::is_sorted(IvarsInfo.begin(), IvarsInfo.end()));
5427  }
5428  assert(IvarsInfo.back().Offset < InstanceEnd);
5429 
5430  assert(buffer.empty());
5431 
5432  // Skip the next N words.
5433  auto skip = [&](unsigned numWords) {
5434  assert(numWords > 0);
5435 
5436  // Try to merge into the previous byte. Since scans happen second, we
5437  // can't do this if it includes a scan.
5438  if (!buffer.empty() && !(buffer.back() & ScanMask)) {
5439  unsigned lastSkip = buffer.back() >> SkipShift;
5440  if (lastSkip < MaxNibble) {
5441  unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
5442  numWords -= claimed;
5443  lastSkip += claimed;
5444  buffer.back() = (lastSkip << SkipShift);
5445  }
5446  }
5447 
5448  while (numWords >= MaxNibble) {
5449  buffer.push_back(MaxNibble << SkipShift);
5450  numWords -= MaxNibble;
5451  }
5452  if (numWords) {
5453  buffer.push_back(numWords << SkipShift);
5454  }
5455  };
5456 
5457  // Scan the next N words.
5458  auto scan = [&](unsigned numWords) {
5459  assert(numWords > 0);
5460 
5461  // Try to merge into the previous byte. Since scans happen second, we can
5462  // do this even if it includes a skip.
5463  if (!buffer.empty()) {
5464  unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
5465  if (lastScan < MaxNibble) {
5466  unsigned claimed = std::min(MaxNibble - lastScan, numWords);
5467  numWords -= claimed;
5468  lastScan += claimed;
5469  buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
5470  }
5471  }
5472 
5473  while (numWords >= MaxNibble) {
5474  buffer.push_back(MaxNibble << ScanShift);
5475  numWords -= MaxNibble;
5476  }
5477  if (numWords) {
5478  buffer.push_back(numWords << ScanShift);
5479  }
5480  };
5481 
5482  // One past the end of the last scan.
5483  unsigned endOfLastScanInWords = 0;
5484  const CharUnits WordSize = CGM.getPointerSize();
5485 
5486  // Consider all the scan requests.
5487  for (auto &request : IvarsInfo) {
5488  CharUnits beginOfScan = request.Offset - InstanceBegin;
5489 
5490  // Ignore scan requests that don't start at an even multiple of the
5491  // word size. We can't encode them.
5492  if ((beginOfScan % WordSize) != 0) continue;
5493 
5494  // Ignore scan requests that start before the instance start.
5495  // This assumes that scans never span that boundary. The boundary
5496  // isn't the true start of the ivars, because in the fragile-ARC case
5497  // it's rounded up to word alignment, but the test above should leave
5498  // us ignoring that possibility.
5499  if (beginOfScan.isNegative()) {
5500  assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin);
5501  continue;
5502  }
5503 
5504  unsigned beginOfScanInWords = beginOfScan / WordSize;
5505  unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
5506 
5507  // If the scan starts some number of words after the last one ended,
5508  // skip forward.
5509  if (beginOfScanInWords > endOfLastScanInWords) {
5510  skip(beginOfScanInWords - endOfLastScanInWords);
5511 
5512  // Otherwise, start scanning where the last left off.
5513  } else {
5514  beginOfScanInWords = endOfLastScanInWords;
5515 
5516  // If that leaves us with nothing to scan, ignore this request.
5517  if (beginOfScanInWords >= endOfScanInWords) continue;
5518  }
5519 
5520  // Scan to the end of the request.
5521  assert(beginOfScanInWords < endOfScanInWords);
5522  scan(endOfScanInWords - beginOfScanInWords);
5523  endOfLastScanInWords = endOfScanInWords;
5524  }
5525 
5526  if (buffer.empty())
5527  return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
5528 
5529  // For GC layouts, emit a skip to the end of the allocation so that we
5530  // have precise information about the entire thing. This isn't useful
5531  // or necessary for the ARC-style layout strings.
5532  if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5533  unsigned lastOffsetInWords =
5534  (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5535  if (lastOffsetInWords > endOfLastScanInWords) {
5536  skip(lastOffsetInWords - endOfLastScanInWords);
5537  }
5538  }
5539 
5540  // Null terminate the string.
5541  buffer.push_back(0);
5542 
5543  auto *Entry = CGObjC.CreateCStringLiteral(
5544  reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
5545  return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5546 }
5547 
5548 /// BuildIvarLayout - Builds ivar layout bitmap for the class
5549 /// implementation for the __strong or __weak case.
5550 /// The layout map displays which words in ivar list must be skipped
5551 /// and which must be scanned by GC (see below). String is built of bytes.
5552 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5553 /// of words to skip and right nibble is count of words to scan. So, each
5554 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5555 /// represented by a 0x00 byte which also ends the string.
5556 /// 1. when ForStrongLayout is true, following ivars are scanned:
5557 /// - id, Class
5558 /// - object *
5559 /// - __strong anything
5560 ///
5561 /// 2. When ForStrongLayout is false, following ivars are scanned:
5562 /// - __weak anything
5563 ///
5564 llvm::Constant *
5565 CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
5566  CharUnits beginOffset, CharUnits endOffset,
5567  bool ForStrongLayout, bool HasMRCWeakIvars) {
5568  // If this is MRC, and we're either building a strong layout or there
5569  // are no weak ivars, bail out early.
5570  llvm::Type *PtrTy = CGM.Int8PtrTy;
5571  if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5572  !CGM.getLangOpts().ObjCAutoRefCount &&
5573  (ForStrongLayout || !HasMRCWeakIvars))
5574  return llvm::Constant::getNullValue(PtrTy);
5575 
5576  const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5577  SmallVector<const ObjCIvarDecl*, 32> ivars;
5578 
5579  // GC layout strings include the complete object layout, possibly
5580  // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5581  // up.
5582  //
5583  // ARC layout strings only include the class's ivars. In non-fragile
5584  // runtimes, that means starting at InstanceStart, rounded up to word
5585  // alignment. In fragile runtimes, there's no InstanceStart, so it means
5586  // starting at the offset of the first ivar, rounded up to word alignment.
5587  //
5588  // MRC weak layout strings follow the ARC style.
5589  CharUnits baseOffset;
5590  if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5591  for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5592  IVD; IVD = IVD->getNextIvar())
5593  ivars.push_back(IVD);
5594 
5595  if (isNonFragileABI()) {
5596  baseOffset = beginOffset; // InstanceStart
5597  } else if (!ivars.empty()) {
5598  baseOffset =
5599  CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5600  } else {
5601  baseOffset = CharUnits::Zero();
5602  }
5603 
5604  baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5605  }
5606  else {
5607  CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5608 
5609  baseOffset = CharUnits::Zero();
5610  }
5611 
5612  if (ivars.empty())
5613  return llvm::Constant::getNullValue(PtrTy);
5614 
5615  IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5616 
5617  builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5618  [&](const ObjCIvarDecl *ivar) -> CharUnits {
5619  return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5620  });
5621 
5622  if (!builder.hasBitmapData())
5623  return llvm::Constant::getNullValue(PtrTy);
5624 
5625  llvm::SmallVector<unsigned char, 4> buffer;
5626  llvm::Constant *C = builder.buildBitmap(*this, buffer);
5627 
5628  if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5629  printf("\n%s ivar layout for class '%s': ",
5630  ForStrongLayout ? "strong" : "weak",
5631  OMD->getClassInterface()->getName().str().c_str());
5632  builder.dump(buffer);
5633  }
5634  return C;
5635 }
5636 
5637 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5638  llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5639  // FIXME: Avoid std::string in "Sel.getAsString()"
5640  if (!Entry)
5641  Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
5642  return getConstantGEP(VMContext, Entry, 0, 0);
5643 }
5644 
5645 // FIXME: Merge into a single cstring creation function.
5646 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5647  return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5648 }
5649 
5650 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5651  std::string TypeStr;
5652  CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5653 
5654  llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5655  if (!Entry)
5656  Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5657  return getConstantGEP(VMContext, Entry, 0, 0);
5658 }
5659 
5660 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5661  bool Extended) {
5662  std::string TypeStr =
5663  CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);
5664 
5665  llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5666  if (!Entry)
5667  Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5668  return getConstantGEP(VMContext, Entry, 0, 0);
5669 }
5670 
5671 // FIXME: Merge into a single cstring creation function.
5672 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5673  llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5674  if (!Entry)
5675  Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
5676  return getConstantGEP(VMContext, Entry, 0, 0);
5677 }
5678 
5679 // FIXME: Merge into a single cstring creation function.
5680 // FIXME: This Decl should be more precise.
5681 llvm::Constant *
5682 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5683  const Decl *Container) {
5684  std::string TypeStr =
5685  CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
5686  return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5687 }
5688 
5689 void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
5690  const ObjCContainerDecl *CD,
5691  SmallVectorImpl<char> &Name,
5692  bool ignoreCategoryNamespace) {
5693  llvm::raw_svector_ostream OS(Name);
5694  assert (CD && "Missing container decl in GetNameForMethod");
5695  OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
5696  << '[' << CD->getName();
5697  if (!ignoreCategoryNamespace)
5698  if (const ObjCCategoryImplDecl *CID =
5699  dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
5700  OS << '(' << *CID << ')';
5701  OS << ' ' << D->getSelector().getAsString() << ']';
5702 }
5703 
5704 void CGObjCMac::FinishModule() {
5705  EmitModuleInfo();
5706 
5707  // Emit the dummy bodies for any protocols which were referenced but
5708  // never defined.
5709  for (auto &entry : Protocols) {
5710  llvm::GlobalVariable *global = entry.second;
5711  if (global->hasInitializer())
5712  continue;
5713 
5714  ConstantInitBuilder builder(CGM);
5715  auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
5716  values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
5717  values.add(GetClassName(entry.first->getName()));
5718  values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
5719  values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5720  values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5721  values.finishAndSetAsInitializer(global);
5722  CGM.addCompilerUsedGlobal(global);
5723  }
5724 
5725  // Add assembler directives to add lazy undefined symbol references
5726  // for classes which are referenced but not defined. This is
5727  // important for correct linker interaction.
5728  //
5729  // FIXME: It would be nice if we had an LLVM construct for this.
5730  if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
5731  CGM.getTriple().isOSBinFormatMachO()) {
5732  SmallString<256> Asm;
5733  Asm += CGM.getModule().getModuleInlineAsm();
5734  if (!Asm.empty() && Asm.back() != '\n')
5735  Asm += '\n';
5736 
5737  llvm::raw_svector_ostream OS(Asm);
5738  for (const auto *Sym : DefinedSymbols)
5739  OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
5740  << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
5741  for (const auto *Sym : LazySymbols)
5742  OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
5743  for (const auto &Category : DefinedCategoryNames)
5744  OS << "\t.objc_category_name_" << Category << "=0\n"
5745  << "\t.globl .objc_category_name_" << Category << "\n";
5746 
5747  CGM.getModule().setModuleInlineAsm(OS.str());
5748  }
5749 }
5750 
5751 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5752  : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
5753  ObjCEmptyVtableVar(nullptr) {
5754  ObjCABI = 2;
5755 }
5756 
5757 /* *** */
5758 
5759 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5760  : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5761 {
5762  CodeGen::CodeGenTypes &Types = CGM.getTypes();
5763  ASTContext &Ctx = CGM.getContext();
5764 
5765  ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
5766  IntTy = CGM.IntTy;
5767  LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
5768  Int8PtrTy = CGM.Int8PtrTy;
5769  Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5770 
5771  // arm64 targets use "int" ivar offset variables. All others,
5772  // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5773  if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5774  IvarOffsetVarTy = IntTy;
5775  else
5776  IvarOffsetVarTy = LongTy;
5777 
5778  ObjectPtrTy =
5779  cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
5780  PtrObjectPtrTy =
5781  llvm::PointerType::getUnqual(ObjectPtrTy);
5782  SelectorPtrTy =
5783  cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
5784 
5785  // I'm not sure I like this. The implicit coordination is a bit
5786  // gross. We should solve this in a reasonable fashion because this
5787  // is a pretty common task (match some runtime data structure with
5788  // an LLVM data structure).
5789 
5790  // FIXME: This is leaked.
5791  // FIXME: Merge with rewriter code?
5792 
5793  // struct _objc_super {
5794  // id self;
5795  // Class cls;
5796  // }
5797  RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5798  Ctx.getTranslationUnitDecl(),
5799  SourceLocation(), SourceLocation(),
5800  &Ctx.Idents.get("_objc_super"));
5801  RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5802  nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5803  false, ICIS_NoInit));
5804  RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5805  nullptr, Ctx.getObjCClassType(), nullptr,
5806  nullptr, false, ICIS_NoInit));
5807  RD->completeDefinition();
5808 
5809  SuperCTy = Ctx.getTagDeclType(RD);
5810  SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5811 
5812  SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5813  SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5814 
5815  // struct _prop_t {
5816  // char *name;
5817  // char *attributes;
5818  // }
5819  PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy);
5820 
5821  // struct _prop_list_t {
5822  // uint32_t entsize; // sizeof(struct _prop_t)
5823  // uint32_t count_of_properties;
5824  // struct _prop_t prop_list[count_of_properties];
5825  // }
5826  PropertyListTy = llvm::StructType::create(
5827  "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0));
5828  // struct _prop_list_t *
5829  PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5830 
5831  // struct _objc_method {
5832  // SEL _cmd;
5833  // char *method_type;
5834  // char *_imp;
5835  // }
5836  MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy,
5837  Int8PtrTy, Int8PtrTy);
5838 
5839  // struct _objc_cache *
5840  CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5841  CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5842 }
5843 
5844 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5845  : ObjCCommonTypesHelper(cgm) {
5846  // struct _objc_method_description {
5847  // SEL name;
5848  // char *types;
5849  // }
5850  MethodDescriptionTy = llvm::StructType::create(
5851  "struct._objc_method_description", SelectorPtrTy, Int8PtrTy);
5852 
5853  // struct _objc_method_description_list {
5854  // int count;
5855  // struct _objc_method_description[1];
5856  // }
5857  MethodDescriptionListTy =
5858  llvm::StructType::create("struct._objc_method_description_list", IntTy,
5859  llvm::ArrayType::get(MethodDescriptionTy, 0));
5860 
5861  // struct _objc_method_description_list *
5862  MethodDescriptionListPtrTy =
5863  llvm::PointerType::getUnqual(MethodDescriptionListTy);
5864 
5865  // Protocol description structures
5866 
5867  // struct _objc_protocol_extension {
5868  // uint32_t size; // sizeof(struct _objc_protocol_extension)
5869  // struct _objc_method_description_list *optional_instance_methods;
5870  // struct _objc_method_description_list *optional_class_methods;
5871  // struct _objc_property_list *instance_properties;
5872  // const char ** extendedMethodTypes;
5873  // struct _objc_property_list *class_properties;
5874  // }
5875  ProtocolExtensionTy = llvm::StructType::create(
5876  "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy,
5877  MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy,
5878  PropertyListPtrTy);
5879 
5880  // struct _objc_protocol_extension *
5881  ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5882 
5883  // Handle recursive construction of Protocol and ProtocolList types
5884 
5885  ProtocolTy =
5886  llvm::StructType::create(VMContext, "struct._objc_protocol");
5887 
5888  ProtocolListTy =
5889  llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5890  ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy,
5891  llvm::ArrayType::get(ProtocolTy, 0));
5892 
5893  // struct _objc_protocol {
5894  // struct _objc_protocol_extension *isa;
5895  // char *protocol_name;
5896  // struct _objc_protocol **_objc_protocol_list;
5897  // struct _objc_method_description_list *instance_methods;
5898  // struct _objc_method_description_list *class_methods;
5899  // }
5900  ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5901  llvm::PointerType::getUnqual(ProtocolListTy),
5902  MethodDescriptionListPtrTy, MethodDescriptionListPtrTy);
5903 
5904  // struct _objc_protocol_list *
5905  ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5906 
5907  ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5908 
5909  // Class description structures
5910 
5911  // struct _objc_ivar {
5912  // char *ivar_name;
5913  // char *ivar_type;
5914  // int ivar_offset;
5915  // }
5916  IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy,
5917  IntTy);
5918 
5919  // struct _objc_ivar_list *
5920  IvarListTy =
5921  llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5922  IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5923 
5924  // struct _objc_method_list *
5925  MethodListTy =
5926  llvm::StructType::create(VMContext, "struct._objc_method_list");
5927  MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5928 
5929  // struct _objc_class_extension *
5930  ClassExtensionTy = llvm::StructType::create(
5931  "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy);
5932  ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5933 
5934  ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5935 
5936  // struct _objc_class {
5937  // Class isa;
5938  // Class super_class;
5939  // char *name;
5940  // long version;
5941  // long info;
5942  // long instance_size;
5943  // struct _objc_ivar_list *ivars;
5944  // struct _objc_method_list *methods;
5945  // struct _objc_cache *cache;
5946  // struct _objc_protocol_list *protocols;
5947  // char *ivar_layout;
5948  // struct _objc_class_ext *ext;
5949  // };
5950  ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5951  llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy,
5952  LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy,
5953  ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy);
5954 
5955  ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5956 
5957  // struct _objc_category {
5958  // char *category_name;
5959  // char *class_name;
5960  // struct _objc_method_list *instance_method;
5961  // struct _objc_method_list *class_method;
5962  // struct _objc_protocol_list *protocols;
5963  // uint32_t size; // sizeof(struct _objc_category)
5964  // struct _objc_property_list *instance_properties;// category's @property
5965  // struct _objc_property_list *class_properties;
5966  // }
5967  CategoryTy = llvm::StructType::create(
5968  "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5969  MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy,
5970  PropertyListPtrTy);
5971 
5972  // Global metadata structures
5973 
5974  // struct _objc_symtab {
5975  // long sel_ref_cnt;
5976  // SEL *refs;
5977  // short cls_def_cnt;
5978  // short cat_def_cnt;
5979  // char *defs[cls_def_cnt + cat_def_cnt];
5980  // }
5981  SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy,
5982  SelectorPtrTy, ShortTy, ShortTy,
5983  llvm::ArrayType::get(Int8PtrTy, 0));
5984  SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
5985 
5986  // struct _objc_module {
5987  // long version;
5988  // long size; // sizeof(struct _objc_module)
5989  // char *name;
5990  // struct _objc_symtab* symtab;
5991  // }
5992  ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy,
5993  Int8PtrTy, SymtabPtrTy);
5994 
5995  // FIXME: This is the size of the setjmp buffer and should be target
5996  // specific. 18 is what's used on 32-bit X86.
5997  uint64_t SetJmpBufferSize = 18;
5998 
5999  // Exceptions
6000  llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
6001 
6002  ExceptionDataTy = llvm::StructType::create(
6003  "struct._objc_exception_data",
6004  llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy);
6005 }
6006 
6007 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
6008  : ObjCCommonTypesHelper(cgm) {
6009  // struct _method_list_t {
6010  // uint32_t entsize; // sizeof(struct _objc_method)
6011  // uint32_t method_count;
6012  // struct _objc_method method_list[method_count];
6013  // }
6014  MethodListnfABITy =
6015  llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
6016  llvm::ArrayType::get(MethodTy, 0));
6017  // struct method_list_t *
6018  MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
6019 
6020  // struct _protocol_t {
6021  // id isa; // NULL
6022  // const char * const protocol_name;
6023  // const struct _protocol_list_t * protocol_list; // super protocols
6024  // const struct method_list_t * const instance_methods;
6025  // const struct method_list_t * const class_methods;
6026  // const struct method_list_t *optionalInstanceMethods;
6027  // const struct method_list_t *optionalClassMethods;
6028  // const struct _prop_list_t * properties;
6029  // const uint32_t size; // sizeof(struct _protocol_t)
6030  // const uint32_t flags; // = 0
6031  // const char ** extendedMethodTypes;
6032  // const char *demangledName;
6033  // const struct _prop_list_t * class_properties;
6034  // }
6035 
6036  // Holder for struct _protocol_list_t *
6037  ProtocolListnfABITy =
6038  llvm::StructType::create(VMContext, "struct._objc_protocol_list");
6039 
6040  ProtocolnfABITy = llvm::StructType::create(
6041  "struct._protocol_t", ObjectPtrTy, Int8PtrTy,
6042  llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy,
6043  MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy,
6044  PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy,
6045  PropertyListPtrTy);
6046 
6047  // struct _protocol_t*
6048  ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
6049 
6050  // struct _protocol_list_t {
6051  // long protocol_count; // Note, this is 32/64 bit
6052  // struct _protocol_t *[protocol_count];
6053  // }
6054  ProtocolListnfABITy->setBody(LongTy,
6055  llvm::ArrayType::get(ProtocolnfABIPtrTy, 0));
6056 
6057  // struct _objc_protocol_list*
6058  ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
6059 
6060  // struct _ivar_t {
6061  // unsigned [long] int *offset; // pointer to ivar offset location
6062  // char *name;
6063  // char *type;
6064  // uint32_t alignment;
6065  // uint32_t size;
6066  // }
6067  IvarnfABITy = llvm::StructType::create(
6068  "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
6069  Int8PtrTy, Int8PtrTy, IntTy, IntTy);
6070 
6071  // struct _ivar_list_t {
6072  // uint32 entsize; // sizeof(struct _ivar_t)
6073  // uint32 count;
6074  // struct _iver_t list[count];
6075  // }
6076  IvarListnfABITy =
6077  llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
6078  llvm::ArrayType::get(IvarnfABITy, 0));
6079 
6080  IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
6081 
6082  // struct _class_ro_t {
6083  // uint32_t const flags;
6084  // uint32_t const instanceStart;
6085  // uint32_t const instanceSize;
6086  // uint32_t const reserved; // only when building for 64bit targets
6087  // const uint8_t * const ivarLayout;
6088  // const char *const name;
6089  // const struct _method_list_t * const baseMethods;
6090  // const struct _objc_protocol_list *const baseProtocols;
6091  // const struct _ivar_list_t *const ivars;
6092  // const uint8_t * const weakIvarLayout;
6093  // const struct _prop_list_t * const properties;
6094  // }
6095 
6096  // FIXME. Add 'reserved' field in 64bit abi mode!
6097  ClassRonfABITy = llvm::StructType::create(
6098  "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy,
6099  MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy,
6100  Int8PtrTy, PropertyListPtrTy);
6101 
6102  // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
6103  llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
6104  ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
6105  ->getPointerTo();
6106 
6107  // struct _class_t {
6108  // struct _class_t *isa;
6109  // struct _class_t * const superclass;
6110  // void *cache;
6111  // IMP *vtable;
6112  // struct class_ro_t *ro;
6113  // }
6114 
6115  ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
6116  ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
6117  llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy,
6118  llvm::PointerType::getUnqual(ImpnfABITy),
6119  llvm::PointerType::getUnqual(ClassRonfABITy));
6120 
6121  // LLVM for struct _class_t *
6122  ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
6123 
6124  // struct _category_t {
6125  // const char * const name;
6126  // struct _class_t *const cls;
6127  // const struct _method_list_t * const instance_methods;
6128  // const struct _method_list_t * const class_methods;
6129  // const struct _protocol_list_t * const protocols;
6130  // const struct _prop_list_t * const properties;
6131  // const struct _prop_list_t * const class_properties;
6132  // const uint32_t size;
6133  // }
6134  CategorynfABITy = llvm::StructType::create(
6135  "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy,
6136  MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy,
6137  PropertyListPtrTy, IntTy);
6138 
6139  // New types for nonfragile abi messaging.
6140  CodeGen::CodeGenTypes &Types = CGM.getTypes();
6141  ASTContext &Ctx = CGM.getContext();
6142 
6143  // MessageRefTy - LLVM for:
6144  // struct _message_ref_t {
6145  // IMP messenger;
6146  // SEL name;
6147  // };
6148 
6149  // First the clang type for struct _message_ref_t
6150  RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
6151  Ctx.getTranslationUnitDecl(),
6152  SourceLocation(), SourceLocation(),
6153  &Ctx.Idents.get("_message_ref_t"));
6154  RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
6155  nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
6156  ICIS_NoInit));
6157  RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
6158  nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
6159  false, ICIS_NoInit));
6160  RD->completeDefinition();
6161 
6162  MessageRefCTy = Ctx.getTagDeclType(RD);
6163  MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
6164  MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
6165 
6166  // MessageRefPtrTy - LLVM for struct _message_ref_t*
6167  MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
6168 
6169  // SuperMessageRefTy - LLVM for:
6170  // struct _super_message_ref_t {
6171  // SUPER_IMP messenger;
6172  // SEL name;
6173  // };
6174  SuperMessageRefTy = llvm::StructType::create("struct._super_message_ref_t",
6175  ImpnfABITy, SelectorPtrTy);
6176 
6177  // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
6178  SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
6179 
6180 
6181  // struct objc_typeinfo {
6182  // const void** vtable; // objc_ehtype_vtable + 2
6183  // const char* name; // c++ typeinfo string
6184  // Class cls;
6185  // };
6186  EHTypeTy = llvm::StructType::create("struct._objc_typeinfo",
6187  llvm::PointerType::getUnqual(Int8PtrTy),
6188  Int8PtrTy, ClassnfABIPtrTy);
6189  EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
6190 }
6191 
6192 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
6193  FinishNonFragileABIModule();
6194 
6195  return nullptr;
6196 }
6197 
6198 void CGObjCNonFragileABIMac::AddModuleClassList(
6199  ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName,
6200  StringRef SectionName) {
6201  unsigned NumClasses = Container.size();
6202 
6203  if (!NumClasses)
6204  return;
6205 
6206  SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
6207  for (unsigned i=0; i<NumClasses; i++)
6208  Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
6209  ObjCTypes.Int8PtrTy);
6210  llvm::Constant *Init =
6211  llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
6212  Symbols.size()),
6213  Symbols);
6214 
6215  // Section name is obtained by calling GetSectionName, which returns
6216  // sections in the __DATA segment on MachO.
6217  assert((!CGM.getTriple().isOSBinFormatMachO() ||
6218  SectionName.startswith("__DATA")) &&
6219  "SectionName expected to start with __DATA on MachO");
6220  llvm::GlobalValue::LinkageTypes LT =
6221  getLinkageTypeForObjCMetadata(CGM, SectionName);
6222  llvm::GlobalVariable *GV =
6223  new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false, LT, Init,
6224  SymbolName);
6225  GV->setAlignment(
6226  llvm::Align(CGM.getDataLayout().getABITypeAlignment(Init->getType())));
6227  GV->setSection(SectionName);
6228  CGM.addCompilerUsedGlobal(GV);
6229 }
6230 
6231 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
6232  // nonfragile abi has no module definition.
6233 
6234  // Build list of all implemented class addresses in array
6235  // L_OBJC_LABEL_CLASS_$.
6236 
6237  for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
6238  const ObjCInterfaceDecl *ID = ImplementedClasses[i];
6239  assert(ID);
6240  if (ObjCImplementationDecl *IMP = ID->getImplementation())
6241  // We are implementing a weak imported interface. Give it external linkage
6242  if (ID->isWeakImported() && !IMP->isWeakImported()) {
6243  DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6244  DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6245  }
6246  }
6247 
6248  AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
6249  GetSectionName("__objc_classlist",
6250  "regular,no_dead_strip"));
6251 
6252  AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$",
6253  GetSectionName("__objc_nlclslist",
6254  "regular,no_dead_strip"));
6255 
6256  // Build list of all implemented category addresses in array
6257  // L_OBJC_LABEL_CATEGORY_$.
6258  AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$",
6259  GetSectionName("__objc_catlist",
6260  "regular,no_dead_strip"));
6261  AddModuleClassList(DefinedStubCategories, "OBJC_LABEL_STUB_CATEGORY_$",
6262  GetSectionName("__objc_catlist2",
6263  "regular,no_dead_strip"));
6264  AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$",
6265  GetSectionName("__objc_nlcatlist",
6266  "regular,no_dead_strip"));
6267 
6268  EmitImageInfo();
6269 }
6270 
6271 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of
6272 /// VTableDispatchMethods; false otherwise. What this means is that
6273 /// except for the 19 selectors in the list, we generate 32bit-style
6274 /// message dispatch call for all the rest.
6275 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
6276  // At various points we've experimented with using vtable-based
6277  // dispatch for all methods.
6278  switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
6279  case CodeGenOptions::Legacy:
6280  return false;
6281  case CodeGenOptions::NonLegacy:
6282  return true;
6283  case CodeGenOptions::Mixed:
6284  break;
6285  }
6286 
6287  // If so, see whether this selector is in the white-list of things which must
6288  // use the new dispatch convention. We lazily build a dense set for this.
6289  if (VTableDispatchMethods.empty()) {
6290  VTableDispatchMethods.insert(GetNullarySelector("alloc"));
6291  VTableDispatchMethods.insert(GetNullarySelector("class"));
6292  VTableDispatchMethods.insert(GetNullarySelector("self"));
6293  VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
6294  VTableDispatchMethods.insert(GetNullarySelector("length"));
6295  VTableDispatchMethods.insert(GetNullarySelector("count"));
6296 
6297  // These are vtable-based if GC is disabled.
6298  // Optimistically use vtable dispatch for hybrid compiles.
6299  if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
6300  VTableDispatchMethods.insert(GetNullarySelector("retain"));
6301  VTableDispatchMethods.insert(GetNullarySelector("release"));
6302  VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
6303  }
6304 
6305  VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
6306  VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
6307  VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
6308  VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
6309  VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
6310  VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
6311  VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
6312 
6313  // These are vtable-based if GC is enabled.
6314  // Optimistically use vtable dispatch for hybrid compiles.
6315  if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
6316  VTableDispatchMethods.insert(GetNullarySelector("hash"));
6317  VTableDispatchMethods.insert(GetUnarySelector("addObject"));
6318 
6319  // "countByEnumeratingWithState:objects:count"
6320  IdentifierInfo *KeyIdents[] = {
6321  &CGM.getContext().Idents.get("countByEnumeratingWithState"),
6322  &CGM.getContext().Idents.get("objects"),
6323  &CGM.getContext().Idents.get("count")
6324  };
6325  VTableDispatchMethods.insert(
6326  CGM.getContext().Selectors.getSelector(3, KeyIdents));
6327  }
6328  }
6329 
6330  return VTableDispatchMethods.count(Sel);
6331 }
6332 
6333 /// BuildClassRoTInitializer - generate meta-data for:
6334 /// struct _class_ro_t {
6335 /// uint32_t const flags;
6336 /// uint32_t const instanceStart;
6337 /// uint32_t const instanceSize;
6338 /// uint32_t const reserved; // only when building for 64bit targets
6339 /// const uint8_t * const ivarLayout;
6340 /// const char *const name;
6341 /// const struct _method_list_t * const baseMethods;
6342 /// const struct _protocol_list_t *const baseProtocols;
6343 /// const struct _ivar_list_t *const ivars;
6344 /// const uint8_t * const weakIvarLayout;
6345 /// const struct _prop_list_t * const properties;
6346 /// }
6347 ///
6348 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
6349  unsigned flags,
6350  unsigned InstanceStart,
6351  unsigned InstanceSize,
6352  const ObjCImplementationDecl *ID) {
6353  std::string ClassName = ID->getObjCRuntimeNameAsString();
6354 
6355  CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
6356  CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
6357 
6358  bool hasMRCWeak = false;
6359  if (CGM.getLangOpts().ObjCAutoRefCount)
6360  flags |= NonFragileABI_Class_CompiledByARC;
6361  else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
6362  flags |= NonFragileABI_Class_HasMRCWeakIvars;
6363 
6364  ConstantInitBuilder builder(CGM);
6365  auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy);
6366 
6367  values.addInt(ObjCTypes.IntTy, flags);
6368  values.addInt(ObjCTypes.IntTy, InstanceStart);
6369  values.addInt(ObjCTypes.IntTy, InstanceSize);
6370  values.add((flags & NonFragileABI_Class_Meta)
6371  ? GetIvarLayoutName(nullptr, ObjCTypes)
6372  : BuildStrongIvarLayout(ID, beginInstance, endInstance));
6373  values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
6374 
6375  // const struct _method_list_t * const baseMethods;
6376  SmallVector<const ObjCMethodDecl*, 16> methods;
6377  if (flags & NonFragileABI_Class_Meta) {
6378  for (const auto *MD : ID->class_methods())
6379  if (!MD->isDirectMethod())
6380  methods.push_back(MD);
6381  } else {
6382  for (const auto *MD : ID->instance_methods())
6383  if (!MD->isDirectMethod())
6384  methods.push_back(MD);
6385  }
6386 
6387  values.add(emitMethodList(ID->getObjCRuntimeNameAsString(),
6388  (flags & NonFragileABI_Class_Meta)
6389  ? MethodListType::ClassMethods
6390  : MethodListType::InstanceMethods,
6391  methods));
6392 
6393  const ObjCInterfaceDecl *OID = ID->getClassInterface();
6394  assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
6395  values.add(EmitProtocolList("_OBJC_CLASS_PROTOCOLS_$_"
6396  + OID->getObjCRuntimeNameAsString(),
6397  OID->all_referenced_protocol_begin(),
6398  OID->all_referenced_protocol_end()));
6399 
6400  if (flags & NonFragileABI_Class_Meta) {
6401  values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy);
6402  values.add(GetIvarLayoutName(nullptr, ObjCTypes));
6403  values.add(EmitPropertyList(
6404  "_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6405  ID, ID->getClassInterface(), ObjCTypes, true));
6406  } else {
6407  values.add(EmitIvarList(ID));
6408  values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak));
6409  values.add(EmitPropertyList(
6410  "_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6411  ID, ID->getClassInterface(), ObjCTypes, false));
6412  }
6413 
6414  llvm::SmallString<64> roLabel;
6415  llvm::raw_svector_ostream(roLabel)
6416  << ((flags & NonFragileABI_Class_Meta) ? "_OBJC_METACLASS_RO_$_"
6417  : "_OBJC_CLASS_RO_$_")
6418  << ClassName;
6419 
6420  return finishAndCreateGlobal(values, roLabel, CGM);
6421 }
6422 
6423 /// Build the metaclass object for a class.
6424 ///
6425 /// struct _class_t {
6426 /// struct _class_t *isa;
6427 /// struct _class_t * const superclass;
6428 /// void *cache;
6429 /// IMP *vtable;
6430 /// struct class_ro_t *ro;
6431 /// }
6432 ///
6433 llvm::GlobalVariable *
6434 CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI,
6435  bool isMetaclass,
6436  llvm::Constant *IsAGV,
6437  llvm::Constant *SuperClassGV,
6438  llvm::Constant *ClassRoGV,
6439  bool HiddenVisibility) {
6440  ConstantInitBuilder builder(CGM);
6441  auto values = builder.beginStruct(ObjCTypes.ClassnfABITy);
6442  values.add(IsAGV);
6443  if (SuperClassGV) {
6444  values.add(SuperClassGV);
6445  } else {
6446  values.addNullPointer(ObjCTypes.ClassnfABIPtrTy);
6447  }
6448  values.add(ObjCEmptyCacheVar);
6449  values.add(ObjCEmptyVtableVar);
6450  values.add(ClassRoGV);
6451 
6452  llvm::GlobalVariable *GV =
6453  cast<llvm::GlobalVariable>(GetClassGlobal(CI, isMetaclass, ForDefinition));
6454  values.finishAndSetAsInitializer(GV);
6455 
6456  if (CGM.getTriple().isOSBinFormatMachO())
6457  GV->setSection("__DATA, __objc_data");
6458  GV->setAlignment(llvm::Align(
6459  CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy)));
6460  if (!CGM.getTriple().isOSBinFormatCOFF())
6461  if (HiddenVisibility)
6462  GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6463  return GV;
6464 }
6465 
6466 bool CGObjCNonFragileABIMac::ImplementationIsNonLazy(
6467  const ObjCImplDecl *OD) const {
6468  return OD->getClassMethod(GetNullarySelector("load")) != nullptr ||
6469  OD->getClassInterface()->hasAttr<ObjCNonLazyClassAttr>() ||
6470  OD->hasAttr<ObjCNonLazyClassAttr>();
6471 }
6472 
6473 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
6474  uint32_t &InstanceStart,
6475  uint32_t &InstanceSize) {
6476  const ASTRecordLayout &RL =
6477  CGM.getContext().getASTObjCImplementationLayout(OID);
6478 
6479  // InstanceSize is really instance end.
6480  InstanceSize = RL.getDataSize().getQuantity();
6481 
6482  // If there are no fields, the start is the same as the end.
6483  if (!RL.getFieldCount())
6484  InstanceStart = InstanceSize;
6485  else
6486  InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
6487 }
6488 
6489 static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM,
6490  StringRef Name) {
6491  IdentifierInfo &II = CGM.getContext().Idents.get(Name);
6492  TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
6493  DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
6494 
6495  const VarDecl *VD = nullptr;
6496  for (const auto &Result : DC->lookup(&II))
6497  if ((VD = dyn_cast<VarDecl>(Result)))
6498  break;
6499 
6500  if (!VD)
6501  return llvm::GlobalValue::DLLImportStorageClass;
6502  if (VD->hasAttr<DLLExportAttr>())
6503  return llvm::GlobalValue::DLLExportStorageClass;
6504  if (VD->hasAttr<DLLImportAttr>())
6505  return llvm::GlobalValue::DLLImportStorageClass;
6506  return llvm::GlobalValue::DefaultStorageClass;
6507 }
6508 
6509 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
6510  if (!ObjCEmptyCacheVar) {
6511  ObjCEmptyCacheVar =
6512  new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false,
6513  llvm::GlobalValue::ExternalLinkage, nullptr,
6514  "_objc_empty_cache");
6515  if (CGM.getTriple().isOSBinFormatCOFF())
6516  ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache"));
6517 
6518  // Only OS X with deployment version <10.9 use the empty vtable symbol
6519  const llvm::Triple &Triple = CGM.getTarget().getTriple();
6520  if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9))
6521  ObjCEmptyVtableVar =
6522  new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false,
6523  llvm::GlobalValue::ExternalLinkage, nullptr,
6524  "_objc_empty_vtable");
6525  else
6526  ObjCEmptyVtableVar =
6527  llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo());
6528  }
6529 
6530  // FIXME: Is this correct (that meta class size is never computed)?
6531  uint32_t InstanceStart =
6532  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
6533  uint32_t InstanceSize = InstanceStart;
6534  uint32_t flags = NonFragileABI_Class_Meta;
6535 
6536  llvm::Constant *SuperClassGV, *IsAGV;
6537 
6538  const auto *CI = ID->getClassInterface();
6539  assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0");
6540 
6541  // Build the flags for the metaclass.
6542  bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF())
6543  ? !CI->hasAttr<DLLExportAttr>()
6544  : CI->getVisibility() == HiddenVisibility;
6545  if (classIsHidden)
6546  flags |= NonFragileABI_Class_Hidden;
6547 
6548  // FIXME: why is this flag set on the metaclass?
6549  // ObjC metaclasses have no fields and don't really get constructed.
6550  if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6552  if (!ID->hasNonZeroConstructors())
6554  }
6555 
6556  if (!CI->getSuperClass()) {
6557  // class is root
6558  flags |= NonFragileABI_Class_Root;
6559 
6560  SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition);
6561  IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition);
6562  } else {
6563  // Has a root. Current class is not a root.
6564  const ObjCInterfaceDecl *Root = ID->getClassInterface();
6565  while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
6566  Root = Super;
6567 
6568  const auto *Super = CI->getSuperClass();
6569  IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition);
6570  SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition);
6571  }
6572 
6573  llvm::GlobalVariable *CLASS_RO_GV =
6574  BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6575 
6576  llvm::GlobalVariable *MetaTClass =
6577  BuildClassObject(CI, /*metaclass*/ true,
6578  IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden);
6579  CGM.setGVProperties(MetaTClass, CI);
6580  DefinedMetaClasses.push_back(MetaTClass);
6581 
6582  // Metadata for the class
6583  flags = 0;
6584  if (classIsHidden)
6585  flags |= NonFragileABI_Class_Hidden;
6586 
6587  if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6589 
6590  // Set a flag to enable a runtime optimization when a class has
6591  // fields that require destruction but which don't require
6592  // anything except zero-initialization during construction. This
6593  // is most notably true of __strong and __weak types, but you can
6594  // also imagine there being C++ types with non-trivial default
6595  // constructors that merely set all fields to null.
6596  if (!ID->hasNonZeroConstructors())
6598  }
6599 
6600  if (hasObjCExceptionAttribute(CGM.getContext(), CI))
6602 
6603  if (!CI->getSuperClass()) {
6604  flags |= NonFragileABI_Class_Root;
6605  SuperClassGV = nullptr;
6606  } else {
6607  // Has a root. Current class is not a root.
6608  const auto *Super = CI->getSuperClass();
6609  SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition);
6610  }
6611 
6612  GetClassSizeInfo(ID, InstanceStart, InstanceSize);
6613  CLASS_RO_GV =
6614  BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6615 
6616  llvm::GlobalVariable *ClassMD =
6617  BuildClassObject(CI, /*metaclass*/ false,
6618  MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden);
6619  CGM.setGVProperties(ClassMD, CI);
6620  DefinedClasses.push_back(ClassMD);
6621  ImplementedClasses.push_back(CI);
6622 
6623  // Determine if this class is also "non-lazy".
6624  if (ImplementationIsNonLazy(ID))
6625  DefinedNonLazyClasses.push_back(ClassMD);
6626 
6627  // Force the definition of the EHType if necessary.
6628  if (flags & NonFragileABI_Class_Exception)
6629  (void) GetInterfaceEHType(CI, ForDefinition);
6630  // Make sure method definition entries are all clear for next implementation.
6631  MethodDefinitions.clear();
6632 }
6633 
6634 /// GenerateProtocolRef - This routine is called to generate code for
6635 /// a protocol reference expression; as in:
6636 /// @code
6637 /// @protocol(Proto1);
6638 /// @endcode
6639 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
6640 /// which will hold address of the protocol meta-data.
6641 ///
6642 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
6643  const ObjCProtocolDecl *PD) {
6644 
6645  // This routine is called for @protocol only. So, we must build definition
6646  // of protocol's meta-data (not a reference to it!)
6647  //
6648  llvm::Constant *Init =
6649  llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
6650  ObjCTypes.getExternalProtocolPtrTy());
6651 
6652  std::string ProtocolName("_OBJC_PROTOCOL_REFERENCE_$_");
6653  ProtocolName += PD->getObjCRuntimeNameAsString();
6654 
6655  CharUnits Align = CGF.getPointerAlign();
6656 
6657  llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
6658  if (PTGV)
6659  return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6660  PTGV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6661  llvm::GlobalValue::WeakAnyLinkage, Init,
6662  ProtocolName);
6663  PTGV->setSection(GetSectionName("__objc_protorefs",
6664  "coalesced,no_dead_strip"));
6665  PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6666  PTGV->setAlignment(Align.getAsAlign());
6667  if (!CGM.getTriple().isOSBinFormatMachO())
6668  PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolName));
6669  CGM.addUsedGlobal(PTGV);
6670  return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6671 }
6672 
6673 /// GenerateCategory - Build metadata for a category implementation.
6674 /// struct _category_t {
6675 /// const char * const name;
6676 /// struct _class_t *const cls;
6677 /// const struct _method_list_t * const instance_methods;
6678 /// const struct _method_list_t * const class_methods;
6679 /// const struct _protocol_list_t * const protocols;
6680 /// const struct _prop_list_t * const properties;
6681 /// const struct _prop_list_t * const class_properties;
6682 /// const uint32_t size;
6683 /// }
6684 ///
6685 void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
6686  const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
6687  const char *Prefix = "_OBJC_$_CATEGORY_";
6688 
6689  llvm::SmallString<64> ExtCatName(Prefix);
6690  ExtCatName += Interface->getObjCRuntimeNameAsString();
6691  ExtCatName += "_$_";
6692  ExtCatName += OCD->getNameAsString();
6693 
6694  ConstantInitBuilder builder(CGM);
6695  auto values = builder.beginStruct(ObjCTypes.CategorynfABITy);
6696  values.add(GetClassName(OCD->getIdentifier()->getName()));
6697  // meta-class entry symbol
6698  values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition));
6699  std::string listName =
6700  (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str();
6701 
6704  for (const auto *MD : OCD->methods()) {
6705  if (MD->isDirectMethod())
6706  continue;
6707  if (MD->isInstanceMethod()) {
6708  instanceMethods.push_back(MD);
6709  } else {
6710  classMethods.push_back(MD);
6711  }
6712  }
6713 
6714  values.add(emitMethodList(listName, MethodListType::CategoryInstanceMethods,
6715  instanceMethods));
6716  values.add(emitMethodList(listName, MethodListType::CategoryClassMethods,
6717  classMethods));
6718 
6719  const ObjCCategoryDecl *Category =
6720  Interface->FindCategoryDeclaration(OCD->getIdentifier());
6721  if (Category) {
6722  SmallString<256> ExtName;
6723  llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
6724  << OCD->getName();
6725  values.add(EmitProtocolList("_OBJC_CATEGORY_PROTOCOLS_$_"
6726  + Interface->getObjCRuntimeNameAsString() + "_$_"
6727  + Category->getName(),
6728  Category->protocol_begin(),
6729  Category->protocol_end()));
6730  values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
6731  OCD, Category, ObjCTypes, false));
6732  values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
6733  OCD, Category, ObjCTypes, true));
6734  } else {
6735  values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy);
6736  values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6737  values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6738  }
6739 
6740  unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy);
6741  values.addInt(ObjCTypes.IntTy, Size);
6742 
6743  llvm::GlobalVariable *GCATV =
6744  finishAndCreateGlobal(values, ExtCatName.str(), CGM);
6745  CGM.addCompilerUsedGlobal(GCATV);
6746  if (Interface->hasAttr<ObjCClassStubAttr>())
6747  DefinedStubCategories.push_back(GCATV);
6748  else
6749  DefinedCategories.push_back(GCATV);
6750 
6751  // Determine if this category is also "non-lazy".
6752  if (ImplementationIsNonLazy(OCD))
6753  DefinedNonLazyCategories.push_back(GCATV);
6754  // method definition entries must be clear for next implementation.
6755  MethodDefinitions.clear();
6756 }
6757 
6758 /// emitMethodConstant - Return a struct objc_method constant. If
6759 /// forProtocol is true, the implementation will be null; otherwise,
6760 /// the method must have a definition registered with the runtime.
6761 ///
6762 /// struct _objc_method {
6763 /// SEL _cmd;
6764 /// char *method_type;
6765 /// char *_imp;
6766 /// }
6767 void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
6768  const ObjCMethodDecl *MD,
6769  bool forProtocol) {
6770  auto method = builder.beginStruct(ObjCTypes.MethodTy);
6771  method.addBitCast(GetMethodVarName(MD->getSelector()),
6772  ObjCTypes.SelectorPtrTy);
6773  method.add(GetMethodVarType(MD));
6774 
6775  if (forProtocol) {
6776  // Protocol methods have no implementation. So, this entry is always NULL.
6777  method.addNullPointer(ObjCTypes.Int8PtrTy);
6778  } else {
6779  llvm::Function *fn = GetMethodDefinition(MD);
6780  assert(fn && "no definition for method?");
6781  method.addBitCast(fn, ObjCTypes.Int8PtrTy);
6782  }
6783 
6784  method.finishAndAddTo(builder);
6785 }
6786 
6787 /// Build meta-data for method declarations.
6788 ///
6789 /// struct _method_list_t {
6790 /// uint32_t entsize; // sizeof(struct _objc_method)
6791 /// uint32_t method_count;
6792 /// struct _objc_method method_list[method_count];
6793 /// }
6794 ///
6795 llvm::Constant *
6796 CGObjCNonFragileABIMac::emitMethodList(Twine name, MethodListType kind,
6798  // Return null for empty list.
6799  if (methods.empty())
6800  return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
6801 
6802  StringRef prefix;
6803  bool forProtocol;
6804  switch (kind) {
6805  case MethodListType::CategoryInstanceMethods:
6806  prefix = "_OBJC_$_CATEGORY_INSTANCE_METHODS_";
6807  forProtocol = false;
6808  break;
6809  case MethodListType::CategoryClassMethods:
6810  prefix = "_OBJC_$_CATEGORY_CLASS_METHODS_";
6811  forProtocol = false;
6812  break;
6813  case MethodListType::InstanceMethods:
6814  prefix = "_OBJC_$_INSTANCE_METHODS_";
6815  forProtocol = false;
6816  break;
6817  case MethodListType::ClassMethods:
6818  prefix = "_OBJC_$_CLASS_METHODS_";
6819  forProtocol = false;
6820  break;
6821 
6822  case MethodListType::ProtocolInstanceMethods:
6823  prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_";
6824  forProtocol = true;
6825  break;
6826  case MethodListType::ProtocolClassMethods:
6827  prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_";
6828  forProtocol = true;
6829  break;
6830  case MethodListType::OptionalProtocolInstanceMethods:
6831  prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_";
6832  forProtocol = true;
6833  break;
6834  case MethodListType::OptionalProtocolClassMethods:
6835  prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_";
6836  forProtocol = true;
6837  break;
6838  }
6839 
6840  ConstantInitBuilder builder(CGM);
6841  auto values = builder.beginStruct();
6842 
6843  // sizeof(struct _objc_method)
6844  unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
6845  values.addInt(ObjCTypes.IntTy, Size);
6846  // method_count
6847  values.addInt(ObjCTypes.IntTy, methods.size());
6848  auto methodArray = values.beginArray(ObjCTypes.MethodTy);
6849  for (auto MD : methods)
6850  emitMethodConstant(methodArray, MD, forProtocol);
6851  methodArray.finishAndAddTo(values);
6852 
6853  llvm::GlobalVariable *GV = finishAndCreateGlobal(values, prefix + name, CGM);
6854  CGM.addCompilerUsedGlobal(GV);
6855  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6856 }
6857 
6858 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6859 /// the given ivar.
6860 llvm::GlobalVariable *
6861 CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
6862  const ObjCIvarDecl *Ivar) {
6863  const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
6864  llvm::SmallString<64> Name("OBJC_IVAR_$_");
6865  Name += Container->getObjCRuntimeNameAsString();
6866  Name += ".";
6867  Name += Ivar->getName();
6868  llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name);
6869  if (!IvarOffsetGV) {
6870  IvarOffsetGV =
6871  new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.IvarOffsetVarTy,
6873  nullptr, Name.str());
6874  if (CGM.getTriple().isOSBinFormatCOFF()) {
6875  bool IsPrivateOrPackage =
6878 
6879  const ObjCInterfaceDecl *ContainingID = Ivar->getContainingInterface();
6880 
6881  if (ContainingID->hasAttr<DLLImportAttr>())
6882  IvarOffsetGV
6883  ->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6884  else if (ContainingID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage)
6885  IvarOffsetGV
6886  ->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6887  }
6888  }
6889  return IvarOffsetGV;
6890 }
6891 
6892 llvm::Constant *
6893 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
6894  const ObjCIvarDecl *Ivar,
6895  unsigned long int Offset) {
6896  llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
6897  IvarOffsetGV->setInitializer(
6898  llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
6899  IvarOffsetGV->setAlignment(llvm::Align(
6900  CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy)));
6901 
6902  if (!CGM.getTriple().isOSBinFormatCOFF()) {
6903  // FIXME: This matches gcc, but shouldn't the visibility be set on the use
6904  // as well (i.e., in ObjCIvarOffsetVariable).
6905  if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6908  IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6909  else
6910  IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
6911  }
6912 
6913  // If ID's layout is known, then make the global constant. This serves as a
6914  // useful assertion: we'll never use this variable to calculate ivar offsets,
6915  // so if the runtime tries to patch it then we should crash.
6916  if (isClassLayoutKnownStatically(ID))
6917  IvarOffsetGV->setConstant(true);
6918 
6919  if (CGM.getTriple().isOSBinFormatMachO())
6920  IvarOffsetGV->setSection("__DATA, __objc_ivar");
6921  return IvarOffsetGV;
6922 }
6923 
6924 /// EmitIvarList - Emit the ivar list for the given
6925 /// implementation. The return value has type
6926 /// IvarListnfABIPtrTy.
6927 /// struct _ivar_t {
6928 /// unsigned [long] int *offset; // pointer to ivar offset location
6929 /// char *name;
6930 /// char *type;
6931 /// uint32_t alignment;
6932 /// uint32_t size;
6933 /// }
6934 /// struct _ivar_list_t {
6935 /// uint32 entsize; // sizeof(struct _ivar_t)
6936 /// uint32 count;
6937 /// struct _iver_t list[count];
6938 /// }
6939 ///
6940 
6941 llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
6942  const ObjCImplementationDecl *ID) {
6943 
6944  ConstantInitBuilder builder(CGM);
6945  auto ivarList = builder.beginStruct();
6946  ivarList.addInt(ObjCTypes.IntTy,
6947  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy));
6948  auto ivarCountSlot = ivarList.addPlaceholder();
6949  auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy);
6950 
6951  const ObjCInterfaceDecl *OID = ID->getClassInterface();
6952  assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
6953 
6954  // FIXME. Consolidate this with similar code in GenerateClass.
6955 
6956  for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
6957  IVD; IVD = IVD->getNextIvar()) {
6958  // Ignore unnamed bit-fields.
6959  if (!IVD->getDeclName())
6960  continue;
6961 
6962  auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy);
6963  ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD,
6964  ComputeIvarBaseOffset(CGM, ID, IVD)));
6965  ivar.add(GetMethodVarName(IVD->getIdentifier()));
6966  ivar.add(GetMethodVarType(IVD));
6967  llvm::Type *FieldTy =
6968  CGM.getTypes().ConvertTypeForMem(IVD->getType());
6969  unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
6970  unsigned Align = CGM.getContext().getPreferredTypeAlign(
6971  IVD->getType().getTypePtr()) >> 3;
6972  Align = llvm::Log2_32(Align);
6973  ivar.addInt(ObjCTypes.IntTy, Align);
6974  // NOTE. Size of a bitfield does not match gcc's, because of the
6975  // way bitfields are treated special in each. But I am told that
6976  // 'size' for bitfield ivars is ignored by the runtime so it does
6977  // not matter. If it matters, there is enough info to get the
6978  // bitfield right!
6979  ivar.addInt(ObjCTypes.IntTy, Size);
6980  ivar.finishAndAddTo(ivars);
6981  }
6982  // Return null for empty list.
6983  if (ivars.empty()) {
6984  ivars.abandon();
6985  ivarList.abandon();
6986  return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
6987  }
6988 
6989  auto ivarCount = ivars.size();
6990  ivars.finishAndAddTo(ivarList);
6991  ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount);
6992 
6993  const char *Prefix = "_OBJC_$_INSTANCE_VARIABLES_";
6994  llvm::GlobalVariable *GV = finishAndCreateGlobal(
6995  ivarList, Prefix + OID->getObjCRuntimeNameAsString(), CGM);
6996  CGM.addCompilerUsedGlobal(GV);
6997  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
6998 }
6999 
7000 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
7001  const ObjCProtocolDecl *PD) {
7002  llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
7003 
7004  if (!Entry) {
7005  // We use the initializer as a marker of whether this is a forward
7006  // reference or not. At module finalization we add the empty
7007  // contents for protocols which were referenced but never defined.
7008  llvm::SmallString<64> Protocol;
7009  llvm::raw_svector_ostream(Protocol) << "_OBJC_PROTOCOL_$_"
7010  << PD->getObjCRuntimeNameAsString();
7011 
7012  Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
7014  nullptr, Protocol);
7015  if (!CGM.getTriple().isOSBinFormatMachO())
7016  Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol));
7017  }
7018 
7019  return Entry;
7020 }
7021 
7022 /// GetOrEmitProtocol - Generate the protocol meta-data:
7023 /// @code
7024 /// struct _protocol_t {
7025 /// id isa; // NULL
7026 /// const char * const protocol_name;
7027 /// const struct _protocol_list_t * protocol_list; // super protocols
7028 /// const struct method_list_t * const instance_methods;
7029 /// const struct method_list_t * const class_methods;
7030 /// const struct method_list_t *optionalInstanceMethods;
7031 /// const struct method_list_t *optionalClassMethods;
7032 /// const struct _prop_list_t * properties;
7033 /// const uint32_t size; // sizeof(struct _protocol_t)
7034 /// const uint32_t flags; // = 0
7035 /// const char ** extendedMethodTypes;
7036 /// const char *demangledName;
7037 /// const struct _prop_list_t * class_properties;
7038 /// }
7039 /// @endcode
7040 ///
7041 
7042 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
7043  const ObjCProtocolDecl *PD) {
7044  llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
7045 
7046  // Early exit if a defining object has already been generated.
7047  if (Entry && Entry->hasInitializer())
7048  return Entry;
7049 
7050  // Use the protocol definition, if there is one.
7051  assert(PD->hasDefinition() &&
7052  "emitting protocol metadata without definition");
7053  PD = PD->getDefinition();
7054 
7055  auto methodLists = ProtocolMethodLists::get(PD);
7056 
7057  ConstantInitBuilder builder(CGM);
7058  auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy);
7059 
7060  // isa is NULL
7061  values.addNullPointer(ObjCTypes.ObjectPtrTy);
7062  values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
7063  values.add(EmitProtocolList("_OBJC_$_PROTOCOL_REFS_"
7064  + PD->getObjCRuntimeNameAsString(),
7065  PD->protocol_begin(),
7066  PD->protocol_end()));
7067  values.add(methodLists.emitMethodList(this, PD,
7068  ProtocolMethodLists::RequiredInstanceMethods));
7069  values.add(methodLists.emitMethodList(this, PD,
7070  ProtocolMethodLists::RequiredClassMethods));
7071  values.add(methodLists.emitMethodList(this, PD,
7072  ProtocolMethodLists::OptionalInstanceMethods));
7073  values.add(methodLists.emitMethodList(this, PD,
7074  ProtocolMethodLists::OptionalClassMethods));
7075  values.add(EmitPropertyList(
7076  "_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
7077  nullptr, PD, ObjCTypes, false));
7078  uint32_t Size =
7079  CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
7080  values.addInt(ObjCTypes.IntTy, Size);
7081  values.addInt(ObjCTypes.IntTy, 0);
7082  values.add(EmitProtocolMethodTypes("_OBJC_$_PROTOCOL_METHOD_TYPES_"
7083  + PD->getObjCRuntimeNameAsString(),
7084  methodLists.emitExtendedTypesArray(this),
7085  ObjCTypes));
7086 
7087  // const char *demangledName;
7088  values.addNullPointer(ObjCTypes.Int8PtrTy);
7089 
7090  values.add(EmitPropertyList(
7091  "_OBJC_$_CLASS_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
7092  nullptr, PD, ObjCTypes, true));
7093 
7094  if (Entry) {
7095  // Already created, fix the linkage and update the initializer.
7096  Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
7097  values.finishAndSetAsInitializer(Entry);
7098  } else {
7099  llvm::SmallString<64> symbolName;
7100  llvm::raw_svector_ostream(symbolName)
7101  << "_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString();
7102 
7103  Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(),
7104  /*constant*/ false,
7105  llvm::GlobalValue::WeakAnyLinkage);
7106  if (!CGM.getTriple().isOSBinFormatMachO())
7107  Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName));
7108 
7109  Protocols[PD->getIdentifier()] = Entry;
7110  }
7111  Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7112  CGM.addUsedGlobal(Entry);
7113 
7114  // Use this protocol meta-data to build protocol list table in section
7115  // __DATA, __objc_protolist
7116  llvm::SmallString<64> ProtocolRef;
7117  llvm::raw_svector_ostream(ProtocolRef) << "_OBJC_LABEL_PROTOCOL_$_"
7118  << PD->getObjCRuntimeNameAsString();
7119 
7120  llvm::GlobalVariable *PTGV =
7121  new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
7122  false, llvm::GlobalValue::WeakAnyLinkage, Entry,
7123  ProtocolRef);
7124  if (!CGM.getTriple().isOSBinFormatMachO())
7125  PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef));
7126  PTGV->setAlignment(llvm::Align(
7127  CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy)));
7128  PTGV->setSection(GetSectionName("__objc_protolist",
7129  "coalesced,no_dead_strip"));
7130  PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
7131  CGM.addUsedGlobal(PTGV);
7132  return Entry;
7133 }
7134 
7135 /// EmitProtocolList - Generate protocol list meta-data:
7136 /// @code
7137 /// struct _protocol_list_t {
7138 /// long protocol_count; // Note, this is 32/64 bit
7139 /// struct _protocol_t[protocol_count];
7140 /// }
7141 /// @endcode
7142 ///
7143 llvm::Constant *
7144 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
7147  SmallVector<llvm::Constant *, 16> ProtocolRefs;
7148 
7149  // Just return null for empty protocol lists
7150  if (begin == end)
7151  return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
7152 
7153  // FIXME: We shouldn't need to do this lookup here, should we?
7154  SmallString<256> TmpName;
7155  Name.toVector(TmpName);
7156  llvm::GlobalVariable *GV =
7157  CGM.getModule().getGlobalVariable(TmpName.str(), true);
7158  if (GV)
7159  return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
7160 
7161  ConstantInitBuilder builder(CGM);
7162  auto values = builder.beginStruct();
7163  auto countSlot = values.addPlaceholder();
7164 
7165  // A null-terminated array of protocols.
7166  auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy);
7167  for (; begin != end; ++begin)
7168  array.add(GetProtocolRef(*begin)); // Implemented???
7169  auto count = array.size();
7170  array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy);
7171 
7172  array.finishAndAddTo(values);
7173  values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
7174 
7175  GV = finishAndCreateGlobal(values, Name, CGM);
7176  CGM.addCompilerUsedGlobal(GV);
7177  return llvm::ConstantExpr::getBitCast(GV,
7178  ObjCTypes.ProtocolListnfABIPtrTy);
7179 }
7180 
7181 /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
7182 /// This code gen. amounts to generating code for:
7183 /// @code
7184 /// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
7185 /// @encode
7186 ///
7187 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
7189  QualType ObjectTy,
7190  llvm::Value *BaseValue,
7191  const ObjCIvarDecl *Ivar,
7192  unsigned CVRQualifiers) {
7193  ObjCInterfaceDecl *ID = ObjectTy->castAs<ObjCObjectType>()->getInterface();
7194  llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
7195  return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
7196  Offset);
7197 }
7198 
7199 llvm::Value *
7200 CGObjCNonFragileABIMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
7201  const ObjCInterfaceDecl *Interface,
7202  const ObjCIvarDecl *Ivar) {
7203  llvm::Value *IvarOffsetValue;
7204  if (isClassLayoutKnownStatically(Interface)) {
7205  IvarOffsetValue = llvm::ConstantInt::get(
7206  ObjCTypes.IvarOffsetVarTy,
7207  ComputeIvarBaseOffset(CGM, Interface->getImplementation(), Ivar));
7208  } else {
7209  llvm::GlobalVariable *GV = ObjCIvarOffsetVariable(Interface, Ivar);
7210  IvarOffsetValue =
7211  CGF.Builder.CreateAlignedLoad(GV, CGF.getSizeAlign(), "ivar");
7212  if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
7213  cast<llvm::LoadInst>(IvarOffsetValue)
7214  ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7215  llvm::MDNode::get(VMContext, None));
7216  }
7217 
7218  // This could be 32bit int or 64bit integer depending on the architecture.
7219  // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
7220  // as this is what caller always expects.
7221  if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
7222  IvarOffsetValue = CGF.Builder.CreateIntCast(
7223  IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
7224  return IvarOffsetValue;
7225 }
7226 
7227 static void appendSelectorForMessageRefTable(std::string &buffer,
7228  Selector selector) {
7229  if (selector.isUnarySelector()) {
7230  buffer += selector.getNameForSlot(0);
7231  return;
7232  }
7233 
7234  for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
7235  buffer += selector.getNameForSlot(i);
7236  buffer += '_';
7237  }
7238 }
7239 
7240 /// Emit a "vtable" message send. We emit a weak hidden-visibility
7241 /// struct, initially containing the selector pointer and a pointer to
7242 /// a "fixup" variant of the appropriate objc_msgSend. To call, we
7243 /// load and call the function pointer, passing the address of the
7244 /// struct as the second parameter. The runtime determines whether
7245 /// the selector is currently emitted using vtable dispatch; if so, it
7246 /// substitutes a stub function which simply tail-calls through the
7247 /// appropriate vtable slot, and if not, it substitues a stub function
7248 /// which tail-calls objc_msgSend. Both stubs adjust the selector
7249 /// argument to correctly point to the selector.
7250 RValue
7251 CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
7252  ReturnValueSlot returnSlot,
7253  QualType resultType,
7254  Selector selector,
7255  llvm::Value *arg0,
7256  QualType arg0Type,
7257  bool isSuper,
7258  const CallArgList &formalArgs,
7259  const ObjCMethodDecl *method) {
7260  // Compute the actual arguments.
7261  CallArgList args;
7262 
7263  // First argument: the receiver / super-call structure.
7264  if (!isSuper)
7265  arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
7266  args.add(RValue::get(arg0), arg0Type);
7267 
7268  // Second argument: a pointer to the message ref structure. Leave
7269  // the actual argument value blank for now.
7270  args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);
7271 
7272  args.insert(args.end(), formalArgs.begin(), formalArgs.end());
7273 
7274  MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);
7275 
7276  NullReturnState nullReturn;
7277 
7278  // Find the function to call and the mangled name for the message
7279  // ref structure. Using a different mangled name wouldn't actually
7280  // be a problem; it would just be a waste.
7281  //
7282  // The runtime currently never uses vtable dispatch for anything
7283  // except normal, non-super message-sends.
7284  // FIXME: don't use this for that.
7285  llvm::FunctionCallee fn = nullptr;
7286  std::string messageRefName("_");
7287  if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
7288  if (isSuper) {
7289  fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
7290  messageRefName += "objc_msgSendSuper2_stret_fixup";
7291  } else {
7292  nullReturn.init(CGF, arg0);
7293  fn = ObjCTypes.getMessageSendStretFixupFn();
7294  messageRefName += "objc_msgSend_stret_fixup";
7295  }
7296  } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
7297  fn = ObjCTypes.getMessageSendFpretFixupFn();
7298  messageRefName += "objc_msgSend_fpret_fixup";
7299  } else {
7300  if (isSuper) {
7301  fn = ObjCTypes.getMessageSendSuper2FixupFn();
7302  messageRefName += "objc_msgSendSuper2_fixup";
7303  } else {
7304  fn = ObjCTypes.getMessageSendFixupFn();
7305  messageRefName += "objc_msgSend_fixup";
7306  }
7307  }
7308  assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend");
7309  messageRefName += '_';
7310 
7311  // Append the selector name, except use underscores anywhere we
7312  // would have used colons.
7313  appendSelectorForMessageRefTable(messageRefName, selector);
7314 
7315  llvm::GlobalVariable *messageRef
7316  = CGM.getModule().getGlobalVariable(messageRefName);
7317  if (!messageRef) {
7318  // Build the message ref structure.
7319  ConstantInitBuilder builder(CGM);
7320  auto values = builder.beginStruct();
7321  values.add(cast<llvm::Constant>(fn.getCallee()));
7322  values.add(GetMethodVarName(selector));
7323  messageRef = values.finishAndCreateGlobal(messageRefName,
7325  /*constant*/ false,
7326  llvm::GlobalValue::WeakAnyLinkage);
7327  messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
7328  messageRef->setSection(GetSectionName("__objc_msgrefs", "coalesced"));
7329  }
7330 
7331  bool requiresnullCheck = false;
7332  if (CGM.getLangOpts().ObjCAutoRefCount && method)
7333  for (const auto *ParamDecl : method->parameters()) {
7334  if (ParamDecl->hasAttr<NSConsumedAttr>()) {
7335  if (!nullReturn.NullBB)
7336  nullReturn.init(CGF, arg0);
7337  requiresnullCheck = true;
7338  break;
7339  }
7340  }
7341 
7342  Address mref =
7343  Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
7344  CGF.getPointerAlign());
7345 
7346  // Update the message ref argument.
7347  args[1].setRValue(RValue::get(mref.getPointer()));
7348 
7349  // Load the function to call from the message ref table.
7350  Address calleeAddr = CGF.Builder.CreateStructGEP(mref, 0);
7351  llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn");
7352 
7353  calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
7354  CGCallee callee(CGCalleeInfo(), calleePtr);
7355 
7356  RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
7357  return nullReturn.complete(CGF, returnSlot, result, resultType, formalArgs,
7358  requiresnullCheck ? method : nullptr);
7359 }
7360 
7361 /// Generate code for a message send expression in the nonfragile abi.
7363 CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
7364  ReturnValueSlot Return,
7365  QualType ResultType,
7366  Selector Sel,
7367  llvm::Value *Receiver,
7368  const CallArgList &CallArgs,
7369  const ObjCInterfaceDecl *Class,
7370  const ObjCMethodDecl *Method) {
7371  return isVTableDispatchedSelector(Sel)
7372  ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7373  Receiver, CGF.getContext().getObjCIdType(),
7374  false, CallArgs, Method)
7375  : EmitMessageSend(CGF, Return, ResultType, Sel,
7376  Receiver, CGF.getContext().getObjCIdType(),
7377  false, CallArgs, Method, Class, ObjCTypes);
7378 }
7379 
7380 llvm::Constant *
7381 CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID,
7382  bool metaclass,
7383  ForDefinition_t isForDefinition) {
7384  auto prefix =
7385  (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix());
7386  return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(),
7387  isForDefinition,
7388  ID->isWeakImported(),
7389  !isForDefinition
7390  && CGM.getTriple().isOSBinFormatCOFF()
7391  && ID->hasAttr<DLLImportAttr>());
7392 }
7393 
7394 llvm::Constant *
7395 CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
7396  ForDefinition_t IsForDefinition,
7397  bool Weak, bool DLLImport) {
7398  llvm::GlobalValue::LinkageTypes L =
7399  Weak ? llvm::GlobalValue::ExternalWeakLinkage
7401 
7402  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
7403  if (!GV || GV->getType() != ObjCTypes.ClassnfABITy->getPointerTo()) {
7404  auto *NewGV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, L,
7405  nullptr, Name);
7406 
7407  if (DLLImport)
7408  NewGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
7409 
7410  if (GV) {
7411  GV->replaceAllUsesWith(
7412  llvm::ConstantExpr::getBitCast(NewGV, GV->getType()));
7413  GV->eraseFromParent();
7414  }
7415  GV = NewGV;
7416  CGM.getModule().getGlobalList().push_back(GV);
7417  }
7418 
7419  assert(GV->getLinkage() == L);
7420  return GV;
7421 }
7422 
7423 llvm::Constant *
7424 CGObjCNonFragileABIMac::GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID) {
7425  llvm::Constant *ClassGV = GetClassGlobal(ID, /*metaclass*/ false,
7427 
7428  if (!ID->hasAttr<ObjCClassStubAttr>())
7429  return ClassGV;
7430 
7431  ClassGV = llvm::ConstantExpr::getPointerCast(ClassGV, ObjCTypes.Int8PtrTy);
7432 
7433  // Stub classes are pointer-aligned. Classrefs pointing at stub classes
7434  // must set the least significant bit set to 1.
7435  auto *Idx = llvm::ConstantInt::get(CGM.Int32Ty, 1);
7436  return llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, ClassGV, Idx);
7437 }
7438 
7439 llvm::Value *
7440 CGObjCNonFragileABIMac::EmitLoadOfClassRef(CodeGenFunction &CGF,
7441  const ObjCInterfaceDecl *ID,
7442  llvm::GlobalVariable *Entry) {
7443  if (ID && ID->hasAttr<ObjCClassStubAttr>()) {
7444  // Classrefs pointing at Objective-C stub classes must be loaded by calling
7445  // a special runtime function.
7446  return CGF.EmitRuntimeCall(
7447  ObjCTypes.getLoadClassrefFn(), Entry, "load_classref_result");
7448  }
7449 
7450  CharUnits Align = CGF.getPointerAlign();
7451  return CGF.Builder.CreateAlignedLoad(Entry, Align);
7452 }
7453 
7454 llvm::Value *
7455 CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
7456  IdentifierInfo *II,
7457  const ObjCInterfaceDecl *ID) {
7458  llvm::GlobalVariable *&Entry = ClassReferences[II];
7459 
7460  if (!Entry) {
7461  llvm::Constant *ClassGV;
7462  if (ID) {
7463  ClassGV = GetClassGlobalForClassRef(ID);
7464  } else {
7465  ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(),
7467  assert(ClassGV->getType() == ObjCTypes.ClassnfABIPtrTy &&
7468  "classref was emitted with the wrong type?");
7469  }
7470 
7471  std::string SectionName =
7472  GetSectionName("__objc_classrefs", "regular,no_dead_strip");
7473  Entry = new llvm::GlobalVariable(
7474  CGM.getModule(), ClassGV->getType(), false,
7475  getLinkageTypeForObjCMetadata(CGM, SectionName), ClassGV,
7476  "OBJC_CLASSLIST_REFERENCES_$_");
7477  Entry->setAlignment(CGF.getPointerAlign().getAsAlign());
7478  if (!ID || !ID->hasAttr<ObjCClassStubAttr>())
7479  Entry->setSection(SectionName);
7480 
7481  CGM.addCompilerUsedGlobal(Entry);
7482  }
7483 
7484  return EmitLoadOfClassRef(CGF, ID, Entry);
7485 }
7486 
7487 llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
7488  const ObjCInterfaceDecl *ID) {
7489  // If the class has the objc_runtime_visible attribute, we need to
7490  // use the Objective-C runtime to get the class.
7491  if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
7492  return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
7493 
7494  return EmitClassRefFromId(CGF, ID->getIdentifier(), ID);
7495 }
7496 
7497 llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
7498  CodeGenFunction &CGF) {
7499  IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
7500  return EmitClassRefFromId(CGF, II, nullptr);
7501 }
7502 
7503 llvm::Value *
7504 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
7505  const ObjCInterfaceDecl *ID) {
7506  llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
7507 
7508  if (!Entry) {
7509  llvm::Constant *ClassGV = GetClassGlobalForClassRef(ID);
7510  std::string SectionName =
7511  GetSectionName("__objc_superrefs", "regular,no_dead_strip");
7512  Entry = new llvm::GlobalVariable(
7513  CGM.getModule(), ClassGV->getType(), false,
7514  getLinkageTypeForObjCMetadata(CGM, SectionName), ClassGV,
7515  "OBJC_CLASSLIST_SUP_REFS_$_");
7516  Entry->setAlignment(CGF.getPointerAlign().getAsAlign());
7517  Entry->setSection(SectionName);
7518  CGM.addCompilerUsedGlobal(Entry);
7519  }
7520 
7521  return EmitLoadOfClassRef(CGF, ID, Entry);
7522 }
7523 
7524 /// EmitMetaClassRef - Return a Value * of the address of _class_t
7525 /// meta-data
7526 ///
7527 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
7528  const ObjCInterfaceDecl *ID,
7529  bool Weak) {
7530  CharUnits Align = CGF.getPointerAlign();
7531  llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
7532  if (!Entry) {
7533  auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition);
7534  std::string SectionName =
7535  GetSectionName("__objc_superrefs", "regular,no_dead_strip");
7536  Entry = new llvm::GlobalVariable(
7537  CGM.getModule(), ObjCTypes.ClassnfABIPtrTy, false,
7538  getLinkageTypeForObjCMetadata(CGM, SectionName), MetaClassGV,
7539  "OBJC_CLASSLIST_SUP_REFS_$_");
7540  Entry->setAlignment(Align.getAsAlign());
7541  Entry->setSection(SectionName);
7542  CGM.addCompilerUsedGlobal(Entry);
7543  }
7544 
7545  return CGF.Builder.CreateAlignedLoad(Entry, Align);
7546 }
7547 
7548 /// GetClass - Return a reference to the class for the given interface
7549 /// decl.
7550 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
7551  const ObjCInterfaceDecl *ID) {
7552  if (ID->isWeakImported()) {
7553  auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7554  (void)ClassGV;
7555  assert(!isa<llvm::GlobalVariable>(ClassGV) ||
7556  cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage());
7557  }
7558 
7559  return EmitClassRef(CGF, ID);
7560 }
7561 
7562 /// Generates a message send where the super is the receiver. This is
7563 /// a message send to self with special delivery semantics indicating
7564 /// which class's method should be called.
7566 CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
7567  ReturnValueSlot Return,
7568  QualType ResultType,
7569  Selector Sel,
7570  const ObjCInterfaceDecl *Class,
7571  bool isCategoryImpl,
7572  llvm::Value *Receiver,
7573  bool IsClassMessage,
7574  const CodeGen::CallArgList &CallArgs,
7575  const ObjCMethodDecl *Method) {
7576  // ...
7577  // Create and init a super structure; this is a (receiver, class)
7578  // pair we will pass to objc_msgSendSuper.
7579  Address ObjCSuper =
7580  CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
7581  "objc_super");
7582 
7583  llvm::Value *ReceiverAsObject =
7584  CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
7585  CGF.Builder.CreateStore(ReceiverAsObject,
7586  CGF.Builder.CreateStructGEP(ObjCSuper, 0));
7587 
7588  // If this is a class message the metaclass is passed as the target.
7590  if (IsClassMessage)
7591  Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported());
7592  else
7593  Target = EmitSuperClassRef(CGF, Class);
7594 
7595  // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
7596  // ObjCTypes types.
7597  llvm::Type *ClassTy =
7599  Target = CGF.Builder.CreateBitCast(Target, ClassTy);
7600  CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
7601 
7602  return (isVTableDispatchedSelector(Sel))
7603  ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7604  ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7605  true, CallArgs, Method)
7606  : EmitMessageSend(CGF, Return, ResultType, Sel,
7607  ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7608  true, CallArgs, Method, Class, ObjCTypes);
7609 }
7610 
7611 llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
7612  Selector Sel) {
7613  Address Addr = EmitSelectorAddr(Sel);
7614 
7615  llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr);
7616  LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7617  llvm::MDNode::get(VMContext, None));
7618  return LI;
7619 }
7620 
7621 Address CGObjCNonFragileABIMac::EmitSelectorAddr(Selector Sel) {
7622  llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
7623  CharUnits Align = CGM.getPointerAlign();
7624  if (!Entry) {
7625  llvm::Constant *Casted =
7626  llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
7627  ObjCTypes.SelectorPtrTy);
7628  std::string SectionName =
7629  GetSectionName("__objc_selrefs", "literal_pointers,no_dead_strip");
7630  Entry = new llvm::GlobalVariable(
7631  CGM.getModule(), ObjCTypes.SelectorPtrTy, false,
7632  getLinkageTypeForObjCMetadata(CGM, SectionName), Casted,
7633  "OBJC_SELECTOR_REFERENCES_");
7634  Entry->setExternallyInitialized(true);
7635  Entry->setSection(SectionName);
7636  Entry->setAlignment(Align.getAsAlign());
7637  CGM.addCompilerUsedGlobal(Entry);
7638  }
7639 
7640  return Address(Entry, Align);
7641 }
7642 
7643 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
7644 /// objc_assign_ivar (id src, id *dst, ptrdiff_t)
7645 ///
7646 void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
7647  llvm::Value *src,
7648  Address dst,
7649  llvm::Value *ivarOffset) {
7650  llvm::Type * SrcTy = src->getType();
7651  if (!isa<llvm::PointerType>(SrcTy)) {
7652  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7653  assert(Size <= 8 && "does not support size > 8");
7654  src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7655  : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7656  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7657  }
7658  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7659  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7660  llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
7661  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
7662 }
7663 
7664 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
7665 /// objc_assign_strongCast (id src, id *dst)
7666 ///
7667 void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
7668  CodeGen::CodeGenFunction &CGF,
7669  llvm::Value *src, Address dst) {
7670  llvm::Type * SrcTy = src->getType();
7671  if (!isa<llvm::PointerType>(SrcTy)) {
7672  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7673  assert(Size <= 8 && "does not support size > 8");
7674  src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7675  : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7676  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7677  }
7678  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7679  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7680  llvm::Value *args[] = { src, dst.getPointer() };
7681  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
7682  args, "weakassign");
7683 }
7684 
7685 void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
7686  CodeGen::CodeGenFunction &CGF,
7687  Address DestPtr,
7688  Address SrcPtr,
7689  llvm::Value *Size) {
7690  SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
7691  DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
7692  llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), Size };
7693  CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
7694 }
7695 
7696 /// EmitObjCWeakRead - Code gen for loading value of a __weak
7697 /// object: objc_read_weak (id *src)
7698 ///
7699 llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
7700  CodeGen::CodeGenFunction &CGF,
7701  Address AddrWeakObj) {
7702  llvm::Type *DestTy = AddrWeakObj.getElementType();
7703  AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
7704  llvm::Value *read_weak =
7705  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
7706  AddrWeakObj.getPointer(), "weakread");
7707  read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
7708  return read_weak;
7709 }
7710 
7711 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
7712 /// objc_assign_weak (id src, id *dst)
7713 ///
7714 void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
7715  llvm::Value *src, Address dst) {
7716  llvm::Type * SrcTy = src->getType();
7717  if (!isa<llvm::PointerType>(SrcTy)) {
7718  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7719  assert(Size <= 8 && "does not support size > 8");
7720  src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7721  : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7722  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7723  }
7724  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7725  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7726  llvm::Value *args[] = { src, dst.getPointer() };
7727  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
7728  args, "weakassign");
7729 }
7730 
7731 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
7732 /// objc_assign_global (id src, id *dst)
7733 ///
7734 void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
7735  llvm::Value *src, Address dst,
7736  bool threadlocal) {
7737  llvm::Type * SrcTy = src->getType();
7738  if (!isa<llvm::PointerType>(SrcTy)) {
7739  unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7740  assert(Size <= 8 && "does not support size > 8");
7741  src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7742  : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7743  src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7744  }
7745  src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7746  dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7747  llvm::Value *args[] = { src, dst.getPointer() };
7748  if (!threadlocal)
7749  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
7750  args, "globalassign");
7751  else
7752  CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
7753  args, "threadlocalassign");
7754 }
7755 
7756 void
7757 CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
7758  const ObjCAtSynchronizedStmt &S) {
7759  EmitAtSynchronizedStmt(CGF, S, ObjCTypes.getSyncEnterFn(),
7760  ObjCTypes.getSyncExitFn());
7761 }
7762 
7763 llvm::Constant *
7764 CGObjCNonFragileABIMac::GetEHType(QualType T) {
7765  // There's a particular fixed type info for 'id'.
7766  if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
7767  auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
7768  if (!IDEHType) {
7769  IDEHType =
7770  new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7771  llvm::GlobalValue::ExternalLinkage, nullptr,
7772  "OBJC_EHTYPE_id");
7773  if (CGM.getTriple().isOSBinFormatCOFF())
7774  IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id"));
7775  }
7776  return IDEHType;
7777  }
7778 
7779  // All other types should be Objective-C interface pointer types.
7780  const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
7781  assert(PT && "Invalid @catch type.");
7782 
7783  const ObjCInterfaceType *IT = PT->getInterfaceType();
7784  assert(IT && "Invalid @catch type.");
7785 
7786  return GetInterfaceEHType(IT->getDecl(), NotForDefinition);
7787 }
7788 
7789 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
7790  const ObjCAtTryStmt &S) {
7791  EmitTryCatchStmt(CGF, S, ObjCTypes.getObjCBeginCatchFn(),
7792  ObjCTypes.getObjCEndCatchFn(),
7793  ObjCTypes.getExceptionRethrowFn());
7794 }
7795 
7796 /// EmitThrowStmt - Generate code for a throw statement.
7797 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
7798  const ObjCAtThrowStmt &S,
7799  bool ClearInsertionPoint) {
7800  if (const Expr *ThrowExpr = S.getThrowExpr()) {
7801  llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
7802  Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7803  llvm::CallBase *Call =
7804  CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception);
7805  Call->setDoesNotReturn();
7806  } else {
7807  llvm::CallBase *Call =
7808  CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn());
7809  Call->setDoesNotReturn();
7810  }
7811 
7812  CGF.Builder.CreateUnreachable();
7813  if (ClearInsertionPoint)
7814  CGF.Builder.ClearInsertionPoint();
7815 }
7816 
7817 llvm::Constant *
7818 CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
7819  ForDefinition_t IsForDefinition) {
7820  llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
7821  StringRef ClassName = ID->getObjCRuntimeNameAsString();
7822 
7823  // If we don't need a definition, return the entry if found or check
7824  // if we use an external reference.
7825  if (!IsForDefinition) {
7826  if (Entry)
7827  return Entry;
7828 
7829  // If this type (or a super class) has the __objc_exception__
7830  // attribute, emit an external reference.
7831  if (hasObjCExceptionAttribute(CGM.getContext(), ID)) {
7832  std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str();
7833  Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
7834  false, llvm::GlobalValue::ExternalLinkage,
7835  nullptr, EHTypeName);
7836  CGM.setGVProperties(Entry, ID);
7837  return Entry;
7838  }
7839  }
7840 
7841  // Otherwise we need to either make a new entry or fill in the initializer.
7842  assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
7843 
7844  std::string VTableName = "objc_ehtype_vtable";
7845  auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName);
7846  if (!VTableGV) {
7847  VTableGV =
7848  new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false,
7849  llvm::GlobalValue::ExternalLinkage, nullptr,
7850  VTableName);
7851  if (CGM.getTriple().isOSBinFormatCOFF())
7852  VTableGV->setDLLStorageClass(getStorage(CGM, VTableName));
7853  }
7854 
7855  llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
7856  ConstantInitBuilder builder(CGM);
7857  auto values = builder.beginStruct(ObjCTypes.EHTypeTy);
7858  values.add(
7859  llvm::ConstantExpr::getInBoundsGetElementPtr(VTableGV->getValueType(),
7860  VTableGV, VTableIdx));
7861  values.add(GetClassName(ClassName));
7862  values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition));
7863 
7864  llvm::GlobalValue::LinkageTypes L = IsForDefinition
7865  ? llvm::GlobalValue::ExternalLinkage
7866  : llvm::GlobalValue::WeakAnyLinkage;
7867  if (Entry) {
7868  values.finishAndSetAsInitializer(Entry);
7869  Entry->setAlignment(CGM.getPointerAlign().getAsAlign());
7870  } else {
7871  Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName,
7872  CGM.getPointerAlign(),
7873  /*constant*/ false,
7874  L);
7875  if (hasObjCExceptionAttribute(CGM.getContext(), ID))
7876  CGM.setGVProperties(Entry, ID);
7877  }
7878  assert(Entry->getLinkage() == L);
7879 
7880  if (!CGM.getTriple().isOSBinFormatCOFF())
7881  if (ID->getVisibility() == HiddenVisibility)
7882  Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7883 
7884  if (IsForDefinition)
7885  if (CGM.getTriple().isOSBinFormatMachO())
7886  Entry->setSection("__DATA,__objc_const");
7887 
7888  return Entry;
7889 }
7890 
7891 /* *** */
7892 
7893 CodeGen::CGObjCRuntime *
7894 CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
7895  switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
7896  case ObjCRuntime::FragileMacOSX:
7897  return new CGObjCMac(CGM);
7898 
7899  case ObjCRuntime::MacOSX:
7900  case ObjCRuntime::iOS:
7901  case ObjCRuntime::WatchOS:
7902  return new CGObjCNonFragileABIMac(CGM);
7903 
7904  case ObjCRuntime::GNUstep:
7905  case ObjCRuntime::GCC:
7906  case ObjCRuntime::ObjFW:
7907  llvm_unreachable("these runtimes are not Mac runtimes");
7908  }
7909  llvm_unreachable("bad runtime");
7910 }
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
Definition: CGCall.cpp:653
bool isAggregate() const
Definition: CGValue.h:54
const llvm::DataLayout & getDataLayout() const
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:359
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")
Definition: CGBuilder.h:178
Defines the clang::ASTContext interface.
QualType withConst() const
Retrieves a version of this type with const applied.
bool isClassMethod() const
Definition: DeclObjC.h:431
const Capture & getCapture(const VarDecl *var) const
Definition: CGBlocks.h:270
llvm::IntegerType * IntTy
int
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:59
CharUnits BlockHeaderForcedGapOffset
Definition: CGBlocks.h:255
bool isObjCQualifiedIdType() const
True if this is equivalent to &#39;id.
Definition: Type.h:6030
Smart pointer class that efficiently represents Objective-C method names.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1874
Class implementation was compiled under ARC.
Definition: CGObjCMac.cpp:3490
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2614
CanQualType VoidPtrTy
Definition: ASTContext.h:1044
A (possibly-)qualified type.
Definition: Type.h:654
bool isBlockPointerType() const
Definition: Type.h:6512
bool ReturnTypeUsesSRet(const CGFunctionInfo &FI)
Return true iff the given type uses &#39;sret&#39; when used as a return type.
Definition: CGCall.cpp:1512
bool isArrayType() const
Definition: Type.h:6570
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1155
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
llvm::LLVMContext & getLLVMContext()
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
The standard implementation of ConstantInitBuilder used in Clang.
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
Stmt - This represents one statement.
Definition: Stmt.h:66
const ObjCAtFinallyStmt * getFinallyStmt() const
Retrieve the @finally statement, if any.
Definition: StmtObjC.h:235
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:994
Implements runtime-specific code generation functions.
Definition: CGObjCRuntime.h:63
bool isRecordType() const
Definition: Type.h:6594
const ASTRecordLayout & getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const
Get or compute information about the layout of the specified Objective-C implementation.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
static llvm::GlobalValue::LinkageTypes getLinkageTypeForObjCMetadata(CodeGenModule &CGM, StringRef Section)
Definition: CGObjCMac.cpp:1866
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
static void add(Kind k)
Definition: DeclBase.cpp:193
Is a meta-class.
Definition: CGObjCMac.cpp:3454
StringRef P
all_protocol_iterator all_referenced_protocol_begin() const
Definition: DeclObjC.h:1443
void EmitAutoVarDecl(const VarDecl &D)
EmitAutoVarDecl - Emit an auto variable declaration.
Definition: CGDecl.cpp:1281
Has a non-trivial constructor or destructor.
Definition: CGObjCMac.cpp:3457
The base class of the type hierarchy.
Definition: Type.h:1450
Represents Objective-C&#39;s @throw statement.
Definition: StmtObjC.h:332
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2889
bool hasDestructors() const
Do any of the ivars of this class (not counting its base classes) require non-trivial destruction...
Definition: DeclObjC.h:2673
static bool hasObjCExceptionAttribute(ASTContext &Context, const ObjCInterfaceDecl *OID)
hasObjCExceptionAttribute - Return true if this class or any super class has the objc_exception attri...
Definition: CGObjCMac.cpp:1856
static Qualifiers::GC GetGCAttrTypeForType(ASTContext &Ctx, QualType FQT, bool pointee=false)
Definition: CGObjCMac.cpp:2281
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
unsigned getCharWidth() const
Definition: TargetInfo.h:383
param_const_iterator param_end() const
Definition: DeclObjC.h:353
Is a root class.
Definition: CGObjCMac.cpp:3475
Address GetAddrOfLocalVar(const VarDecl *VD)
GetAddrOfLocalVar - Return the address of a local variable.
CanQualType getCanonicalParamType(QualType T) const
Return the canonical parameter type corresponding to the specific potentially non-canonical one...
Represents a variable declaration or definition.
Definition: Decl.h:820
Objects with "hidden" visibility are not seen by the dynamic linker.
Definition: Visibility.h:36
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7002
llvm::GlobalVariable * finishAndCreateGlobal(As &&...args)
Given that this builder was created by beginning an array or struct directly on a ConstantInitBuilder...
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
QualType getObjCClassType() const
Represents the Objective-C Class type.
Definition: ASTContext.h:1896
llvm::Value * getPointer() const
Definition: Address.h:37
Defines the Objective-C statement AST node classes.
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
protocol_range protocols() const
Definition: DeclObjC.h:2143
Represents a parameter to a function.
Definition: Decl.h:1595
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:23
void add(RValue rvalue, QualType type)
Definition: CGCall.h:285
A jump destination is an abstract label, branching to which may require a jump out through normal cle...
llvm::Value * EmitObjCThrowOperand(const Expr *expr)
Definition: CGObjC.cpp:3306
Class implementation was compiled under ARC.
Definition: CGObjCMac.cpp:3463
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:244
Represents a struct/union/class.
Definition: Decl.h:3748
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:361
One of these records is kept for each identifier that is lexed.
Represents a class type in Objective C.
Definition: Type.h:5694
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:168
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:344
field_range fields() const
Definition: Decl.h:3963
Class has non-trivial destructors, but zero-initialization is okay.
Definition: CGObjCMac.cpp:3493
bool isObjCIdType() const
Definition: Type.h:6651
Represents a member of a struct/union/class.
Definition: Decl.h:2729
protocol_iterator protocol_begin() const
Definition: DeclObjC.h:2147
MethodListType
Definition: CGObjCMac.cpp:1139
bool Zero(InterpState &S, CodePtr OpPC)
Definition: Interp.h:812
method_range methods() const
Definition: DeclObjC.h:1051
StringRef getObjCRuntimeNameAsString() const
Produce a name to be used for protocol&#39;s metadata.
Definition: DeclObjC.cpp:1986
std::string getNameAsString() const
Get the name of the class associated with this interface.
Definition: DeclObjC.h:2695
Class implementation was compiled under MRC and has MRC weak ivars.
Definition: CGObjCMac.cpp:3497
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c-base.h:40
prop_range properties() const
Definition: DeclObjC.h:1002
int Category
Definition: Format.cpp:1828
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
bool isObjCQualifiedClassType() const
Definition: Type.h:6645
IdentifierTable & Idents
Definition: ASTContext.h:580
Has the exception attribute.
Definition: CGObjCMac.cpp:3484
static std::string getBlockLayoutInfoString(const SmallVectorImpl< CGObjCCommonMac::RUN_SKIP > &RunSkipBlockVars, bool HasCopyDisposeHelpers)
Definition: CGObjCMac.cpp:2895
bool isUnarySelector() const
Objects with "default" visibility are seen by the dynamic linker and act like normal objects...
Definition: Visibility.h:45
Represents Objective-C&#39;s @catch statement.
Definition: StmtObjC.h:77
bool isDirectMethod() const
True if the method is tagged as objc_direct.
Definition: DeclObjC.cpp:826
static bool isWeakLinkedClass(const ObjCInterfaceDecl *ID)
Definition: CGObjCMac.cpp:2142
bool hasNonZeroConstructors() const
Do any of the ivars of this class (not counting its base classes) require construction other than zer...
Definition: DeclObjC.h:2668
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2807
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition: ObjCRuntime.h:81
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:983
const Expr * getThrowExpr() const
Definition: StmtObjC.h:344
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
const BlockDecl * getBlockDecl() const
Definition: CGBlocks.h:280
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
Definition: CharUnits.h:183
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
static llvm::GlobalVariable * finishAndCreateGlobal(ConstantInitBuilder::StructBuilder &Builder, const llvm::Twine &Name, CodeGenModule &CGM)
A helper function to create an internal or private global variable.
Definition: CGObjCMac.cpp:1875
Selector GetNullarySelector(StringRef name, ASTContext &Ctx)
Utility function for constructing a nullary selector.
Definition: ASTContext.h:3063
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr or CxxCtorInitializer) selects the name&#39;s to...
QualType getObjCClassRedefinitionType() const
Retrieve the type that Class has been defined to, which may be different from the built-in Class if C...
Definition: ASTContext.h:1674
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
Definition: DeclObjC.h:2224
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:4031
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void addCompilerUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.compiler.used metadata.
void ForceCleanup(std::initializer_list< llvm::Value **> ValuesToReload={})
Force the emission of cleanups now, instead of waiting until this object is destroyed.
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2078
llvm::Constant * CreateRuntimeVariable(llvm::Type *Ty, StringRef Name)
Create a new runtime global variable with the specified type and name.
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
Definition: CGExpr.cpp:106
Represents an ObjC class declaration.
Definition: DeclObjC.h:1186
QualType getReturnType() const
Definition: DeclObjC.h:324
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5930
Address NormalCleanupDest
i32s containing the indexes of the cleanup destinations.
all_protocol_iterator all_referenced_protocol_end() const
Definition: DeclObjC.h:1456
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition: CGValue.h:71
QualType getObjCProtoType() const
Retrieve the type of the Objective-C Protocol class.
Definition: ASTContext.h:1920
ObjCMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclObjC.cpp:957
This object can be modified without requiring retains or releases.
Definition: Type.h:164
#define NULL
const ObjCAtCatchStmt * getCatchStmt(unsigned I) const
Retrieve a @catch statement.
Definition: StmtObjC.h:217
bool hasAttr() const
Definition: DeclBase.h:542
bool isValid() const
Definition: Address.h:35
StringRef getString() const
Definition: Expr.h:1794
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
void addFrom(const CallArgList &other)
Add all the arguments from another CallArgList to this one.
Definition: CGCall.h:294
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
CGBlockInfo - Information to generate a block literal.
Definition: CGBlocks.h:152
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:39
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
static llvm::StringMapEntry< llvm::GlobalVariable * > & GetConstantStringEntry(llvm::StringMap< llvm::GlobalVariable *> &Map, const StringLiteral *Literal, unsigned &StringLength)
Definition: CGObjCMac.cpp:1958
bool hasDefinition() const
Determine whether this protocol has a definition.
Definition: DeclObjC.h:2212
unsigned Offset
Definition: Format.cpp:1827
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:38
llvm::CallingConv::ID getRuntimeCC() const
bool isObjCGCStrong() const
true when Type is objc&#39;s strong.
Definition: Type.h:1075
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4037
This represents one expression.
Definition: Expr.h:108
Defines the clang::LangOptions interface.
static Address invalid()
Definition: Address.h:34
std::string Label
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
Definition: CGValue.h:66
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7067
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:133
#define V(N, I)
Definition: ASTContext.h:2941
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Has hidden visibility.
Definition: CGObjCMac.cpp:3460
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
bool isObjCClassType() const
Definition: Type.h:6657
bool isObjCIdType() const
True if this is equivalent to the &#39;id&#39; type, i.e.
Definition: Type.h:6013
Represents Objective-C&#39;s @synchronized statement.
Definition: StmtObjC.h:277
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:337
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
llvm::LLVMContext & getLLVMContext()
bool needsCopyDisposeHelpers() const
Definition: CGBlocks.h:290
bool ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI)
Return true iff the given type uses an argument slot when &#39;sret&#39; is used as a return type...
Definition: CGCall.cpp:1517
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:257
propimpl_range property_impls() const
Definition: DeclObjC.h:2481
bool isInstanceMethod() const
Definition: DeclObjC.h:423
static llvm::Constant * getConstantGEP(llvm::LLVMContext &VMContext, llvm::GlobalVariable *C, unsigned idx0, unsigned idx1)
getConstantGEP() - Help routine to construct simple GEPs.
Definition: CGObjCMac.cpp:1844
unsigned getNumArgs() const
const TargetInfo & getTarget() const
Selector getSelector() const
Definition: DeclObjC.h:322
float __ovld __cnfn length(float p)
Return the length of vector p, i.e., sqrt(p.x2 + p.y 2 + ...)
bool isUnionType() const
Definition: Type.cpp:527
const LangOptions & getLangOpts() const
ASTContext & getContext() const
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:415
(Obsolete) ARC-specific: this class has a .release_ivars method
Definition: CGObjCMac.cpp:3487
CanQualType getCanonicalTypeUnqualified() const
The l-value was considered opaque, so the alignment was determined from a type.
RecordDecl * getDecl() const
Definition: Type.h:4505
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:190
There is no lifetime qualification on this type.
Definition: Type.h:160
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:141
std::string getAsString() const
Derive the full selector name (e.g.
QualType getObjCIdRedefinitionType() const
Retrieve the type that id has been defined to, which may be different from the built-in id if id has ...
Definition: ASTContext.h:1661
SelectorTable & Selectors
Definition: ASTContext.h:581
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:171
Kind
bool ReturnTypeUsesFPRet(QualType ResultType)
Return true iff the given type uses &#39;fpret&#39; when used as a return type.
Definition: CGCall.cpp:1522
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go...
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
Definition: CGObjC.cpp:2246
const Stmt * getCatchBody() const
Definition: StmtObjC.h:93
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
llvm::StructType * StructureType
Definition: CGBlocks.h:245
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **callOrInvoke, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type, and using the given argument list which specifies both the LLVM arguments and the types they were derived from.
Definition: CGCall.cpp:3814
SmallVector< llvm::Value *, 8 > ObjCEHValueStack
ObjCEHValueStack - Stack of Objective-C exception values, used for rethrows.
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
Definition: Decl.h:266
void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const
Set visibility, dllimport/dllexport and dso_local.
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C &#39;SEL&#39; type.
Definition: ASTContext.h:1884
const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)
Objective-C methods are C functions with some implicit parameters.
Definition: CGCall.cpp:458
void EmitStmt(const Stmt *S, ArrayRef< const Attr *> Attrs=None)
EmitStmt - Emit the code for the statement.
Definition: CGStmt.cpp:45
static void PushProtocolProperties(llvm::SmallPtrSet< const IdentifierInfo *, 16 > &PropertySet, SmallVectorImpl< const ObjCPropertyDecl *> &Properties, const ObjCProtocolDecl *Proto, bool IsClassProperty)
Definition: CGObjCMac.cpp:3244
static bool hasMRCWeakIvars(CodeGenModule &CGM, const ObjCImplementationDecl *ID)
For compatibility, we only want to set the "HasMRCWeakIvars" flag (and actually fill in a layout stri...
Definition: CGObjCMac.cpp:3518
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2294
CanQualType VoidTy
Definition: ASTContext.h:1016
NonFragileClassFlags
Definition: CGObjCMac.cpp:3470
static bool hasWeakMember(QualType type)
Definition: CGObjCMac.cpp:3500
bool isObjCObjectPointerType() const
Definition: Type.h:6618
An aligned address.
Definition: Address.h:24
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:741
Class implementation was compiled under MRC and has MRC weak ivars.
Definition: CGObjCMac.cpp:3467
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
Definition: DeclObjC.h:1824
All available information about a concrete callee.
Definition: CGCall.h:66
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:398
constexpr XRayInstrMask None
Definition: XRayInstr.h:37
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
Assigning into this object requires a lifetime extension.
Definition: Type.h:177
unsigned getPreferredTypeAlign(const Type *T) const
Return the "preferred" alignment of the specified type T for the current target, in bits...
bool ReturnTypeUsesFP2Ret(QualType ResultType)
Return true iff the given type uses &#39;fp2ret&#39; when used as a return type.
Definition: CGCall.cpp:1539
ObjCImplementationDecl * getImplementation() const
Definition: DeclObjC.cpp:1574
FragileClassFlags
Definition: CGObjCMac.cpp:3449
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
Definition: DeclBase.cpp:670
ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)
Returns a pointer to a character array containing the literal and a terminating &#39;\0&#39; character...
StringRef getName() const
Return the actual identifier string.
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1992
bool isObjCGCWeak() const
true when Type is objc&#39;s weak.
Definition: Type.h:1070
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:59
CanQualType CharTy
Definition: ASTContext.h:1018
This class organizes the cross-function state that is used while generating LLVM code.
protocol_iterator protocol_end() const
Definition: DeclObjC.h:2154
StructBuilder beginStruct(llvm::StructType *ty=nullptr)
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2454
static void addIfPresent(llvm::DenseSet< llvm::Value *> &S, Address V)
Definition: CGObjCMac.cpp:4449
Dataflow Directional Tag Classes.
CharUnits getSize() const
getSize - Get the record size in characters.
Definition: RecordLayout.h:183
static RValue getComplex(llvm::Value *V1, llvm::Value *V2)
Definition: CGValue.h:93
ArrayRef< Capture > captures() const
Definition: Decl.h:4164
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:90
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:69
int printf(__constant const char *st,...) __attribute__((format(printf
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5992
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)
Create or return a runtime function declaration with the specified type and name. ...
const ObjCInterfaceDecl * getContainingInterface() const
Return the class interface that this ivar is logically contained in; this is either the interface whe...
Definition: DeclObjC.cpp:1815
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:107
llvm::Module & getModule() const
Apparently: is not a meta-class.
Definition: CGObjCMac.cpp:3451
JumpDest ReturnBlock
ReturnBlock - Unified return block.
Represents a pointer to an Objective C object.
Definition: Type.h:5951
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2566
Has hidden visibility.
Definition: CGObjCMac.cpp:3481
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4495
StringRef getObjCRuntimeNameAsString() const
Produce a name to be used for class&#39;s metadata.
Definition: DeclObjC.cpp:1558
StructBuilder beginStruct(llvm::StructType *structTy=nullptr)
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:51
This class organizes the cross-module state that is used while lowering AST types to LLVM types...
Definition: CodeGenTypes.h:59
protocol_iterator protocol_begin() const
Definition: DeclObjC.h:2374
bool isObjCQualifiedIdType() const
Definition: Type.h:6639
param_const_iterator param_begin() const
Definition: DeclObjC.h:349
StringRef getObjCRuntimeNameAsString() const
Produce a name to be used for class&#39;s metadata.
Definition: DeclObjC.cpp:1566
Represents Objective-C&#39;s @finally statement.
Definition: StmtObjC.h:127
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:31
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:473
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2104
const Decl * CurFuncDecl
CurFuncDecl - Holds the Decl for the current outermost non-closure context.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2305
Is a meta-class.
Definition: CGObjCMac.cpp:3472
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Reading or writing from this object requires a barrier call.
Definition: Type.h:174
Selector GetUnarySelector(StringRef name, ASTContext &Ctx)
Utility function for constructing an unary selector.
Definition: ASTContext.h:3069
bool isVoidType() const
Definition: Type.h:6777
llvm::Type * ConvertType(QualType T)
A specialization of Address that requires the address to be an LLVM Constant.
Definition: Address.h:74
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1959
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
A helper class of ConstantInitBuilder, used for building constant struct initializers.
ASTImporterLookupTable & LT
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
ImplicitParamDecl * getCmdDecl() const
Definition: DeclObjC.h:417
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:60
CharUnits BlockHeaderForcedGapSize
Definition: CGBlocks.h:258
Has a non-trivial constructor or destructor.
Definition: CGObjCMac.cpp:3478
Represents Objective-C&#39;s @try ... @catch ... @finally statement.
Definition: StmtObjC.h:165
protocol_iterator protocol_end() const
Definition: DeclObjC.h:2378
unsigned getNumCatchStmts() const
Retrieve the number of @catch statements in this try-catch-finally block.
Definition: StmtObjC.h:214
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1711
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:250
StringRef getName() const
getName - Get the name of identifier for the class interface associated with this implementation as a...
Definition: DeclObjC.h:2687
ObjCLabelType
Definition: CGObjCMac.cpp:758
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
bool isUnion() const
Definition: Decl.h:3407
Visibility getVisibility() const
Determines the visibility of this entity.
Definition: Decl.h:373
const internal::VariadicDynCastAllOfMatcher< Decl, BlockDecl > blockDecl
Matches block declarations.
const VarDecl * getCatchParamDecl() const
Definition: StmtObjC.h:97
void EmitBranchThroughCleanup(JumpDest Dest)
EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...
Definition: CGCleanup.cpp:1044
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
QualType getType() const
Definition: Decl.h:630
std::string ObjCConstantStringClass
Definition: LangOptions.h:261
LValue - This represents an lvalue references.
Definition: CGValue.h:167
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:146
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1617
CanQualType BoolTy
Definition: ASTContext.h:1017
AccessControl getAccessControl() const
Definition: DeclObjC.h:1998
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
ObjCProtocolList::iterator protocol_iterator
Definition: DeclObjC.h:2140
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:261
#define not
Definition: iso646.h:19
const LangOptions & getLangOpts() const
Definition: ASTContext.h:724
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
Definition: CGCleanup.cpp:644
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2513
A helper class of ConstantInitBuilder, used for building constant array initializers.
Abstract information about a function or function prototype.
Definition: CGCall.h:44
bool isScalar() const
Definition: CGValue.h:52
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:368
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2743
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1080
ObjCCategoryDecl * FindCategoryDeclaration(IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
Definition: DeclObjC.cpp:1689
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition: CGCall.cpp:1556
const llvm::Triple & getTriple() const