granicus.if.org Git - clang/blob - lib/CodeGen/CGObjCMac.cpp

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