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