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