contrib/llvm/tools/clang/lib/CodeGen/CGObjCMac.cpp

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