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