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