contrib/llvm-project/clang/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(1);
2022   Fields.addBitCast(GV, CGM.Int8PtrTy);
2023
2024   // String length.
2025   Fields.addInt(CGM.IntTy, StringLength);
2026
2027   // The struct.
2028   CharUnits Alignment = CGM.getPointerAlign();
2029   GV = Fields.finishAndCreateGlobal("_unnamed_nsstring_", Alignment,
2030                                     /*constant*/ true,
2031                                     llvm::GlobalVariable::PrivateLinkage);
2032   const char *NSStringSection = "__OBJC,__cstring_object,regular,no_dead_strip";
2033   const char *NSStringNonFragileABISection =
2034       "__DATA,__objc_stringobj,regular,no_dead_strip";
2035   // FIXME. Fix section.
2036   GV->setSection(CGM.getLangOpts().ObjCRuntime.isNonFragile()
2037                      ? NSStringNonFragileABISection
2038                      : NSStringSection);
2039   Entry.second = GV;
2040
2041   return ConstantAddress(GV, Alignment);
2042 }
2043
2044 enum {
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       const ConstantArrayType *CArray =
2521         dyn_cast_or_null<ConstantArrayType>(Array);
2522       uint64_t ElCount = CArray->getSize().getZExtValue();
2523       assert(CArray && "only array with known element size is supported");
2524       FQT = CArray->getElementType();
2525       while (const ArrayType *Array = CGM.getContext().getAsArrayType(FQT)) {
2526         const ConstantArrayType *CArray =
2527           dyn_cast_or_null<ConstantArrayType>(Array);
2528         ElCount *= CArray->getSize().getZExtValue();
2529         FQT = CArray->getElementType();
2530       }
2531       if (FQT->isRecordType() && ElCount) {
2532         int OldIndex = RunSkipBlockVars.size() - 1;
2533         const RecordType *RT = FQT->getAs<RecordType>();
2534         BuildRCBlockVarRecordLayout(RT, BytePos + FieldOffset,
2535                                     HasUnion);
2536
2537         // Replicate layout information for each array element. Note that
2538         // one element is already done.
2539         uint64_t ElIx = 1;
2540         for (int FirstIndex = RunSkipBlockVars.size() - 1 ;ElIx < ElCount; ElIx++) {
2541           CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2542           for (int i = OldIndex+1; i <= FirstIndex; ++i)
2543             RunSkipBlockVars.push_back(
2544               RUN_SKIP(RunSkipBlockVars[i].opcode,
2545               RunSkipBlockVars[i].block_var_bytepos + Size*ElIx,
2546               RunSkipBlockVars[i].block_var_size));
2547         }
2548         continue;
2549       }
2550     }
2551     CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2552     if (IsUnion) {
2553       CharUnits UnionIvarSize = FieldSize;
2554       if (UnionIvarSize > MaxUnionSize) {
2555         MaxUnionSize = UnionIvarSize;
2556         MaxField = Field;
2557         MaxFieldOffset = FieldOffset;
2558       }
2559     } else {
2560       UpdateRunSkipBlockVars(false,
2561                              getBlockCaptureLifetime(FQT, ByrefLayout),
2562                              BytePos + FieldOffset,
2563                              FieldSize);
2564     }
2565   }
2566
2567   if (LastFieldBitfieldOrUnnamed) {
2568     if (LastFieldBitfieldOrUnnamed->isBitField()) {
2569       // Last field was a bitfield. Must update the info.
2570       uint64_t BitFieldSize
2571         = LastFieldBitfieldOrUnnamed->getBitWidthValue(CGM.getContext());
2572       unsigned UnsSize = (BitFieldSize / ByteSizeInBits) +
2573                         ((BitFieldSize % ByteSizeInBits) != 0);
2574       CharUnits Size = CharUnits::fromQuantity(UnsSize);
2575       Size += LastBitfieldOrUnnamedOffset;
2576       UpdateRunSkipBlockVars(false,
2577                              getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2578                                                      ByrefLayout),
2579                              BytePos + LastBitfieldOrUnnamedOffset,
2580                              Size);
2581     } else {
2582       assert(!LastFieldBitfieldOrUnnamed->getIdentifier() &&"Expected unnamed");
2583       // Last field was unnamed. Must update skip info.
2584       CharUnits FieldSize
2585         = CGM.getContext().getTypeSizeInChars(LastFieldBitfieldOrUnnamed->getType());
2586       UpdateRunSkipBlockVars(false,
2587                              getBlockCaptureLifetime(LastFieldBitfieldOrUnnamed->getType(),
2588                                                      ByrefLayout),
2589                              BytePos + LastBitfieldOrUnnamedOffset,
2590                              FieldSize);
2591     }
2592   }
2593
2594   if (MaxField)
2595     UpdateRunSkipBlockVars(false,
2596                            getBlockCaptureLifetime(MaxField->getType(), ByrefLayout),
2597                            BytePos + MaxFieldOffset,
2598                            MaxUnionSize);
2599 }
2600
2601 void CGObjCCommonMac::BuildRCBlockVarRecordLayout(const RecordType *RT,
2602                                                   CharUnits BytePos,
2603                                                   bool &HasUnion,
2604                                                   bool ByrefLayout) {
2605   const RecordDecl *RD = RT->getDecl();
2606   SmallVector<const FieldDecl*, 16> Fields(RD->fields());
2607   llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
2608   const llvm::StructLayout *RecLayout =
2609     CGM.getDataLayout().getStructLayout(cast<llvm::StructType>(Ty));
2610
2611   BuildRCRecordLayout(RecLayout, RD, Fields, BytePos, HasUnion, ByrefLayout);
2612 }
2613
2614 /// InlineLayoutInstruction - This routine produce an inline instruction for the
2615 /// block variable layout if it can. If not, it returns 0. Rules are as follow:
2616 /// If ((uintptr_t) layout) < (1 << 12), the layout is inline. In the 64bit world,
2617 /// an inline layout of value 0x0000000000000xyz is interpreted as follows:
2618 /// x captured object pointers of BLOCK_LAYOUT_STRONG. Followed by
2619 /// y captured object of BLOCK_LAYOUT_BYREF. Followed by
2620 /// z captured object of BLOCK_LAYOUT_WEAK. If any of the above is missing, zero
2621 /// replaces it. For example, 0x00000x00 means x BLOCK_LAYOUT_STRONG and no
2622 /// BLOCK_LAYOUT_BYREF and no BLOCK_LAYOUT_WEAK objects are captured.
2623 uint64_t CGObjCCommonMac::InlineLayoutInstruction(
2624                                     SmallVectorImpl<unsigned char> &Layout) {
2625   uint64_t Result = 0;
2626   if (Layout.size() <= 3) {
2627     unsigned size = Layout.size();
2628     unsigned strong_word_count = 0, byref_word_count=0, weak_word_count=0;
2629     unsigned char inst;
2630     enum BLOCK_LAYOUT_OPCODE opcode ;
2631     switch (size) {
2632       case 3:
2633         inst = Layout[0];
2634         opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2635         if (opcode == BLOCK_LAYOUT_STRONG)
2636           strong_word_count = (inst & 0xF)+1;
2637         else
2638           return 0;
2639         inst = Layout[1];
2640         opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2641         if (opcode == BLOCK_LAYOUT_BYREF)
2642           byref_word_count = (inst & 0xF)+1;
2643         else
2644           return 0;
2645         inst = Layout[2];
2646         opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2647         if (opcode == BLOCK_LAYOUT_WEAK)
2648           weak_word_count = (inst & 0xF)+1;
2649         else
2650           return 0;
2651         break;
2652
2653       case 2:
2654         inst = Layout[0];
2655         opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2656         if (opcode == BLOCK_LAYOUT_STRONG) {
2657           strong_word_count = (inst & 0xF)+1;
2658           inst = Layout[1];
2659           opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2660           if (opcode == BLOCK_LAYOUT_BYREF)
2661             byref_word_count = (inst & 0xF)+1;
2662           else if (opcode == BLOCK_LAYOUT_WEAK)
2663             weak_word_count = (inst & 0xF)+1;
2664           else
2665             return 0;
2666         }
2667         else if (opcode == BLOCK_LAYOUT_BYREF) {
2668           byref_word_count = (inst & 0xF)+1;
2669           inst = Layout[1];
2670           opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2671           if (opcode == BLOCK_LAYOUT_WEAK)
2672             weak_word_count = (inst & 0xF)+1;
2673           else
2674             return 0;
2675         }
2676         else
2677           return 0;
2678         break;
2679
2680       case 1:
2681         inst = Layout[0];
2682         opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2683         if (opcode == BLOCK_LAYOUT_STRONG)
2684           strong_word_count = (inst & 0xF)+1;
2685         else if (opcode == BLOCK_LAYOUT_BYREF)
2686           byref_word_count = (inst & 0xF)+1;
2687         else if (opcode == BLOCK_LAYOUT_WEAK)
2688           weak_word_count = (inst & 0xF)+1;
2689         else
2690           return 0;
2691         break;
2692
2693       default:
2694         return 0;
2695     }
2696
2697     // Cannot inline when any of the word counts is 15. Because this is one less
2698     // than the actual work count (so 15 means 16 actual word counts),
2699     // and we can only display 0 thru 15 word counts.
2700     if (strong_word_count == 16 || byref_word_count == 16 || weak_word_count == 16)
2701       return 0;
2702
2703     unsigned count =
2704       (strong_word_count != 0) + (byref_word_count != 0) + (weak_word_count != 0);
2705
2706     if (size == count) {
2707       if (strong_word_count)
2708         Result = strong_word_count;
2709       Result <<= 4;
2710       if (byref_word_count)
2711         Result += byref_word_count;
2712       Result <<= 4;
2713       if (weak_word_count)
2714         Result += weak_word_count;
2715     }
2716   }
2717   return Result;
2718 }
2719
2720 llvm::Constant *CGObjCCommonMac::getBitmapBlockLayout(bool ComputeByrefLayout) {
2721   llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2722   if (RunSkipBlockVars.empty())
2723     return nullPtr;
2724   unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2725   unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2726   unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2727
2728   // Sort on byte position; captures might not be allocated in order,
2729   // and unions can do funny things.
2730   llvm::array_pod_sort(RunSkipBlockVars.begin(), RunSkipBlockVars.end());
2731   SmallVector<unsigned char, 16> Layout;
2732
2733   unsigned size = RunSkipBlockVars.size();
2734   for (unsigned i = 0; i < size; i++) {
2735     enum BLOCK_LAYOUT_OPCODE opcode = RunSkipBlockVars[i].opcode;
2736     CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2737     CharUnits end_byte_pos = start_byte_pos;
2738     unsigned j = i+1;
2739     while (j < size) {
2740       if (opcode == RunSkipBlockVars[j].opcode) {
2741         end_byte_pos = RunSkipBlockVars[j++].block_var_bytepos;
2742         i++;
2743       }
2744       else
2745         break;
2746     }
2747     CharUnits size_in_bytes =
2748     end_byte_pos - start_byte_pos + RunSkipBlockVars[j-1].block_var_size;
2749     if (j < size) {
2750       CharUnits gap =
2751       RunSkipBlockVars[j].block_var_bytepos -
2752       RunSkipBlockVars[j-1].block_var_bytepos - RunSkipBlockVars[j-1].block_var_size;
2753       size_in_bytes += gap;
2754     }
2755     CharUnits residue_in_bytes = CharUnits::Zero();
2756     if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES) {
2757       residue_in_bytes = size_in_bytes % WordSizeInBytes;
2758       size_in_bytes -= residue_in_bytes;
2759       opcode = BLOCK_LAYOUT_NON_OBJECT_WORDS;
2760     }
2761
2762     unsigned size_in_words = size_in_bytes.getQuantity() / WordSizeInBytes;
2763     while (size_in_words >= 16) {
2764       // Note that value in imm. is one less that the actual
2765       // value. So, 0xf means 16 words follow!
2766       unsigned char inst = (opcode << 4) | 0xf;
2767       Layout.push_back(inst);
2768       size_in_words -= 16;
2769     }
2770     if (size_in_words > 0) {
2771       // Note that value in imm. is one less that the actual
2772       // value. So, we subtract 1 away!
2773       unsigned char inst = (opcode << 4) | (size_in_words-1);
2774       Layout.push_back(inst);
2775     }
2776     if (residue_in_bytes > CharUnits::Zero()) {
2777       unsigned char inst =
2778       (BLOCK_LAYOUT_NON_OBJECT_BYTES << 4) | (residue_in_bytes.getQuantity()-1);
2779       Layout.push_back(inst);
2780     }
2781   }
2782
2783   while (!Layout.empty()) {
2784     unsigned char inst = Layout.back();
2785     enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2786     if (opcode == BLOCK_LAYOUT_NON_OBJECT_BYTES || opcode == BLOCK_LAYOUT_NON_OBJECT_WORDS)
2787       Layout.pop_back();
2788     else
2789       break;
2790   }
2791
2792   uint64_t Result = InlineLayoutInstruction(Layout);
2793   if (Result != 0) {
2794     // Block variable layout instruction has been inlined.
2795     if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2796       if (ComputeByrefLayout)
2797         printf("\n Inline BYREF variable layout: ");
2798       else
2799         printf("\n Inline block variable layout: ");
2800       printf("0x0%" PRIx64 "", Result);
2801       if (auto numStrong = (Result & 0xF00) >> 8)
2802         printf(", BL_STRONG:%d", (int) numStrong);
2803       if (auto numByref = (Result & 0x0F0) >> 4)
2804         printf(", BL_BYREF:%d", (int) numByref);
2805       if (auto numWeak = (Result & 0x00F) >> 0)
2806         printf(", BL_WEAK:%d", (int) numWeak);
2807       printf(", BL_OPERATOR:0\n");
2808     }
2809     return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2810   }
2811
2812   unsigned char inst = (BLOCK_LAYOUT_OPERATOR << 4) | 0;
2813   Layout.push_back(inst);
2814   std::string BitMap;
2815   for (unsigned i = 0, e = Layout.size(); i != e; i++)
2816     BitMap += Layout[i];
2817
2818   if (CGM.getLangOpts().ObjCGCBitmapPrint) {
2819     if (ComputeByrefLayout)
2820       printf("\n Byref variable layout: ");
2821     else
2822       printf("\n Block variable layout: ");
2823     for (unsigned i = 0, e = BitMap.size(); i != e; i++) {
2824       unsigned char inst = BitMap[i];
2825       enum BLOCK_LAYOUT_OPCODE opcode = (enum BLOCK_LAYOUT_OPCODE) (inst >> 4);
2826       unsigned delta = 1;
2827       switch (opcode) {
2828         case BLOCK_LAYOUT_OPERATOR:
2829           printf("BL_OPERATOR:");
2830           delta = 0;
2831           break;
2832         case BLOCK_LAYOUT_NON_OBJECT_BYTES:
2833           printf("BL_NON_OBJECT_BYTES:");
2834           break;
2835         case BLOCK_LAYOUT_NON_OBJECT_WORDS:
2836           printf("BL_NON_OBJECT_WORD:");
2837           break;
2838         case BLOCK_LAYOUT_STRONG:
2839           printf("BL_STRONG:");
2840           break;
2841         case BLOCK_LAYOUT_BYREF:
2842           printf("BL_BYREF:");
2843           break;
2844         case BLOCK_LAYOUT_WEAK:
2845           printf("BL_WEAK:");
2846           break;
2847         case BLOCK_LAYOUT_UNRETAINED:
2848           printf("BL_UNRETAINED:");
2849           break;
2850       }
2851       // Actual value of word count is one more that what is in the imm.
2852       // field of the instruction
2853       printf("%d", (inst & 0xf) + delta);
2854       if (i < e-1)
2855         printf(", ");
2856       else
2857         printf("\n");
2858     }
2859   }
2860
2861   auto *Entry = CreateCStringLiteral(BitMap, ObjCLabelType::ClassName,
2862                                      /*ForceNonFragileABI=*/true,
2863                                      /*NullTerminate=*/false);
2864   return getConstantGEP(VMContext, Entry, 0, 0);
2865 }
2866
2867 static std::string getBlockLayoutInfoString(
2868     const SmallVectorImpl<CGObjCCommonMac::RUN_SKIP> &RunSkipBlockVars,
2869     bool HasCopyDisposeHelpers) {
2870   std::string Str;
2871   for (const CGObjCCommonMac::RUN_SKIP &R : RunSkipBlockVars) {
2872     if (R.opcode == CGObjCCommonMac::BLOCK_LAYOUT_UNRETAINED) {
2873       // Copy/dispose helpers don't have any information about
2874       // __unsafe_unretained captures, so unconditionally concatenate a string.
2875       Str += "u";
2876     } else if (HasCopyDisposeHelpers) {
2877       // Information about __strong, __weak, or byref captures has already been
2878       // encoded into the names of the copy/dispose helpers. We have to add a
2879       // string here only when the copy/dispose helpers aren't generated (which
2880       // happens when the block is non-escaping).
2881       continue;
2882     } else {
2883       switch (R.opcode) {
2884       case CGObjCCommonMac::BLOCK_LAYOUT_STRONG:
2885         Str += "s";
2886         break;
2887       case CGObjCCommonMac::BLOCK_LAYOUT_BYREF:
2888         Str += "r";
2889         break;
2890       case CGObjCCommonMac::BLOCK_LAYOUT_WEAK:
2891         Str += "w";
2892         break;
2893       default:
2894         continue;
2895       }
2896     }
2897     Str += llvm::to_string(R.block_var_bytepos.getQuantity());
2898     Str += "l" + llvm::to_string(R.block_var_size.getQuantity());
2899   }
2900   return Str;
2901 }
2902
2903 void CGObjCCommonMac::fillRunSkipBlockVars(CodeGenModule &CGM,
2904                                            const CGBlockInfo &blockInfo) {
2905   assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2906
2907   RunSkipBlockVars.clear();
2908   bool hasUnion = false;
2909
2910   unsigned WordSizeInBits = CGM.getTarget().getPointerWidth(0);
2911   unsigned ByteSizeInBits = CGM.getTarget().getCharWidth();
2912   unsigned WordSizeInBytes = WordSizeInBits/ByteSizeInBits;
2913
2914   const BlockDecl *blockDecl = blockInfo.getBlockDecl();
2915
2916   // Calculate the basic layout of the block structure.
2917   const llvm::StructLayout *layout =
2918   CGM.getDataLayout().getStructLayout(blockInfo.StructureType);
2919
2920   // Ignore the optional 'this' capture: C++ objects are not assumed
2921   // to be GC'ed.
2922   if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2923     UpdateRunSkipBlockVars(false, Qualifiers::OCL_None,
2924                            blockInfo.BlockHeaderForcedGapOffset,
2925                            blockInfo.BlockHeaderForcedGapSize);
2926   // Walk the captured variables.
2927   for (const auto &CI : blockDecl->captures()) {
2928     const VarDecl *variable = CI.getVariable();
2929     QualType type = variable->getType();
2930
2931     const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
2932
2933     // Ignore constant captures.
2934     if (capture.isConstant()) continue;
2935
2936     CharUnits fieldOffset =
2937        CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2938
2939     assert(!type->isArrayType() && "array variable should not be caught");
2940     if (!CI.isByRef())
2941       if (const RecordType *record = type->getAs<RecordType>()) {
2942         BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion);
2943         continue;
2944       }
2945     CharUnits fieldSize;
2946     if (CI.isByRef())
2947       fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2948     else
2949       fieldSize = CGM.getContext().getTypeSizeInChars(type);
2950     UpdateRunSkipBlockVars(CI.isByRef(), getBlockCaptureLifetime(type, false),
2951                            fieldOffset, fieldSize);
2952   }
2953 }
2954
2955 llvm::Constant *
2956 CGObjCCommonMac::BuildRCBlockLayout(CodeGenModule &CGM,
2957                                     const CGBlockInfo &blockInfo) {
2958   fillRunSkipBlockVars(CGM, blockInfo);
2959   return getBitmapBlockLayout(false);
2960 }
2961
2962 std::string CGObjCCommonMac::getRCBlockLayoutStr(CodeGenModule &CGM,
2963                                                  const CGBlockInfo &blockInfo) {
2964   fillRunSkipBlockVars(CGM, blockInfo);
2965   return getBlockLayoutInfoString(RunSkipBlockVars,
2966                                   blockInfo.needsCopyDisposeHelpers());
2967 }
2968
2969 llvm::Constant *CGObjCCommonMac::BuildByrefLayout(CodeGen::CodeGenModule &CGM,
2970                                                   QualType T) {
2971   assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
2972   assert(!T->isArrayType() && "__block array variable should not be caught");
2973   CharUnits fieldOffset;
2974   RunSkipBlockVars.clear();
2975   bool hasUnion = false;
2976   if (const RecordType *record = T->getAs<RecordType>()) {
2977     BuildRCBlockVarRecordLayout(record, fieldOffset, hasUnion, true /*ByrefLayout */);
2978     llvm::Constant *Result = getBitmapBlockLayout(true);
2979     if (isa<llvm::ConstantInt>(Result))
2980       Result = llvm::ConstantExpr::getIntToPtr(Result, CGM.Int8PtrTy);
2981     return Result;
2982   }
2983   llvm::Constant *nullPtr = llvm::Constant::getNullValue(CGM.Int8PtrTy);
2984   return nullPtr;
2985 }
2986
2987 llvm::Value *CGObjCMac::GenerateProtocolRef(CodeGenFunction &CGF,
2988                                             const ObjCProtocolDecl *PD) {
2989   // FIXME: I don't understand why gcc generates this, or where it is
2990   // resolved. Investigate. Its also wasteful to look this up over and over.
2991   LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
2992
2993   return llvm::ConstantExpr::getBitCast(GetProtocolRef(PD),
2994                                         ObjCTypes.getExternalProtocolPtrTy());
2995 }
2996
2997 void CGObjCCommonMac::GenerateProtocol(const ObjCProtocolDecl *PD) {
2998   // FIXME: We shouldn't need this, the protocol decl should contain enough
2999   // information to tell us whether this was a declaration or a definition.
3000   DefinedProtocols.insert(PD->getIdentifier());
3001
3002   // If we have generated a forward reference to this protocol, emit
3003   // it now. Otherwise do nothing, the protocol objects are lazily
3004   // emitted.
3005   if (Protocols.count(PD->getIdentifier()))
3006     GetOrEmitProtocol(PD);
3007 }
3008
3009 llvm::Constant *CGObjCCommonMac::GetProtocolRef(const ObjCProtocolDecl *PD) {
3010   if (DefinedProtocols.count(PD->getIdentifier()))
3011     return GetOrEmitProtocol(PD);
3012
3013   return GetOrEmitProtocolRef(PD);
3014 }
3015
3016 llvm::Value *CGObjCCommonMac::EmitClassRefViaRuntime(
3017                CodeGenFunction &CGF,
3018                const ObjCInterfaceDecl *ID,
3019                ObjCCommonTypesHelper &ObjCTypes) {
3020   llvm::FunctionCallee lookUpClassFn = ObjCTypes.getLookUpClassFn();
3021
3022   llvm::Value *className =
3023       CGF.CGM.GetAddrOfConstantCString(ID->getObjCRuntimeNameAsString())
3024         .getPointer();
3025   ASTContext &ctx = CGF.CGM.getContext();
3026   className =
3027       CGF.Builder.CreateBitCast(className,
3028                                 CGF.ConvertType(
3029                                   ctx.getPointerType(ctx.CharTy.withConst())));
3030   llvm::CallInst *call = CGF.Builder.CreateCall(lookUpClassFn, className);
3031   call->setDoesNotThrow();
3032   return call;
3033 }
3034
3035 /*
3036 // Objective-C 1.0 extensions
3037 struct _objc_protocol {
3038 struct _objc_protocol_extension *isa;
3039 char *protocol_name;
3040 struct _objc_protocol_list *protocol_list;
3041 struct _objc__method_prototype_list *instance_methods;
3042 struct _objc__method_prototype_list *class_methods
3043 };
3044
3045 See EmitProtocolExtension().
3046 */
3047 llvm::Constant *CGObjCMac::GetOrEmitProtocol(const ObjCProtocolDecl *PD) {
3048   llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
3049
3050   // Early exit if a defining object has already been generated.
3051   if (Entry && Entry->hasInitializer())
3052     return Entry;
3053
3054   // Use the protocol definition, if there is one.
3055   if (const ObjCProtocolDecl *Def = PD->getDefinition())
3056     PD = Def;
3057
3058   // FIXME: I don't understand why gcc generates this, or where it is
3059   // resolved. Investigate. Its also wasteful to look this up over and over.
3060   LazySymbols.insert(&CGM.getContext().Idents.get("Protocol"));
3061
3062   // Construct method lists.
3063   auto methodLists = ProtocolMethodLists::get(PD);
3064
3065   ConstantInitBuilder builder(CGM);
3066   auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
3067   values.add(EmitProtocolExtension(PD, methodLists));
3068   values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
3069   values.add(EmitProtocolList("OBJC_PROTOCOL_REFS_" + PD->getName(),
3070                               PD->protocol_begin(), PD->protocol_end()));
3071   values.add(methodLists.emitMethodList(this, PD,
3072                               ProtocolMethodLists::RequiredInstanceMethods));
3073   values.add(methodLists.emitMethodList(this, PD,
3074                               ProtocolMethodLists::RequiredClassMethods));
3075
3076   if (Entry) {
3077     // Already created, update the initializer.
3078     assert(Entry->hasPrivateLinkage());
3079     values.finishAndSetAsInitializer(Entry);
3080   } else {
3081     Entry = values.finishAndCreateGlobal("OBJC_PROTOCOL_" + PD->getName(),
3082                                          CGM.getPointerAlign(),
3083                                          /*constant*/ false,
3084                                          llvm::GlobalValue::PrivateLinkage);
3085     Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3086
3087     Protocols[PD->getIdentifier()] = Entry;
3088   }
3089   CGM.addCompilerUsedGlobal(Entry);
3090
3091   return Entry;
3092 }
3093
3094 llvm::Constant *CGObjCMac::GetOrEmitProtocolRef(const ObjCProtocolDecl *PD) {
3095   llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
3096
3097   if (!Entry) {
3098     // We use the initializer as a marker of whether this is a forward
3099     // reference or not. At module finalization we add the empty
3100     // contents for protocols which were referenced but never defined.
3101     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolTy,
3102                                      false, llvm::GlobalValue::PrivateLinkage,
3103                                      nullptr, "OBJC_PROTOCOL_" + PD->getName());
3104     Entry->setSection("__OBJC,__protocol,regular,no_dead_strip");
3105     // FIXME: Is this necessary? Why only for protocol?
3106     Entry->setAlignment(4);
3107   }
3108
3109   return Entry;
3110 }
3111
3112 /*
3113   struct _objc_protocol_extension {
3114   uint32_t size;
3115   struct objc_method_description_list *optional_instance_methods;
3116   struct objc_method_description_list *optional_class_methods;
3117   struct objc_property_list *instance_properties;
3118   const char ** extendedMethodTypes;
3119   struct objc_property_list *class_properties;
3120   };
3121 */
3122 llvm::Constant *
3123 CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
3124                                  const ProtocolMethodLists &methodLists) {
3125   auto optInstanceMethods =
3126     methodLists.emitMethodList(this, PD,
3127                                ProtocolMethodLists::OptionalInstanceMethods);
3128   auto optClassMethods =
3129     methodLists.emitMethodList(this, PD,
3130                                ProtocolMethodLists::OptionalClassMethods);
3131
3132   auto extendedMethodTypes =
3133     EmitProtocolMethodTypes("OBJC_PROTOCOL_METHOD_TYPES_" + PD->getName(),
3134                             methodLists.emitExtendedTypesArray(this),
3135                             ObjCTypes);
3136
3137   auto instanceProperties =
3138     EmitPropertyList("OBJC_$_PROP_PROTO_LIST_" + PD->getName(), nullptr, PD,
3139                      ObjCTypes, false);
3140   auto classProperties =
3141     EmitPropertyList("OBJC_$_CLASS_PROP_PROTO_LIST_" + PD->getName(), nullptr,
3142                      PD, ObjCTypes, true);
3143
3144   // Return null if no extension bits are used.
3145   if (optInstanceMethods->isNullValue() &&
3146       optClassMethods->isNullValue() &&
3147       extendedMethodTypes->isNullValue() &&
3148       instanceProperties->isNullValue() &&
3149       classProperties->isNullValue()) {
3150     return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
3151   }
3152
3153   uint64_t size =
3154     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolExtensionTy);
3155
3156   ConstantInitBuilder builder(CGM);
3157   auto values = builder.beginStruct(ObjCTypes.ProtocolExtensionTy);
3158   values.addInt(ObjCTypes.IntTy, size);
3159   values.add(optInstanceMethods);
3160   values.add(optClassMethods);
3161   values.add(instanceProperties);
3162   values.add(extendedMethodTypes);
3163   values.add(classProperties);
3164
3165   // No special section, but goes in llvm.used
3166   return CreateMetadataVar("_OBJC_PROTOCOLEXT_" + PD->getName(), values,
3167                            StringRef(), CGM.getPointerAlign(), true);
3168 }
3169
3170 /*
3171   struct objc_protocol_list {
3172     struct objc_protocol_list *next;
3173     long count;
3174     Protocol *list[];
3175   };
3176 */
3177 llvm::Constant *
3178 CGObjCMac::EmitProtocolList(Twine name,
3179                             ObjCProtocolDecl::protocol_iterator begin,
3180                             ObjCProtocolDecl::protocol_iterator end) {
3181   // Just return null for empty protocol lists
3182   if (begin == end)
3183     return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
3184
3185   ConstantInitBuilder builder(CGM);
3186   auto values = builder.beginStruct();
3187
3188   // This field is only used by the runtime.
3189   values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3190
3191   // Reserve a slot for the count.
3192   auto countSlot = values.addPlaceholder();
3193
3194   auto refsArray = values.beginArray(ObjCTypes.ProtocolPtrTy);
3195   for (; begin != end; ++begin) {
3196     refsArray.add(GetProtocolRef(*begin));
3197   }
3198   auto count = refsArray.size();
3199
3200   // This list is null terminated.
3201   refsArray.addNullPointer(ObjCTypes.ProtocolPtrTy);
3202
3203   refsArray.finishAndAddTo(values);
3204   values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
3205
3206   StringRef section;
3207   if (CGM.getTriple().isOSBinFormatMachO())
3208     section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3209
3210   llvm::GlobalVariable *GV =
3211       CreateMetadataVar(name, values, section, CGM.getPointerAlign(), false);
3212   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListPtrTy);
3213 }
3214
3215 static void
3216 PushProtocolProperties(llvm::SmallPtrSet<const IdentifierInfo*,16> &PropertySet,
3217                        SmallVectorImpl<const ObjCPropertyDecl *> &Properties,
3218                        const ObjCProtocolDecl *Proto,
3219                        bool IsClassProperty) {
3220   for (const auto *P : Proto->protocols())
3221     PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3222
3223   for (const auto *PD : Proto->properties()) {
3224     if (IsClassProperty != PD->isClassProperty())
3225       continue;
3226     if (!PropertySet.insert(PD->getIdentifier()).second)
3227       continue;
3228     Properties.push_back(PD);
3229   }
3230 }
3231
3232 /*
3233   struct _objc_property {
3234     const char * const name;
3235     const char * const attributes;
3236   };
3237
3238   struct _objc_property_list {
3239     uint32_t entsize; // sizeof (struct _objc_property)
3240     uint32_t prop_count;
3241     struct _objc_property[prop_count];
3242   };
3243 */
3244 llvm::Constant *CGObjCCommonMac::EmitPropertyList(Twine Name,
3245                                        const Decl *Container,
3246                                        const ObjCContainerDecl *OCD,
3247                                        const ObjCCommonTypesHelper &ObjCTypes,
3248                                        bool IsClassProperty) {
3249   if (IsClassProperty) {
3250     // Make this entry NULL for OS X with deployment target < 10.11, for iOS
3251     // with deployment target < 9.0.
3252     const llvm::Triple &Triple = CGM.getTarget().getTriple();
3253     if ((Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 11)) ||
3254         (Triple.isiOS() && Triple.isOSVersionLT(9)))
3255       return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3256   }
3257
3258   SmallVector<const ObjCPropertyDecl *, 16> Properties;
3259   llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3260
3261   if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3262     for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3263       for (auto *PD : ClassExt->properties()) {
3264         if (IsClassProperty != PD->isClassProperty())
3265           continue;
3266         PropertySet.insert(PD->getIdentifier());
3267         Properties.push_back(PD);
3268       }
3269
3270   for (const auto *PD : OCD->properties()) {
3271     if (IsClassProperty != PD->isClassProperty())
3272       continue;
3273     // Don't emit duplicate metadata for properties that were already in a
3274     // class extension.
3275     if (!PropertySet.insert(PD->getIdentifier()).second)
3276       continue;
3277     Properties.push_back(PD);
3278   }
3279
3280   if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD)) {
3281     for (const auto *P : OID->all_referenced_protocols())
3282       PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3283   }
3284   else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD)) {
3285     for (const auto *P : CD->protocols())
3286       PushProtocolProperties(PropertySet, Properties, P, IsClassProperty);
3287   }
3288
3289   // Return null for empty list.
3290   if (Properties.empty())
3291     return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
3292
3293   unsigned propertySize =
3294     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.PropertyTy);
3295
3296   ConstantInitBuilder builder(CGM);
3297   auto values = builder.beginStruct();
3298   values.addInt(ObjCTypes.IntTy, propertySize);
3299   values.addInt(ObjCTypes.IntTy, Properties.size());
3300   auto propertiesArray = values.beginArray(ObjCTypes.PropertyTy);
3301   for (auto PD : Properties) {
3302     auto property = propertiesArray.beginStruct(ObjCTypes.PropertyTy);
3303     property.add(GetPropertyName(PD->getIdentifier()));
3304     property.add(GetPropertyTypeString(PD, Container));
3305     property.finishAndAddTo(propertiesArray);
3306   }
3307   propertiesArray.finishAndAddTo(values);
3308
3309   StringRef Section;
3310   if (CGM.getTriple().isOSBinFormatMachO())
3311     Section = (ObjCABI == 2) ? "__DATA, __objc_const"
3312                              : "__OBJC,__property,regular,no_dead_strip";
3313
3314   llvm::GlobalVariable *GV =
3315       CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3316   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.PropertyListPtrTy);
3317 }
3318
3319 llvm::Constant *
3320 CGObjCCommonMac::EmitProtocolMethodTypes(Twine Name,
3321                                          ArrayRef<llvm::Constant*> MethodTypes,
3322                                          const ObjCCommonTypesHelper &ObjCTypes) {
3323   // Return null for empty list.
3324   if (MethodTypes.empty())
3325     return llvm::Constant::getNullValue(ObjCTypes.Int8PtrPtrTy);
3326
3327   llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
3328                                              MethodTypes.size());
3329   llvm::Constant *Init = llvm::ConstantArray::get(AT, MethodTypes);
3330
3331   StringRef Section;
3332   if (CGM.getTriple().isOSBinFormatMachO() && ObjCABI == 2)
3333     Section = "__DATA, __objc_const";
3334
3335   llvm::GlobalVariable *GV =
3336       CreateMetadataVar(Name, Init, Section, CGM.getPointerAlign(), true);
3337   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.Int8PtrPtrTy);
3338 }
3339
3340 /*
3341   struct _objc_category {
3342   char *category_name;
3343   char *class_name;
3344   struct _objc_method_list *instance_methods;
3345   struct _objc_method_list *class_methods;
3346   struct _objc_protocol_list *protocols;
3347   uint32_t size; // <rdar://4585769>
3348   struct _objc_property_list *instance_properties;
3349   struct _objc_property_list *class_properties;
3350   };
3351 */
3352 void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3353   unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategoryTy);
3354
3355   // FIXME: This is poor design, the OCD should have a pointer to the category
3356   // decl. Additionally, note that Category can be null for the @implementation
3357   // w/o an @interface case. Sema should just create one for us as it does for
3358   // @implementation so everyone else can live life under a clear blue sky.
3359   const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
3360   const ObjCCategoryDecl *Category =
3361     Interface->FindCategoryDeclaration(OCD->getIdentifier());
3362
3363   SmallString<256> ExtName;
3364   llvm::raw_svector_ostream(ExtName) << Interface->getName() << '_'
3365                                      << OCD->getName();
3366
3367   ConstantInitBuilder Builder(CGM);
3368   auto Values = Builder.beginStruct(ObjCTypes.CategoryTy);
3369
3370   enum {
3371     InstanceMethods,
3372     ClassMethods,
3373     NumMethodLists
3374   };
3375   SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3376   for (const auto *MD : OCD->methods()) {
3377     Methods[unsigned(MD->isClassMethod())].push_back(MD);
3378   }
3379
3380   Values.add(GetClassName(OCD->getName()));
3381   Values.add(GetClassName(Interface->getObjCRuntimeNameAsString()));
3382   LazySymbols.insert(Interface->getIdentifier());
3383
3384   Values.add(emitMethodList(ExtName, MethodListType::CategoryInstanceMethods,
3385                             Methods[InstanceMethods]));
3386   Values.add(emitMethodList(ExtName, MethodListType::CategoryClassMethods,
3387                             Methods[ClassMethods]));
3388   if (Category) {
3389     Values.add(
3390         EmitProtocolList("OBJC_CATEGORY_PROTOCOLS_" + ExtName.str(),
3391                          Category->protocol_begin(), Category->protocol_end()));
3392   } else {
3393     Values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
3394   }
3395   Values.addInt(ObjCTypes.IntTy, Size);
3396
3397   // If there is no category @interface then there can be no properties.
3398   if (Category) {
3399     Values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
3400                                 OCD, Category, ObjCTypes, false));
3401     Values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
3402                                 OCD, Category, ObjCTypes, true));
3403   } else {
3404     Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3405     Values.addNullPointer(ObjCTypes.PropertyListPtrTy);
3406   }
3407
3408   llvm::GlobalVariable *GV =
3409       CreateMetadataVar("OBJC_CATEGORY_" + ExtName.str(), Values,
3410                         "__OBJC,__category,regular,no_dead_strip",
3411                         CGM.getPointerAlign(), true);
3412   DefinedCategories.push_back(GV);
3413   DefinedCategoryNames.insert(llvm::CachedHashString(ExtName));
3414   // method definition entries must be clear for next implementation.
3415   MethodDefinitions.clear();
3416 }
3417
3418 enum FragileClassFlags {
3419   /// Apparently: is not a meta-class.
3420   FragileABI_Class_Factory                 = 0x00001,
3421
3422   /// Is a meta-class.
3423   FragileABI_Class_Meta                    = 0x00002,
3424
3425   /// Has a non-trivial constructor or destructor.
3426   FragileABI_Class_HasCXXStructors         = 0x02000,
3427
3428   /// Has hidden visibility.
3429   FragileABI_Class_Hidden                  = 0x20000,
3430
3431   /// Class implementation was compiled under ARC.
3432   FragileABI_Class_CompiledByARC           = 0x04000000,
3433
3434   /// Class implementation was compiled under MRC and has MRC weak ivars.
3435   /// Exclusive with CompiledByARC.
3436   FragileABI_Class_HasMRCWeakIvars         = 0x08000000,
3437 };
3438
3439 enum NonFragileClassFlags {
3440   /// Is a meta-class.
3441   NonFragileABI_Class_Meta                 = 0x00001,
3442
3443   /// Is a root class.
3444   NonFragileABI_Class_Root                 = 0x00002,
3445
3446   /// Has a non-trivial constructor or destructor.
3447   NonFragileABI_Class_HasCXXStructors      = 0x00004,
3448
3449   /// Has hidden visibility.
3450   NonFragileABI_Class_Hidden               = 0x00010,
3451
3452   /// Has the exception attribute.
3453   NonFragileABI_Class_Exception            = 0x00020,
3454
3455   /// (Obsolete) ARC-specific: this class has a .release_ivars method
3456   NonFragileABI_Class_HasIvarReleaser      = 0x00040,
3457
3458   /// Class implementation was compiled under ARC.
3459   NonFragileABI_Class_CompiledByARC        = 0x00080,
3460
3461   /// Class has non-trivial destructors, but zero-initialization is okay.
3462   NonFragileABI_Class_HasCXXDestructorOnly = 0x00100,
3463
3464   /// Class implementation was compiled under MRC and has MRC weak ivars.
3465   /// Exclusive with CompiledByARC.
3466   NonFragileABI_Class_HasMRCWeakIvars      = 0x00200,
3467 };
3468
3469 static bool hasWeakMember(QualType type) {
3470   if (type.getObjCLifetime() == Qualifiers::OCL_Weak) {
3471     return true;
3472   }
3473
3474   if (auto recType = type->getAs<RecordType>()) {
3475     for (auto field : recType->getDecl()->fields()) {
3476       if (hasWeakMember(field->getType()))
3477         return true;
3478     }
3479   }
3480
3481   return false;
3482 }
3483
3484 /// For compatibility, we only want to set the "HasMRCWeakIvars" flag
3485 /// (and actually fill in a layout string) if we really do have any
3486 /// __weak ivars.
3487 static bool hasMRCWeakIvars(CodeGenModule &CGM,
3488                             const ObjCImplementationDecl *ID) {
3489   if (!CGM.getLangOpts().ObjCWeak) return false;
3490   assert(CGM.getLangOpts().getGC() == LangOptions::NonGC);
3491
3492   for (const ObjCIvarDecl *ivar =
3493          ID->getClassInterface()->all_declared_ivar_begin();
3494        ivar; ivar = ivar->getNextIvar()) {
3495     if (hasWeakMember(ivar->getType()))
3496       return true;
3497   }
3498
3499   return false;
3500 }
3501
3502 /*
3503   struct _objc_class {
3504   Class isa;
3505   Class super_class;
3506   const char *name;
3507   long version;
3508   long info;
3509   long instance_size;
3510   struct _objc_ivar_list *ivars;
3511   struct _objc_method_list *methods;
3512   struct _objc_cache *cache;
3513   struct _objc_protocol_list *protocols;
3514   // Objective-C 1.0 extensions (<rdr://4585769>)
3515   const char *ivar_layout;
3516   struct _objc_class_ext *ext;
3517   };
3518
3519   See EmitClassExtension();
3520 */
3521 void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
3522   IdentifierInfo *RuntimeName =
3523       &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
3524   DefinedSymbols.insert(RuntimeName);
3525
3526   std::string ClassName = ID->getNameAsString();
3527   // FIXME: Gross
3528   ObjCInterfaceDecl *Interface =
3529     const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
3530   llvm::Constant *Protocols =
3531       EmitProtocolList("OBJC_CLASS_PROTOCOLS_" + ID->getName(),
3532                        Interface->all_referenced_protocol_begin(),
3533                        Interface->all_referenced_protocol_end());
3534   unsigned Flags = FragileABI_Class_Factory;
3535   if (ID->hasNonZeroConstructors() || ID->hasDestructors())
3536     Flags |= FragileABI_Class_HasCXXStructors;
3537
3538   bool hasMRCWeak = false;
3539
3540   if (CGM.getLangOpts().ObjCAutoRefCount)
3541     Flags |= FragileABI_Class_CompiledByARC;
3542   else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
3543     Flags |= FragileABI_Class_HasMRCWeakIvars;
3544
3545   CharUnits Size =
3546     CGM.getContext().getASTObjCImplementationLayout(ID).getSize();
3547
3548   // FIXME: Set CXX-structors flag.
3549   if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3550     Flags |= FragileABI_Class_Hidden;
3551
3552   enum {
3553     InstanceMethods,
3554     ClassMethods,
3555     NumMethodLists
3556   };
3557   SmallVector<const ObjCMethodDecl *, 16> Methods[NumMethodLists];
3558   for (const auto *MD : ID->methods()) {
3559     Methods[unsigned(MD->isClassMethod())].push_back(MD);
3560   }
3561
3562   for (const auto *PID : ID->property_impls()) {
3563     if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
3564       ObjCPropertyDecl *PD = PID->getPropertyDecl();
3565
3566       if (ObjCMethodDecl *MD = PD->getGetterMethodDecl())
3567         if (GetMethodDefinition(MD))
3568           Methods[InstanceMethods].push_back(MD);
3569       if (ObjCMethodDecl *MD = PD->getSetterMethodDecl())
3570         if (GetMethodDefinition(MD))
3571           Methods[InstanceMethods].push_back(MD);
3572     }
3573   }
3574
3575   ConstantInitBuilder builder(CGM);
3576   auto values = builder.beginStruct(ObjCTypes.ClassTy);
3577   values.add(EmitMetaClass(ID, Protocols, Methods[ClassMethods]));
3578   if (ObjCInterfaceDecl *Super = Interface->getSuperClass()) {
3579     // Record a reference to the super class.
3580     LazySymbols.insert(Super->getIdentifier());
3581
3582     values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3583                       ObjCTypes.ClassPtrTy);
3584   } else {
3585     values.addNullPointer(ObjCTypes.ClassPtrTy);
3586   }
3587   values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3588   // Version is always 0.
3589   values.addInt(ObjCTypes.LongTy, 0);
3590   values.addInt(ObjCTypes.LongTy, Flags);
3591   values.addInt(ObjCTypes.LongTy, Size.getQuantity());
3592   values.add(EmitIvarList(ID, false));
3593   values.add(emitMethodList(ID->getName(), MethodListType::InstanceMethods,
3594                             Methods[InstanceMethods]));
3595   // cache is always NULL.
3596   values.addNullPointer(ObjCTypes.CachePtrTy);
3597   values.add(Protocols);
3598   values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3599   values.add(EmitClassExtension(ID, Size, hasMRCWeak,
3600                                 /*isMetaclass*/ false));
3601
3602   std::string Name("OBJC_CLASS_");
3603   Name += ClassName;
3604   const char *Section = "__OBJC,__class,regular,no_dead_strip";
3605   // Check for a forward reference.
3606   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3607   if (GV) {
3608     assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3609            "Forward metaclass reference has incorrect type.");
3610     values.finishAndSetAsInitializer(GV);
3611     GV->setSection(Section);
3612     GV->setAlignment(CGM.getPointerAlign().getQuantity());
3613     CGM.addCompilerUsedGlobal(GV);
3614   } else
3615     GV = CreateMetadataVar(Name, values, Section, CGM.getPointerAlign(), true);
3616   DefinedClasses.push_back(GV);
3617   ImplementedClasses.push_back(Interface);
3618   // method definition entries must be clear for next implementation.
3619   MethodDefinitions.clear();
3620 }
3621
3622 llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
3623                                          llvm::Constant *Protocols,
3624                                 ArrayRef<const ObjCMethodDecl*> Methods) {
3625   unsigned Flags = FragileABI_Class_Meta;
3626   unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassTy);
3627
3628   if (ID->getClassInterface()->getVisibility() == HiddenVisibility)
3629     Flags |= FragileABI_Class_Hidden;
3630
3631   ConstantInitBuilder builder(CGM);
3632   auto values = builder.beginStruct(ObjCTypes.ClassTy);
3633   // The isa for the metaclass is the root of the hierarchy.
3634   const ObjCInterfaceDecl *Root = ID->getClassInterface();
3635   while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
3636     Root = Super;
3637   values.addBitCast(GetClassName(Root->getObjCRuntimeNameAsString()),
3638                     ObjCTypes.ClassPtrTy);
3639   // The super class for the metaclass is emitted as the name of the
3640   // super class. The runtime fixes this up to point to the
3641   // *metaclass* for the super class.
3642   if (ObjCInterfaceDecl *Super = ID->getClassInterface()->getSuperClass()) {
3643     values.addBitCast(GetClassName(Super->getObjCRuntimeNameAsString()),
3644                       ObjCTypes.ClassPtrTy);
3645   } else {
3646     values.addNullPointer(ObjCTypes.ClassPtrTy);
3647   }
3648   values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
3649   // Version is always 0.
3650   values.addInt(ObjCTypes.LongTy, 0);
3651   values.addInt(ObjCTypes.LongTy, Flags);
3652   values.addInt(ObjCTypes.LongTy, Size);
3653   values.add(EmitIvarList(ID, true));
3654   values.add(emitMethodList(ID->getName(), MethodListType::ClassMethods,
3655                             Methods));
3656   // cache is always NULL.
3657   values.addNullPointer(ObjCTypes.CachePtrTy);
3658   values.add(Protocols);
3659   // ivar_layout for metaclass is always NULL.
3660   values.addNullPointer(ObjCTypes.Int8PtrTy);
3661   // The class extension is used to store class properties for metaclasses.
3662   values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3663                                 /*isMetaclass*/true));
3664
3665   std::string Name("OBJC_METACLASS_");
3666   Name += ID->getName();
3667
3668   // Check for a forward reference.
3669   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3670   if (GV) {
3671     assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3672            "Forward metaclass reference has incorrect type.");
3673     values.finishAndSetAsInitializer(GV);
3674   } else {
3675     GV = values.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
3676                                       /*constant*/ false,
3677                                       llvm::GlobalValue::PrivateLinkage);
3678   }
3679   GV->setSection("__OBJC,__meta_class,regular,no_dead_strip");
3680   CGM.addCompilerUsedGlobal(GV);
3681
3682   return GV;
3683 }
3684
3685 llvm::Constant *CGObjCMac::EmitMetaClassRef(const ObjCInterfaceDecl *ID) {
3686   std::string Name = "OBJC_METACLASS_" + ID->getNameAsString();
3687
3688   // FIXME: Should we look these up somewhere other than the module. Its a bit
3689   // silly since we only generate these while processing an implementation, so
3690   // exactly one pointer would work if know when we entered/exitted an
3691   // implementation block.
3692
3693   // Check for an existing forward reference.
3694   // Previously, metaclass with internal linkage may have been defined.
3695   // pass 'true' as 2nd argument so it is returned.
3696   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3697   if (!GV)
3698     GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3699                                   llvm::GlobalValue::PrivateLinkage, nullptr,
3700                                   Name);
3701
3702   assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3703          "Forward metaclass reference has incorrect type.");
3704   return GV;
3705 }
3706
3707 llvm::Value *CGObjCMac::EmitSuperClassRef(const ObjCInterfaceDecl *ID) {
3708   std::string Name = "OBJC_CLASS_" + ID->getNameAsString();
3709   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
3710
3711   if (!GV)
3712     GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassTy, false,
3713                                   llvm::GlobalValue::PrivateLinkage, nullptr,
3714                                   Name);
3715
3716   assert(GV->getType()->getElementType() == ObjCTypes.ClassTy &&
3717          "Forward class metadata reference has incorrect type.");
3718   return GV;
3719 }
3720
3721 /*
3722   Emit a "class extension", which in this specific context means extra
3723   data that doesn't fit in the normal fragile-ABI class structure, and
3724   has nothing to do with the language concept of a class extension.
3725
3726   struct objc_class_ext {
3727   uint32_t size;
3728   const char *weak_ivar_layout;
3729   struct _objc_property_list *properties;
3730   };
3731 */
3732 llvm::Constant *
3733 CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID,
3734                               CharUnits InstanceSize, bool hasMRCWeakIvars,
3735                               bool isMetaclass) {
3736   // Weak ivar layout.
3737   llvm::Constant *layout;
3738   if (isMetaclass) {
3739     layout = llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
3740   } else {
3741     layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3742                                  hasMRCWeakIvars);
3743   }
3744
3745   // Properties.
3746   llvm::Constant *propertyList =
3747     EmitPropertyList((isMetaclass ? Twine("_OBJC_$_CLASS_PROP_LIST_")
3748                                   : Twine("_OBJC_$_PROP_LIST_"))
3749                         + ID->getName(),
3750                      ID, ID->getClassInterface(), ObjCTypes, isMetaclass);
3751
3752   // Return null if no extension bits are used.
3753   if (layout->isNullValue() && propertyList->isNullValue()) {
3754     return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
3755   }
3756
3757   uint64_t size =
3758     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassExtensionTy);
3759
3760   ConstantInitBuilder builder(CGM);
3761   auto values = builder.beginStruct(ObjCTypes.ClassExtensionTy);
3762   values.addInt(ObjCTypes.IntTy, size);
3763   values.add(layout);
3764   values.add(propertyList);
3765
3766   return CreateMetadataVar("OBJC_CLASSEXT_" + ID->getName(), values,
3767                            "__OBJC,__class_ext,regular,no_dead_strip",
3768                            CGM.getPointerAlign(), true);
3769 }
3770
3771 /*
3772   struct objc_ivar {
3773     char *ivar_name;
3774     char *ivar_type;
3775     int ivar_offset;
3776   };
3777
3778   struct objc_ivar_list {
3779     int ivar_count;
3780     struct objc_ivar list[count];
3781   };
3782 */
3783 llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
3784                                         bool ForClass) {
3785   // When emitting the root class GCC emits ivar entries for the
3786   // actual class structure. It is not clear if we need to follow this
3787   // behavior; for now lets try and get away with not doing it. If so,
3788   // the cleanest solution would be to make up an ObjCInterfaceDecl
3789   // for the class.
3790   if (ForClass)
3791     return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3792
3793   const ObjCInterfaceDecl *OID = ID->getClassInterface();
3794
3795   ConstantInitBuilder builder(CGM);
3796   auto ivarList = builder.beginStruct();
3797   auto countSlot = ivarList.addPlaceholder();
3798   auto ivars = ivarList.beginArray(ObjCTypes.IvarTy);
3799
3800   for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
3801        IVD; IVD = IVD->getNextIvar()) {
3802     // Ignore unnamed bit-fields.
3803     if (!IVD->getDeclName())
3804       continue;
3805
3806     auto ivar = ivars.beginStruct(ObjCTypes.IvarTy);
3807     ivar.add(GetMethodVarName(IVD->getIdentifier()));
3808     ivar.add(GetMethodVarType(IVD));
3809     ivar.addInt(ObjCTypes.IntTy, ComputeIvarBaseOffset(CGM, OID, IVD));
3810     ivar.finishAndAddTo(ivars);
3811   }
3812
3813   // Return null for empty list.
3814   auto count = ivars.size();
3815   if (count == 0) {
3816     ivars.abandon();
3817     ivarList.abandon();
3818     return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
3819   }
3820
3821   ivars.finishAndAddTo(ivarList);
3822   ivarList.fillPlaceholderWithInt(countSlot, ObjCTypes.IntTy, count);
3823
3824   llvm::GlobalVariable *GV;
3825   if (ForClass)
3826     GV =
3827         CreateMetadataVar("OBJC_CLASS_VARIABLES_" + ID->getName(), ivarList,
3828                           "__OBJC,__class_vars,regular,no_dead_strip",
3829                           CGM.getPointerAlign(), true);
3830   else
3831     GV = CreateMetadataVar("OBJC_INSTANCE_VARIABLES_" + ID->getName(), ivarList,
3832                            "__OBJC,__instance_vars,regular,no_dead_strip",
3833                            CGM.getPointerAlign(), true);
3834   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListPtrTy);
3835 }
3836
3837 /// Build a struct objc_method_description constant for the given method.
3838 ///
3839 /// struct objc_method_description {
3840 ///   SEL method_name;
3841 ///   char *method_types;
3842 /// };
3843 void CGObjCMac::emitMethodDescriptionConstant(ConstantArrayBuilder &builder,
3844                                               const ObjCMethodDecl *MD) {
3845   auto description = builder.beginStruct(ObjCTypes.MethodDescriptionTy);
3846   description.addBitCast(GetMethodVarName(MD->getSelector()),
3847                          ObjCTypes.SelectorPtrTy);
3848   description.add(GetMethodVarType(MD));
3849   description.finishAndAddTo(builder);
3850 }
3851
3852 /// Build a struct objc_method constant for the given method.
3853 ///
3854 /// struct objc_method {
3855 ///   SEL method_name;
3856 ///   char *method_types;
3857 ///   void *method;
3858 /// };
3859 void CGObjCMac::emitMethodConstant(ConstantArrayBuilder &builder,
3860                                    const ObjCMethodDecl *MD) {
3861   llvm::Function *fn = GetMethodDefinition(MD);
3862   assert(fn && "no definition registered for method");
3863
3864   auto method = builder.beginStruct(ObjCTypes.MethodTy);
3865   method.addBitCast(GetMethodVarName(MD->getSelector()),
3866                     ObjCTypes.SelectorPtrTy);
3867   method.add(GetMethodVarType(MD));
3868   method.addBitCast(fn, ObjCTypes.Int8PtrTy);
3869   method.finishAndAddTo(builder);
3870 }
3871
3872 /// Build a struct objc_method_list or struct objc_method_description_list,
3873 /// as appropriate.
3874 ///
3875 /// struct objc_method_list {
3876 ///   struct objc_method_list *obsolete;
3877 ///   int count;
3878 ///   struct objc_method methods_list[count];
3879 /// };
3880 ///
3881 /// struct objc_method_description_list {
3882 ///   int count;
3883 ///   struct objc_method_description list[count];
3884 /// };
3885 llvm::Constant *CGObjCMac::emitMethodList(Twine name, MethodListType MLT,
3886                                  ArrayRef<const ObjCMethodDecl *> methods) {
3887   StringRef prefix;
3888   StringRef section;
3889   bool forProtocol = false;
3890   switch (MLT) {
3891   case MethodListType::CategoryInstanceMethods:
3892     prefix = "OBJC_CATEGORY_INSTANCE_METHODS_";
3893     section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3894     forProtocol = false;
3895     break;
3896   case MethodListType::CategoryClassMethods:
3897     prefix = "OBJC_CATEGORY_CLASS_METHODS_";
3898     section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3899     forProtocol = false;
3900     break;
3901   case MethodListType::InstanceMethods:
3902     prefix = "OBJC_INSTANCE_METHODS_";
3903     section = "__OBJC,__inst_meth,regular,no_dead_strip";
3904     forProtocol = false;
3905     break;
3906   case MethodListType::ClassMethods:
3907     prefix = "OBJC_CLASS_METHODS_";
3908     section = "__OBJC,__cls_meth,regular,no_dead_strip";
3909     forProtocol = false;
3910     break;
3911   case MethodListType::ProtocolInstanceMethods:
3912     prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_";
3913     section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3914     forProtocol = true;
3915     break;
3916   case MethodListType::ProtocolClassMethods:
3917     prefix = "OBJC_PROTOCOL_CLASS_METHODS_";
3918     section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3919     forProtocol = true;
3920     break;
3921   case MethodListType::OptionalProtocolInstanceMethods:
3922     prefix = "OBJC_PROTOCOL_INSTANCE_METHODS_OPT_";
3923     section = "__OBJC,__cat_inst_meth,regular,no_dead_strip";
3924     forProtocol = true;
3925     break;
3926   case MethodListType::OptionalProtocolClassMethods:
3927     prefix = "OBJC_PROTOCOL_CLASS_METHODS_OPT_";
3928     section = "__OBJC,__cat_cls_meth,regular,no_dead_strip";
3929     forProtocol = true;
3930     break;
3931   }
3932
3933   // Return null for empty list.
3934   if (methods.empty())
3935     return llvm::Constant::getNullValue(forProtocol
3936                                         ? ObjCTypes.MethodDescriptionListPtrTy
3937                                         : ObjCTypes.MethodListPtrTy);
3938
3939   // For protocols, this is an objc_method_description_list, which has
3940   // a slightly different structure.
3941   if (forProtocol) {
3942     ConstantInitBuilder builder(CGM);
3943     auto values = builder.beginStruct();
3944     values.addInt(ObjCTypes.IntTy, methods.size());
3945     auto methodArray = values.beginArray(ObjCTypes.MethodDescriptionTy);
3946     for (auto MD : methods) {
3947       emitMethodDescriptionConstant(methodArray, MD);
3948     }
3949     methodArray.finishAndAddTo(values);
3950
3951     llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3952                                                  CGM.getPointerAlign(), true);
3953     return llvm::ConstantExpr::getBitCast(GV,
3954                                           ObjCTypes.MethodDescriptionListPtrTy);
3955   }
3956
3957   // Otherwise, it's an objc_method_list.
3958   ConstantInitBuilder builder(CGM);
3959   auto values = builder.beginStruct();
3960   values.addNullPointer(ObjCTypes.Int8PtrTy);
3961   values.addInt(ObjCTypes.IntTy, methods.size());
3962   auto methodArray = values.beginArray(ObjCTypes.MethodTy);
3963   for (auto MD : methods) {
3964     emitMethodConstant(methodArray, MD);
3965   }
3966   methodArray.finishAndAddTo(values);
3967
3968   llvm::GlobalVariable *GV = CreateMetadataVar(prefix + name, values, section,
3969                                                CGM.getPointerAlign(), true);
3970   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListPtrTy);
3971 }
3972
3973 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
3974                                                 const ObjCContainerDecl *CD) {
3975   SmallString<256> Name;
3976   GetNameForMethod(OMD, CD, Name);
3977
3978   CodeGenTypes &Types = CGM.getTypes();
3979   llvm::FunctionType *MethodTy =
3980     Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
3981   llvm::Function *Method =
3982     llvm::Function::Create(MethodTy,
3983                            llvm::GlobalValue::InternalLinkage,
3984                            Name.str(),
3985                            &CGM.getModule());
3986   MethodDefinitions.insert(std::make_pair(OMD, Method));
3987
3988   return Method;
3989 }
3990
3991 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
3992                                                ConstantStructBuilder &Init,
3993                                                          StringRef Section,
3994                                                          CharUnits Align,
3995                                                          bool AddToUsed) {
3996   llvm::GlobalValue::LinkageTypes LT =
3997       getLinkageTypeForObjCMetadata(CGM, Section);
3998   llvm::GlobalVariable *GV =
3999       Init.finishAndCreateGlobal(Name, Align, /*constant*/ false, LT);
4000   if (!Section.empty())
4001     GV->setSection(Section);
4002   if (AddToUsed)
4003     CGM.addCompilerUsedGlobal(GV);
4004   return GV;
4005 }
4006
4007 llvm::GlobalVariable *CGObjCCommonMac::CreateMetadataVar(Twine Name,
4008                                                          llvm::Constant *Init,
4009                                                          StringRef Section,
4010                                                          CharUnits Align,
4011                                                          bool AddToUsed) {
4012   llvm::Type *Ty = Init->getType();
4013   llvm::GlobalValue::LinkageTypes LT =
4014       getLinkageTypeForObjCMetadata(CGM, Section);
4015   llvm::GlobalVariable *GV =
4016       new llvm::GlobalVariable(CGM.getModule(), Ty, false, LT, Init, Name);
4017   if (!Section.empty())
4018     GV->setSection(Section);
4019   GV->setAlignment(Align.getQuantity());
4020   if (AddToUsed)
4021     CGM.addCompilerUsedGlobal(GV);
4022   return GV;
4023 }
4024
4025 llvm::GlobalVariable *
4026 CGObjCCommonMac::CreateCStringLiteral(StringRef Name, ObjCLabelType Type,
4027                                       bool ForceNonFragileABI,
4028                                       bool NullTerminate) {
4029   StringRef Label;
4030   switch (Type) {
4031   case ObjCLabelType::ClassName:     Label = "OBJC_CLASS_NAME_"; break;
4032   case ObjCLabelType::MethodVarName: Label = "OBJC_METH_VAR_NAME_"; break;
4033   case ObjCLabelType::MethodVarType: Label = "OBJC_METH_VAR_TYPE_"; break;
4034   case ObjCLabelType::PropertyName:  Label = "OBJC_PROP_NAME_ATTR_"; break;
4035   }
4036
4037   bool NonFragile = ForceNonFragileABI || isNonFragileABI();
4038
4039   StringRef Section;
4040   switch (Type) {
4041   case ObjCLabelType::ClassName:
4042     Section = NonFragile ? "__TEXT,__objc_classname,cstring_literals"
4043                          : "__TEXT,__cstring,cstring_literals";
4044     break;
4045   case ObjCLabelType::MethodVarName:
4046     Section = NonFragile ? "__TEXT,__objc_methname,cstring_literals"
4047                          : "__TEXT,__cstring,cstring_literals";
4048     break;
4049   case ObjCLabelType::MethodVarType:
4050     Section = NonFragile ? "__TEXT,__objc_methtype,cstring_literals"
4051                          : "__TEXT,__cstring,cstring_literals";
4052     break;
4053   case ObjCLabelType::PropertyName:
4054     Section = "__TEXT,__cstring,cstring_literals";
4055     break;
4056   }
4057
4058   llvm::Constant *Value =
4059       llvm::ConstantDataArray::getString(VMContext, Name, NullTerminate);
4060   llvm::GlobalVariable *GV =
4061       new llvm::GlobalVariable(CGM.getModule(), Value->getType(),
4062                                /*isConstant=*/true,
4063                                llvm::GlobalValue::PrivateLinkage, Value, Label);
4064   if (CGM.getTriple().isOSBinFormatMachO())
4065     GV->setSection(Section);
4066   GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4067   GV->setAlignment(CharUnits::One().getQuantity());
4068   CGM.addCompilerUsedGlobal(GV);
4069
4070   return GV;
4071 }
4072
4073 llvm::Function *CGObjCMac::ModuleInitFunction() {
4074   // Abuse this interface function as a place to finalize.
4075   FinishModule();
4076   return nullptr;
4077 }
4078
4079 llvm::FunctionCallee CGObjCMac::GetPropertyGetFunction() {
4080   return ObjCTypes.getGetPropertyFn();
4081 }
4082
4083 llvm::FunctionCallee CGObjCMac::GetPropertySetFunction() {
4084   return ObjCTypes.getSetPropertyFn();
4085 }
4086
4087 llvm::FunctionCallee CGObjCMac::GetOptimizedPropertySetFunction(bool atomic,
4088                                                                 bool copy) {
4089   return ObjCTypes.getOptimizedSetPropertyFn(atomic, copy);
4090 }
4091
4092 llvm::FunctionCallee CGObjCMac::GetGetStructFunction() {
4093   return ObjCTypes.getCopyStructFn();
4094 }
4095
4096 llvm::FunctionCallee CGObjCMac::GetSetStructFunction() {
4097   return ObjCTypes.getCopyStructFn();
4098 }
4099
4100 llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectGetFunction() {
4101   return ObjCTypes.getCppAtomicObjectFunction();
4102 }
4103
4104 llvm::FunctionCallee CGObjCMac::GetCppAtomicObjectSetFunction() {
4105   return ObjCTypes.getCppAtomicObjectFunction();
4106 }
4107
4108 llvm::FunctionCallee CGObjCMac::EnumerationMutationFunction() {
4109   return ObjCTypes.getEnumerationMutationFn();
4110 }
4111
4112 void CGObjCMac::EmitTryStmt(CodeGenFunction &CGF, const ObjCAtTryStmt &S) {
4113   return EmitTryOrSynchronizedStmt(CGF, S);
4114 }
4115
4116 void CGObjCMac::EmitSynchronizedStmt(CodeGenFunction &CGF,
4117                                      const ObjCAtSynchronizedStmt &S) {
4118   return EmitTryOrSynchronizedStmt(CGF, S);
4119 }
4120
4121 namespace {
4122   struct PerformFragileFinally final : EHScopeStack::Cleanup {
4123     const Stmt &S;
4124     Address SyncArgSlot;
4125     Address CallTryExitVar;
4126     Address ExceptionData;
4127     ObjCTypesHelper &ObjCTypes;
4128     PerformFragileFinally(const Stmt *S,
4129                           Address SyncArgSlot,
4130                           Address CallTryExitVar,
4131                           Address ExceptionData,
4132                           ObjCTypesHelper *ObjCTypes)
4133       : S(*S), SyncArgSlot(SyncArgSlot), CallTryExitVar(CallTryExitVar),
4134         ExceptionData(ExceptionData), ObjCTypes(*ObjCTypes) {}
4135
4136     void Emit(CodeGenFunction &CGF, Flags flags) override {
4137       // Check whether we need to call objc_exception_try_exit.
4138       // In optimized code, this branch will always be folded.
4139       llvm::BasicBlock *FinallyCallExit =
4140         CGF.createBasicBlock("finally.call_exit");
4141       llvm::BasicBlock *FinallyNoCallExit =
4142         CGF.createBasicBlock("finally.no_call_exit");
4143       CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
4144                                FinallyCallExit, FinallyNoCallExit);
4145
4146       CGF.EmitBlock(FinallyCallExit);
4147       CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryExitFn(),
4148                                   ExceptionData.getPointer());
4149
4150       CGF.EmitBlock(FinallyNoCallExit);
4151
4152       if (isa<ObjCAtTryStmt>(S)) {
4153         if (const ObjCAtFinallyStmt* FinallyStmt =
4154               cast<ObjCAtTryStmt>(S).getFinallyStmt()) {
4155           // Don't try to do the @finally if this is an EH cleanup.
4156           if (flags.isForEHCleanup()) return;
4157
4158           // Save the current cleanup destination in case there's
4159           // control flow inside the finally statement.
4160           llvm::Value *CurCleanupDest =
4161             CGF.Builder.CreateLoad(CGF.getNormalCleanupDestSlot());
4162
4163           CGF.EmitStmt(FinallyStmt->getFinallyBody());
4164
4165           if (CGF.HaveInsertPoint()) {
4166             CGF.Builder.CreateStore(CurCleanupDest,
4167                                     CGF.getNormalCleanupDestSlot());
4168           } else {
4169             // Currently, the end of the cleanup must always exist.
4170             CGF.EnsureInsertPoint();
4171           }
4172         }
4173       } else {
4174         // Emit objc_sync_exit(expr); as finally's sole statement for
4175         // @synchronized.
4176         llvm::Value *SyncArg = CGF.Builder.CreateLoad(SyncArgSlot);
4177         CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncExitFn(), SyncArg);
4178       }
4179     }
4180   };
4181
4182   class FragileHazards {
4183     CodeGenFunction &CGF;
4184     SmallVector<llvm::Value*, 20> Locals;
4185     llvm::DenseSet<llvm::BasicBlock*> BlocksBeforeTry;
4186
4187     llvm::InlineAsm *ReadHazard;
4188     llvm::InlineAsm *WriteHazard;
4189
4190     llvm::FunctionType *GetAsmFnType();
4191
4192     void collectLocals();
4193     void emitReadHazard(CGBuilderTy &Builder);
4194
4195   public:
4196     FragileHazards(CodeGenFunction &CGF);
4197
4198     void emitWriteHazard();
4199     void emitHazardsInNewBlocks();
4200   };
4201 } // end anonymous namespace
4202
4203 /// Create the fragile-ABI read and write hazards based on the current
4204 /// state of the function, which is presumed to be immediately prior
4205 /// to a @try block.  These hazards are used to maintain correct
4206 /// semantics in the face of optimization and the fragile ABI's
4207 /// cavalier use of setjmp/longjmp.
4208 FragileHazards::FragileHazards(CodeGenFunction &CGF) : CGF(CGF) {
4209   collectLocals();
4210
4211   if (Locals.empty()) return;
4212
4213   // Collect all the blocks in the function.
4214   for (llvm::Function::iterator
4215          I = CGF.CurFn->begin(), E = CGF.CurFn->end(); I != E; ++I)
4216     BlocksBeforeTry.insert(&*I);
4217
4218   llvm::FunctionType *AsmFnTy = GetAsmFnType();
4219
4220   // Create a read hazard for the allocas.  This inhibits dead-store
4221   // optimizations and forces the values to memory.  This hazard is
4222   // inserted before any 'throwing' calls in the protected scope to
4223   // reflect the possibility that the variables might be read from the
4224   // catch block if the call throws.
4225   {
4226     std::string Constraint;
4227     for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4228       if (I) Constraint += ',';
4229       Constraint += "*m";
4230     }
4231
4232     ReadHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4233   }
4234
4235   // Create a write hazard for the allocas.  This inhibits folding
4236   // loads across the hazard.  This hazard is inserted at the
4237   // beginning of the catch path to reflect the possibility that the
4238   // variables might have been written within the protected scope.
4239   {
4240     std::string Constraint;
4241     for (unsigned I = 0, E = Locals.size(); I != E; ++I) {
4242       if (I) Constraint += ',';
4243       Constraint += "=*m";
4244     }
4245
4246     WriteHazard = llvm::InlineAsm::get(AsmFnTy, "", Constraint, true, false);
4247   }
4248 }
4249
4250 /// Emit a write hazard at the current location.
4251 void FragileHazards::emitWriteHazard() {
4252   if (Locals.empty()) return;
4253
4254   CGF.EmitNounwindRuntimeCall(WriteHazard, Locals);
4255 }
4256
4257 void FragileHazards::emitReadHazard(CGBuilderTy &Builder) {
4258   assert(!Locals.empty());
4259   llvm::CallInst *call = Builder.CreateCall(ReadHazard, Locals);
4260   call->setDoesNotThrow();
4261   call->setCallingConv(CGF.getRuntimeCC());
4262 }
4263
4264 /// Emit read hazards in all the protected blocks, i.e. all the blocks
4265 /// which have been inserted since the beginning of the try.
4266 void FragileHazards::emitHazardsInNewBlocks() {
4267   if (Locals.empty()) return;
4268
4269   CGBuilderTy Builder(CGF, CGF.getLLVMContext());
4270
4271   // Iterate through all blocks, skipping those prior to the try.
4272   for (llvm::Function::iterator
4273          FI = CGF.CurFn->begin(), FE = CGF.CurFn->end(); FI != FE; ++FI) {
4274     llvm::BasicBlock &BB = *FI;
4275     if (BlocksBeforeTry.count(&BB)) continue;
4276
4277     // Walk through all the calls in the block.
4278     for (llvm::BasicBlock::iterator
4279            BI = BB.begin(), BE = BB.end(); BI != BE; ++BI) {
4280       llvm::Instruction &I = *BI;
4281
4282       // Ignore instructions that aren't non-intrinsic calls.
4283       // These are the only calls that can possibly call longjmp.
4284       if (!isa<llvm::CallInst>(I) && !isa<llvm::InvokeInst>(I))
4285         continue;
4286       if (isa<llvm::IntrinsicInst>(I))
4287         continue;
4288
4289       // Ignore call sites marked nounwind.  This may be questionable,
4290       // since 'nounwind' doesn't necessarily mean 'does not call longjmp'.
4291       if (cast<llvm::CallBase>(I).doesNotThrow())
4292         continue;
4293
4294       // Insert a read hazard before the call.  This will ensure that
4295       // any writes to the locals are performed before making the
4296       // call.  If the call throws, then this is sufficient to
4297       // guarantee correctness as long as it doesn't also write to any
4298       // locals.
4299       Builder.SetInsertPoint(&BB, BI);
4300       emitReadHazard(Builder);
4301     }
4302   }
4303 }
4304
4305 static void addIfPresent(llvm::DenseSet<llvm::Value*> &S, Address V) {
4306   if (V.isValid()) S.insert(V.getPointer());
4307 }
4308
4309 void FragileHazards::collectLocals() {
4310   // Compute a set of allocas to ignore.
4311   llvm::DenseSet<llvm::Value*> AllocasToIgnore;
4312   addIfPresent(AllocasToIgnore, CGF.ReturnValue);
4313   addIfPresent(AllocasToIgnore, CGF.NormalCleanupDest);
4314
4315   // Collect all the allocas currently in the function.  This is
4316   // probably way too aggressive.
4317   llvm::BasicBlock &Entry = CGF.CurFn->getEntryBlock();
4318   for (llvm::BasicBlock::iterator
4319          I = Entry.begin(), E = Entry.end(); I != E; ++I)
4320     if (isa<llvm::AllocaInst>(*I) && !AllocasToIgnore.count(&*I))
4321       Locals.push_back(&*I);
4322 }
4323
4324 llvm::FunctionType *FragileHazards::GetAsmFnType() {
4325   SmallVector<llvm::Type *, 16> tys(Locals.size());
4326   for (unsigned i = 0, e = Locals.size(); i != e; ++i)
4327     tys[i] = Locals[i]->getType();
4328   return llvm::FunctionType::get(CGF.VoidTy, tys, false);
4329 }
4330
4331 /*
4332
4333   Objective-C setjmp-longjmp (sjlj) Exception Handling
4334   --
4335
4336   A catch buffer is a setjmp buffer plus:
4337     - a pointer to the exception that was caught
4338     - a pointer to the previous exception data buffer
4339     - two pointers of reserved storage
4340   Therefore catch buffers form a stack, with a pointer to the top
4341   of the stack kept in thread-local storage.
4342
4343   objc_exception_try_enter pushes a catch buffer onto the EH stack.
4344   objc_exception_try_exit pops the given catch buffer, which is
4345     required to be the top of the EH stack.
4346   objc_exception_throw pops the top of the EH stack, writes the
4347     thrown exception into the appropriate field, and longjmps
4348     to the setjmp buffer.  It crashes the process (with a printf
4349     and an abort()) if there are no catch buffers on the stack.
4350   objc_exception_extract just reads the exception pointer out of the
4351     catch buffer.
4352
4353   There's no reason an implementation couldn't use a light-weight
4354   setjmp here --- something like __builtin_setjmp, but API-compatible
4355   with the heavyweight setjmp.  This will be more important if we ever
4356   want to implement correct ObjC/C++ exception interactions for the
4357   fragile ABI.
4358
4359   Note that for this use of setjmp/longjmp to be correct, we may need
4360   to mark some local variables volatile: if a non-volatile local
4361   variable is modified between the setjmp and the longjmp, it has
4362   indeterminate value.  For the purposes of LLVM IR, it may be
4363   sufficient to make loads and stores within the @try (to variables
4364   declared outside the @try) volatile.  This is necessary for
4365   optimized correctness, but is not currently being done; this is
4366   being tracked as rdar://problem/8160285
4367
4368   The basic framework for a @try-catch-finally is as follows:
4369   {
4370   objc_exception_data d;
4371   id _rethrow = null;
4372   bool _call_try_exit = true;
4373
4374   objc_exception_try_enter(&d);
4375   if (!setjmp(d.jmp_buf)) {
4376   ... try body ...
4377   } else {
4378   // exception path
4379   id _caught = objc_exception_extract(&d);
4380
4381   // enter new try scope for handlers
4382   if (!setjmp(d.jmp_buf)) {
4383   ... match exception and execute catch blocks ...
4384
4385   // fell off end, rethrow.
4386   _rethrow = _caught;
4387   ... jump-through-finally to finally_rethrow ...
4388   } else {
4389   // exception in catch block
4390   _rethrow = objc_exception_extract(&d);
4391   _call_try_exit = false;
4392   ... jump-through-finally to finally_rethrow ...
4393   }
4394   }
4395   ... jump-through-finally to finally_end ...
4396
4397   finally:
4398   if (_call_try_exit)
4399   objc_exception_try_exit(&d);
4400
4401   ... finally block ....
4402   ... dispatch to finally destination ...
4403
4404   finally_rethrow:
4405   objc_exception_throw(_rethrow);
4406
4407   finally_end:
4408   }
4409
4410   This framework differs slightly from the one gcc uses, in that gcc
4411   uses _rethrow to determine if objc_exception_try_exit should be called
4412   and if the object should be rethrown. This breaks in the face of
4413   throwing nil and introduces unnecessary branches.
4414
4415   We specialize this framework for a few particular circumstances:
4416
4417   - If there are no catch blocks, then we avoid emitting the second
4418   exception handling context.
4419
4420   - If there is a catch-all catch block (i.e. @catch(...) or @catch(id
4421   e)) we avoid emitting the code to rethrow an uncaught exception.
4422
4423   - FIXME: If there is no @finally block we can do a few more
4424   simplifications.
4425
4426   Rethrows and Jumps-Through-Finally
4427   --
4428
4429   '@throw;' is supported by pushing the currently-caught exception
4430   onto ObjCEHStack while the @catch blocks are emitted.
4431
4432   Branches through the @finally block are handled with an ordinary
4433   normal cleanup.  We do not register an EH cleanup; fragile-ABI ObjC
4434   exceptions are not compatible with C++ exceptions, and this is
4435   hardly the only place where this will go wrong.
4436
4437   @synchronized(expr) { stmt; } is emitted as if it were:
4438     id synch_value = expr;
4439     objc_sync_enter(synch_value);
4440     @try { stmt; } @finally { objc_sync_exit(synch_value); }
4441 */
4442
4443 void CGObjCMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
4444                                           const Stmt &S) {
4445   bool isTry = isa<ObjCAtTryStmt>(S);
4446
4447   // A destination for the fall-through edges of the catch handlers to
4448   // jump to.
4449   CodeGenFunction::JumpDest FinallyEnd =
4450     CGF.getJumpDestInCurrentScope("finally.end");
4451
4452   // A destination for the rethrow edge of the catch handlers to jump
4453   // to.
4454   CodeGenFunction::JumpDest FinallyRethrow =
4455     CGF.getJumpDestInCurrentScope("finally.rethrow");
4456
4457   // For @synchronized, call objc_sync_enter(sync.expr). The
4458   // evaluation of the expression must occur before we enter the
4459   // @synchronized.  We can't avoid a temp here because we need the
4460   // value to be preserved.  If the backend ever does liveness
4461   // correctly after setjmp, this will be unnecessary.
4462   Address SyncArgSlot = Address::invalid();
4463   if (!isTry) {
4464     llvm::Value *SyncArg =
4465       CGF.EmitScalarExpr(cast<ObjCAtSynchronizedStmt>(S).getSynchExpr());
4466     SyncArg = CGF.Builder.CreateBitCast(SyncArg, ObjCTypes.ObjectPtrTy);
4467     CGF.EmitNounwindRuntimeCall(ObjCTypes.getSyncEnterFn(), SyncArg);
4468
4469     SyncArgSlot = CGF.CreateTempAlloca(SyncArg->getType(),
4470                                        CGF.getPointerAlign(), "sync.arg");
4471     CGF.Builder.CreateStore(SyncArg, SyncArgSlot);
4472   }
4473
4474   // Allocate memory for the setjmp buffer.  This needs to be kept
4475   // live throughout the try and catch blocks.
4476   Address ExceptionData = CGF.CreateTempAlloca(ObjCTypes.ExceptionDataTy,
4477                                                CGF.getPointerAlign(),
4478                                                "exceptiondata.ptr");
4479
4480   // Create the fragile hazards.  Note that this will not capture any
4481   // of the allocas required for exception processing, but will
4482   // capture the current basic block (which extends all the way to the
4483   // setjmp call) as "before the @try".
4484   FragileHazards Hazards(CGF);
4485
4486   // Create a flag indicating whether the cleanup needs to call
4487   // objc_exception_try_exit.  This is true except when
4488   //   - no catches match and we're branching through the cleanup
4489   //     just to rethrow the exception, or
4490   //   - a catch matched and we're falling out of the catch handler.
4491   // The setjmp-safety rule here is that we should always store to this
4492   // variable in a place that dominates the branch through the cleanup
4493   // without passing through any setjmps.
4494   Address CallTryExitVar = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(),
4495                                                 CharUnits::One(),
4496                                                 "_call_try_exit");
4497
4498   // A slot containing the exception to rethrow.  Only needed when we
4499   // have both a @catch and a @finally.
4500   Address PropagatingExnVar = Address::invalid();
4501
4502   // Push a normal cleanup to leave the try scope.
4503   CGF.EHStack.pushCleanup<PerformFragileFinally>(NormalAndEHCleanup, &S,
4504                                                  SyncArgSlot,
4505                                                  CallTryExitVar,
4506                                                  ExceptionData,
4507                                                  &ObjCTypes);
4508
4509   // Enter a try block:
4510   //  - Call objc_exception_try_enter to push ExceptionData on top of
4511   //    the EH stack.
4512   CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4513                               ExceptionData.getPointer());
4514
4515   //  - Call setjmp on the exception data buffer.
4516   llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4517   llvm::Value *GEPIndexes[] = { Zero, Zero, Zero };
4518   llvm::Value *SetJmpBuffer = CGF.Builder.CreateGEP(
4519       ObjCTypes.ExceptionDataTy, ExceptionData.getPointer(), GEPIndexes,
4520       "setjmp_buffer");
4521   llvm::CallInst *SetJmpResult = CGF.EmitNounwindRuntimeCall(
4522       ObjCTypes.getSetJmpFn(), SetJmpBuffer, "setjmp_result");
4523   SetJmpResult->setCanReturnTwice();
4524
4525   // If setjmp returned 0, enter the protected block; otherwise,
4526   // branch to the handler.
4527   llvm::BasicBlock *TryBlock = CGF.createBasicBlock("try");
4528   llvm::BasicBlock *TryHandler = CGF.createBasicBlock("try.handler");
4529   llvm::Value *DidCatch =
4530     CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4531   CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
4532
4533   // Emit the protected block.
4534   CGF.EmitBlock(TryBlock);
4535   CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4536   CGF.EmitStmt(isTry ? cast<ObjCAtTryStmt>(S).getTryBody()
4537                      : cast<ObjCAtSynchronizedStmt>(S).getSynchBody());
4538
4539   CGBuilderTy::InsertPoint TryFallthroughIP = CGF.Builder.saveAndClearIP();
4540
4541   // Emit the exception handler block.
4542   CGF.EmitBlock(TryHandler);
4543
4544   // Don't optimize loads of the in-scope locals across this point.
4545   Hazards.emitWriteHazard();
4546
4547   // For a @synchronized (or a @try with no catches), just branch
4548   // through the cleanup to the rethrow block.
4549   if (!isTry || !cast<ObjCAtTryStmt>(S).getNumCatchStmts()) {
4550     // Tell the cleanup not to re-pop the exit.
4551     CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4552     CGF.EmitBranchThroughCleanup(FinallyRethrow);
4553
4554   // Otherwise, we have to match against the caught exceptions.
4555   } else {
4556     // Retrieve the exception object.  We may emit multiple blocks but
4557     // nothing can cross this so the value is already in SSA form.
4558     llvm::CallInst *Caught =
4559       CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4560                                   ExceptionData.getPointer(), "caught");
4561
4562     // Push the exception to rethrow onto the EH value stack for the
4563     // benefit of any @throws in the handlers.
4564     CGF.ObjCEHValueStack.push_back(Caught);
4565
4566     const ObjCAtTryStmt* AtTryStmt = cast<ObjCAtTryStmt>(&S);
4567
4568     bool HasFinally = (AtTryStmt->getFinallyStmt() != nullptr);
4569
4570     llvm::BasicBlock *CatchBlock = nullptr;
4571     llvm::BasicBlock *CatchHandler = nullptr;
4572     if (HasFinally) {
4573       // Save the currently-propagating exception before
4574       // objc_exception_try_enter clears the exception slot.
4575       PropagatingExnVar = CGF.CreateTempAlloca(Caught->getType(),
4576                                                CGF.getPointerAlign(),
4577                                                "propagating_exception");
4578       CGF.Builder.CreateStore(Caught, PropagatingExnVar);
4579
4580       // Enter a new exception try block (in case a @catch block
4581       // throws an exception).
4582       CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionTryEnterFn(),
4583                                   ExceptionData.getPointer());
4584
4585       llvm::CallInst *SetJmpResult =
4586         CGF.EmitNounwindRuntimeCall(ObjCTypes.getSetJmpFn(),
4587                                     SetJmpBuffer, "setjmp.result");
4588       SetJmpResult->setCanReturnTwice();
4589
4590       llvm::Value *Threw =
4591         CGF.Builder.CreateIsNotNull(SetJmpResult, "did_catch_exception");
4592
4593       CatchBlock = CGF.createBasicBlock("catch");
4594       CatchHandler = CGF.createBasicBlock("catch_for_catch");
4595       CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
4596
4597       CGF.EmitBlock(CatchBlock);
4598     }
4599
4600     CGF.Builder.CreateStore(CGF.Builder.getInt1(HasFinally), CallTryExitVar);
4601
4602     // Handle catch list. As a special case we check if everything is
4603     // matched and avoid generating code for falling off the end if
4604     // so.
4605     bool AllMatched = false;
4606     for (unsigned I = 0, N = AtTryStmt->getNumCatchStmts(); I != N; ++I) {
4607       const ObjCAtCatchStmt *CatchStmt = AtTryStmt->getCatchStmt(I);
4608
4609       const VarDecl *CatchParam = CatchStmt->getCatchParamDecl();
4610       const ObjCObjectPointerType *OPT = nullptr;
4611
4612       // catch(...) always matches.
4613       if (!CatchParam) {
4614         AllMatched = true;
4615       } else {
4616         OPT = CatchParam->getType()->getAs<ObjCObjectPointerType>();
4617
4618         // catch(id e) always matches under this ABI, since only
4619         // ObjC exceptions end up here in the first place.
4620         // FIXME: For the time being we also match id<X>; this should
4621         // be rejected by Sema instead.
4622         if (OPT && (OPT->isObjCIdType() || OPT->isObjCQualifiedIdType()))
4623           AllMatched = true;
4624       }
4625
4626       // If this is a catch-all, we don't need to test anything.
4627       if (AllMatched) {
4628         CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4629
4630         if (CatchParam) {
4631           CGF.EmitAutoVarDecl(*CatchParam);
4632           assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4633
4634           // These types work out because ConvertType(id) == i8*.
4635           EmitInitOfCatchParam(CGF, Caught, CatchParam);
4636         }
4637
4638         CGF.EmitStmt(CatchStmt->getCatchBody());
4639
4640         // The scope of the catch variable ends right here.
4641         CatchVarCleanups.ForceCleanup();
4642
4643         CGF.EmitBranchThroughCleanup(FinallyEnd);
4644         break;
4645       }
4646
4647       assert(OPT && "Unexpected non-object pointer type in @catch");
4648       const ObjCObjectType *ObjTy = OPT->getObjectType();
4649
4650       // FIXME: @catch (Class c) ?
4651       ObjCInterfaceDecl *IDecl = ObjTy->getInterface();
4652       assert(IDecl && "Catch parameter must have Objective-C type!");
4653
4654       // Check if the @catch block matches the exception object.
4655       llvm::Value *Class = EmitClassRef(CGF, IDecl);
4656
4657       llvm::Value *matchArgs[] = { Class, Caught };
4658       llvm::CallInst *Match =
4659         CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionMatchFn(),
4660                                     matchArgs, "match");
4661
4662       llvm::BasicBlock *MatchedBlock = CGF.createBasicBlock("match");
4663       llvm::BasicBlock *NextCatchBlock = CGF.createBasicBlock("catch.next");
4664
4665       CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),
4666                                MatchedBlock, NextCatchBlock);
4667
4668       // Emit the @catch block.
4669       CGF.EmitBlock(MatchedBlock);
4670
4671       // Collect any cleanups for the catch variable.  The scope lasts until
4672       // the end of the catch body.
4673       CodeGenFunction::RunCleanupsScope CatchVarCleanups(CGF);
4674
4675       CGF.EmitAutoVarDecl(*CatchParam);
4676       assert(CGF.HaveInsertPoint() && "DeclStmt destroyed insert point?");
4677
4678       // Initialize the catch variable.
4679       llvm::Value *Tmp =
4680         CGF.Builder.CreateBitCast(Caught,
4681                                   CGF.ConvertType(CatchParam->getType()));
4682       EmitInitOfCatchParam(CGF, Tmp, CatchParam);
4683
4684       CGF.EmitStmt(CatchStmt->getCatchBody());
4685
4686       // We're done with the catch variable.
4687       CatchVarCleanups.ForceCleanup();
4688
4689       CGF.EmitBranchThroughCleanup(FinallyEnd);
4690
4691       CGF.EmitBlock(NextCatchBlock);
4692     }
4693
4694     CGF.ObjCEHValueStack.pop_back();
4695
4696     // If nothing wanted anything to do with the caught exception,
4697     // kill the extract call.
4698     if (Caught->use_empty())
4699       Caught->eraseFromParent();
4700
4701     if (!AllMatched)
4702       CGF.EmitBranchThroughCleanup(FinallyRethrow);
4703
4704     if (HasFinally) {
4705       // Emit the exception handler for the @catch blocks.
4706       CGF.EmitBlock(CatchHandler);
4707
4708       // In theory we might now need a write hazard, but actually it's
4709       // unnecessary because there's no local-accessing code between
4710       // the try's write hazard and here.
4711       //Hazards.emitWriteHazard();
4712
4713       // Extract the new exception and save it to the
4714       // propagating-exception slot.
4715       assert(PropagatingExnVar.isValid());
4716       llvm::CallInst *NewCaught =
4717         CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4718                                     ExceptionData.getPointer(), "caught");
4719       CGF.Builder.CreateStore(NewCaught, PropagatingExnVar);
4720
4721       // Don't pop the catch handler; the throw already did.
4722       CGF.Builder.CreateStore(CGF.Builder.getFalse(), CallTryExitVar);
4723       CGF.EmitBranchThroughCleanup(FinallyRethrow);
4724     }
4725   }
4726
4727   // Insert read hazards as required in the new blocks.
4728   Hazards.emitHazardsInNewBlocks();
4729
4730   // Pop the cleanup.
4731   CGF.Builder.restoreIP(TryFallthroughIP);
4732   if (CGF.HaveInsertPoint())
4733     CGF.Builder.CreateStore(CGF.Builder.getTrue(), CallTryExitVar);
4734   CGF.PopCleanupBlock();
4735   CGF.EmitBlock(FinallyEnd.getBlock(), true);
4736
4737   // Emit the rethrow block.
4738   CGBuilderTy::InsertPoint SavedIP = CGF.Builder.saveAndClearIP();
4739   CGF.EmitBlock(FinallyRethrow.getBlock(), true);
4740   if (CGF.HaveInsertPoint()) {
4741     // If we have a propagating-exception variable, check it.
4742     llvm::Value *PropagatingExn;
4743     if (PropagatingExnVar.isValid()) {
4744       PropagatingExn = CGF.Builder.CreateLoad(PropagatingExnVar);
4745
4746     // Otherwise, just look in the buffer for the exception to throw.
4747     } else {
4748       llvm::CallInst *Caught =
4749         CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionExtractFn(),
4750                                     ExceptionData.getPointer());
4751       PropagatingExn = Caught;
4752     }
4753
4754     CGF.EmitNounwindRuntimeCall(ObjCTypes.getExceptionThrowFn(),
4755                                 PropagatingExn);
4756     CGF.Builder.CreateUnreachable();
4757   }
4758
4759   CGF.Builder.restoreIP(SavedIP);
4760 }
4761
4762 void CGObjCMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
4763                               const ObjCAtThrowStmt &S,
4764                               bool ClearInsertionPoint) {
4765   llvm::Value *ExceptionAsObject;
4766
4767   if (const Expr *ThrowExpr = S.getThrowExpr()) {
4768     llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4769     ExceptionAsObject =
4770       CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
4771   } else {
4772     assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4773            "Unexpected rethrow outside @catch block.");
4774     ExceptionAsObject = CGF.ObjCEHValueStack.back();
4775   }
4776
4777   CGF.EmitRuntimeCall(ObjCTypes.getExceptionThrowFn(), ExceptionAsObject)
4778     ->setDoesNotReturn();
4779   CGF.Builder.CreateUnreachable();
4780
4781   // Clear the insertion point to indicate we are in unreachable code.
4782   if (ClearInsertionPoint)
4783     CGF.Builder.ClearInsertionPoint();
4784 }
4785
4786 /// EmitObjCWeakRead - Code gen for loading value of a __weak
4787 /// object: objc_read_weak (id *src)
4788 ///
4789 llvm::Value * CGObjCMac::EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF,
4790                                           Address AddrWeakObj) {
4791   llvm::Type* DestTy = AddrWeakObj.getElementType();
4792   AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj,
4793                                           ObjCTypes.PtrObjectPtrTy);
4794   llvm::Value *read_weak =
4795     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
4796                                 AddrWeakObj.getPointer(), "weakread");
4797   read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
4798   return read_weak;
4799 }
4800
4801 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
4802 /// objc_assign_weak (id src, id *dst)
4803 ///
4804 void CGObjCMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
4805                                    llvm::Value *src, Address dst) {
4806   llvm::Type * SrcTy = src->getType();
4807   if (!isa<llvm::PointerType>(SrcTy)) {
4808     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4809     assert(Size <= 8 && "does not support size > 8");
4810     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4811                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4812     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4813   }
4814   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4815   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4816   llvm::Value *args[] = { src, dst.getPointer() };
4817   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
4818                               args, "weakassign");
4819 }
4820
4821 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
4822 /// objc_assign_global (id src, id *dst)
4823 ///
4824 void CGObjCMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
4825                                      llvm::Value *src, Address dst,
4826                                      bool threadlocal) {
4827   llvm::Type * SrcTy = src->getType();
4828   if (!isa<llvm::PointerType>(SrcTy)) {
4829     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4830     assert(Size <= 8 && "does not support size > 8");
4831     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4832                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4833     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4834   }
4835   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4836   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4837   llvm::Value *args[] = { src, dst.getPointer() };
4838   if (!threadlocal)
4839     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
4840                                 args, "globalassign");
4841   else
4842     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
4843                                 args, "threadlocalassign");
4844 }
4845
4846 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
4847 /// objc_assign_ivar (id src, id *dst, ptrdiff_t ivaroffset)
4848 ///
4849 void CGObjCMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
4850                                    llvm::Value *src, Address dst,
4851                                    llvm::Value *ivarOffset) {
4852   assert(ivarOffset && "EmitObjCIvarAssign - ivarOffset is NULL");
4853   llvm::Type * SrcTy = src->getType();
4854   if (!isa<llvm::PointerType>(SrcTy)) {
4855     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4856     assert(Size <= 8 && "does not support size > 8");
4857     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4858                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4859     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4860   }
4861   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4862   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4863   llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
4864   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
4865 }
4866
4867 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
4868 /// objc_assign_strongCast (id src, id *dst)
4869 ///
4870 void CGObjCMac::EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF,
4871                                          llvm::Value *src, Address dst) {
4872   llvm::Type * SrcTy = src->getType();
4873   if (!isa<llvm::PointerType>(SrcTy)) {
4874     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
4875     assert(Size <= 8 && "does not support size > 8");
4876     src = (Size == 4) ? CGF.Builder.CreateBitCast(src, CGM.Int32Ty)
4877                       : CGF.Builder.CreateBitCast(src, CGM.Int64Ty);
4878     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
4879   }
4880   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
4881   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
4882   llvm::Value *args[] = { src, dst.getPointer() };
4883   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
4884                               args, "strongassign");
4885 }
4886
4887 void CGObjCMac::EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF,
4888                                          Address DestPtr,
4889                                          Address SrcPtr,
4890                                          llvm::Value *size) {
4891   SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
4892   DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
4893   llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), size };
4894   CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
4895 }
4896
4897 /// EmitObjCValueForIvar - Code Gen for ivar reference.
4898 ///
4899 LValue CGObjCMac::EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF,
4900                                        QualType ObjectTy,
4901                                        llvm::Value *BaseValue,
4902                                        const ObjCIvarDecl *Ivar,
4903                                        unsigned CVRQualifiers) {
4904   const ObjCInterfaceDecl *ID =
4905     ObjectTy->getAs<ObjCObjectType>()->getInterface();
4906   return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
4907                                   EmitIvarOffset(CGF, ID, Ivar));
4908 }
4909
4910 llvm::Value *CGObjCMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
4911                                        const ObjCInterfaceDecl *Interface,
4912                                        const ObjCIvarDecl *Ivar) {
4913   uint64_t Offset = ComputeIvarBaseOffset(CGM, Interface, Ivar);
4914   return llvm::ConstantInt::get(
4915     CGM.getTypes().ConvertType(CGM.getContext().LongTy),
4916     Offset);
4917 }
4918
4919 /* *** Private Interface *** */
4920
4921 std::string CGObjCCommonMac::GetSectionName(StringRef Section,
4922                                             StringRef MachOAttributes) {
4923   switch (CGM.getTriple().getObjectFormat()) {
4924   case llvm::Triple::UnknownObjectFormat:
4925     llvm_unreachable("unexpected object file format");
4926   case llvm::Triple::MachO: {
4927     if (MachOAttributes.empty())
4928       return ("__DATA," + Section).str();
4929     return ("__DATA," + Section + "," + MachOAttributes).str();
4930   }
4931   case llvm::Triple::ELF:
4932     assert(Section.substr(0, 2) == "__" &&
4933            "expected the name to begin with __");
4934     return Section.substr(2).str();
4935   case llvm::Triple::COFF:
4936     assert(Section.substr(0, 2) == "__" &&
4937            "expected the name to begin with __");
4938     return ("." + Section.substr(2) + "$B").str();
4939   case llvm::Triple::Wasm:
4940   case llvm::Triple::XCOFF:
4941     llvm::report_fatal_error(
4942         "Objective-C support is unimplemented for object file format.");
4943   }
4944
4945   llvm_unreachable("Unhandled llvm::Triple::ObjectFormatType enum");
4946 }
4947
4948 /// EmitImageInfo - Emit the image info marker used to encode some module
4949 /// level information.
4950 ///
4951 /// See: <rdr://4810609&4810587&4810587>
4952 /// struct IMAGE_INFO {
4953 ///   unsigned version;
4954 ///   unsigned flags;
4955 /// };
4956 enum ImageInfoFlags {
4957   eImageInfo_FixAndContinue      = (1 << 0), // This flag is no longer set by clang.
4958   eImageInfo_GarbageCollected    = (1 << 1),
4959   eImageInfo_GCOnly              = (1 << 2),
4960   eImageInfo_OptimizedByDyld     = (1 << 3), // This flag is set by the dyld shared cache.
4961
4962   // A flag indicating that the module has no instances of a @synthesize of a
4963   // superclass variable. <rdar://problem/6803242>
4964   eImageInfo_CorrectedSynthesize = (1 << 4), // This flag is no longer set by clang.
4965   eImageInfo_ImageIsSimulated    = (1 << 5),
4966   eImageInfo_ClassProperties     = (1 << 6)
4967 };
4968
4969 void CGObjCCommonMac::EmitImageInfo() {
4970   unsigned version = 0; // Version is unused?
4971   std::string Section =
4972       (ObjCABI == 1)
4973           ? "__OBJC,__image_info,regular"
4974           : GetSectionName("__objc_imageinfo", "regular,no_dead_strip");
4975
4976   // Generate module-level named metadata to convey this information to the
4977   // linker and code-gen.
4978   llvm::Module &Mod = CGM.getModule();
4979
4980   // Add the ObjC ABI version to the module flags.
4981   Mod.addModuleFlag(llvm::Module::Error, "Objective-C Version", ObjCABI);
4982   Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Version",
4983                     version);
4984   Mod.addModuleFlag(llvm::Module::Error, "Objective-C Image Info Section",
4985                     llvm::MDString::get(VMContext, Section));
4986
4987   if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
4988     // Non-GC overrides those files which specify GC.
4989     Mod.addModuleFlag(llvm::Module::Override,
4990                       "Objective-C Garbage Collection", (uint32_t)0);
4991   } else {
4992     // Add the ObjC garbage collection value.
4993     Mod.addModuleFlag(llvm::Module::Error,
4994                       "Objective-C Garbage Collection",
4995                       eImageInfo_GarbageCollected);
4996
4997     if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
4998       // Add the ObjC GC Only value.
4999       Mod.addModuleFlag(llvm::Module::Error, "Objective-C GC Only",
5000                         eImageInfo_GCOnly);
5001
5002       // Require that GC be specified and set to eImageInfo_GarbageCollected.
5003       llvm::Metadata *Ops[2] = {
5004           llvm::MDString::get(VMContext, "Objective-C Garbage Collection"),
5005           llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
5006               llvm::Type::getInt32Ty(VMContext), eImageInfo_GarbageCollected))};
5007       Mod.addModuleFlag(llvm::Module::Require, "Objective-C GC Only",
5008                         llvm::MDNode::get(VMContext, Ops));
5009     }
5010   }
5011
5012   // Indicate whether we're compiling this to run on a simulator.
5013   if (CGM.getTarget().getTriple().isSimulatorEnvironment())
5014     Mod.addModuleFlag(llvm::Module::Error, "Objective-C Is Simulated",
5015                       eImageInfo_ImageIsSimulated);
5016
5017   // Indicate whether we are generating class properties.
5018   Mod.addModuleFlag(llvm::Module::Error, "Objective-C Class Properties",
5019                     eImageInfo_ClassProperties);
5020 }
5021
5022 // struct objc_module {
5023 //   unsigned long version;
5024 //   unsigned long size;
5025 //   const char *name;
5026 //   Symtab symtab;
5027 // };
5028
5029 // FIXME: Get from somewhere
5030 static const int ModuleVersion = 7;
5031
5032 void CGObjCMac::EmitModuleInfo() {
5033   uint64_t Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ModuleTy);
5034
5035   ConstantInitBuilder builder(CGM);
5036   auto values = builder.beginStruct(ObjCTypes.ModuleTy);
5037   values.addInt(ObjCTypes.LongTy, ModuleVersion);
5038   values.addInt(ObjCTypes.LongTy, Size);
5039   // This used to be the filename, now it is unused. <rdr://4327263>
5040   values.add(GetClassName(StringRef("")));
5041   values.add(EmitModuleSymbols());
5042   CreateMetadataVar("OBJC_MODULES", values,
5043                     "__OBJC,__module_info,regular,no_dead_strip",
5044                     CGM.getPointerAlign(), true);
5045 }
5046
5047 llvm::Constant *CGObjCMac::EmitModuleSymbols() {
5048   unsigned NumClasses = DefinedClasses.size();
5049   unsigned NumCategories = DefinedCategories.size();
5050
5051   // Return null if no symbols were defined.
5052   if (!NumClasses && !NumCategories)
5053     return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
5054
5055   ConstantInitBuilder builder(CGM);
5056   auto values = builder.beginStruct();
5057   values.addInt(ObjCTypes.LongTy, 0);
5058   values.addNullPointer(ObjCTypes.SelectorPtrTy);
5059   values.addInt(ObjCTypes.ShortTy, NumClasses);
5060   values.addInt(ObjCTypes.ShortTy, NumCategories);
5061
5062   // The runtime expects exactly the list of defined classes followed
5063   // by the list of defined categories, in a single array.
5064   auto array = values.beginArray(ObjCTypes.Int8PtrTy);
5065   for (unsigned i=0; i<NumClasses; i++) {
5066     const ObjCInterfaceDecl *ID = ImplementedClasses[i];
5067     assert(ID);
5068     if (ObjCImplementationDecl *IMP = ID->getImplementation())
5069       // We are implementing a weak imported interface. Give it external linkage
5070       if (ID->isWeakImported() && !IMP->isWeakImported())
5071         DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
5072
5073     array.addBitCast(DefinedClasses[i], ObjCTypes.Int8PtrTy);
5074   }
5075   for (unsigned i=0; i<NumCategories; i++)
5076     array.addBitCast(DefinedCategories[i], ObjCTypes.Int8PtrTy);
5077
5078   array.finishAndAddTo(values);
5079
5080   llvm::GlobalVariable *GV = CreateMetadataVar(
5081       "OBJC_SYMBOLS", values, "__OBJC,__symbols,regular,no_dead_strip",
5082       CGM.getPointerAlign(), true);
5083   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.SymtabPtrTy);
5084 }
5085
5086 llvm::Value *CGObjCMac::EmitClassRefFromId(CodeGenFunction &CGF,
5087                                            IdentifierInfo *II) {
5088   LazySymbols.insert(II);
5089
5090   llvm::GlobalVariable *&Entry = ClassReferences[II];
5091
5092   if (!Entry) {
5093     llvm::Constant *Casted =
5094     llvm::ConstantExpr::getBitCast(GetClassName(II->getName()),
5095                                    ObjCTypes.ClassPtrTy);
5096     Entry = CreateMetadataVar(
5097         "OBJC_CLASS_REFERENCES_", Casted,
5098         "__OBJC,__cls_refs,literal_pointers,no_dead_strip",
5099         CGM.getPointerAlign(), true);
5100   }
5101
5102   return CGF.Builder.CreateAlignedLoad(Entry, CGF.getPointerAlign());
5103 }
5104
5105 llvm::Value *CGObjCMac::EmitClassRef(CodeGenFunction &CGF,
5106                                      const ObjCInterfaceDecl *ID) {
5107   // If the class has the objc_runtime_visible attribute, we need to
5108   // use the Objective-C runtime to get the class.
5109   if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
5110     return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
5111
5112   IdentifierInfo *RuntimeName =
5113       &CGM.getContext().Idents.get(ID->getObjCRuntimeNameAsString());
5114   return EmitClassRefFromId(CGF, RuntimeName);
5115 }
5116
5117 llvm::Value *CGObjCMac::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
5118   IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
5119   return EmitClassRefFromId(CGF, II);
5120 }
5121
5122 llvm::Value *CGObjCMac::EmitSelector(CodeGenFunction &CGF, Selector Sel) {
5123   return CGF.Builder.CreateLoad(EmitSelectorAddr(CGF, Sel));
5124 }
5125
5126 Address CGObjCMac::EmitSelectorAddr(CodeGenFunction &CGF, Selector Sel) {
5127   CharUnits Align = CGF.getPointerAlign();
5128
5129   llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
5130   if (!Entry) {
5131     llvm::Constant *Casted =
5132       llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
5133                                      ObjCTypes.SelectorPtrTy);
5134     Entry = CreateMetadataVar(
5135         "OBJC_SELECTOR_REFERENCES_", Casted,
5136         "__OBJC,__message_refs,literal_pointers,no_dead_strip", Align, true);
5137     Entry->setExternallyInitialized(true);
5138   }
5139
5140   return Address(Entry, Align);
5141 }
5142
5143 llvm::Constant *CGObjCCommonMac::GetClassName(StringRef RuntimeName) {
5144     llvm::GlobalVariable *&Entry = ClassNames[RuntimeName];
5145     if (!Entry)
5146       Entry = CreateCStringLiteral(RuntimeName, ObjCLabelType::ClassName);
5147     return getConstantGEP(VMContext, Entry, 0, 0);
5148 }
5149
5150 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
5151   llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
5152       I = MethodDefinitions.find(MD);
5153   if (I != MethodDefinitions.end())
5154     return I->second;
5155
5156   return nullptr;
5157 }
5158
5159 /// GetIvarLayoutName - Returns a unique constant for the given
5160 /// ivar layout bitmap.
5161 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
5162                                        const ObjCCommonTypesHelper &ObjCTypes) {
5163   return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
5164 }
5165
5166 void IvarLayoutBuilder::visitRecord(const RecordType *RT,
5167                                     CharUnits offset) {
5168   const RecordDecl *RD = RT->getDecl();
5169
5170   // If this is a union, remember that we had one, because it might mess
5171   // up the ordering of layout entries.
5172   if (RD->isUnion())
5173     IsDisordered = true;
5174
5175   const ASTRecordLayout *recLayout = nullptr;
5176   visitAggregate(RD->field_begin(), RD->field_end(), offset,
5177                  [&](const FieldDecl *field) -> CharUnits {
5178     if (!recLayout)
5179       recLayout = &CGM.getContext().getASTRecordLayout(RD);
5180     auto offsetInBits = recLayout->getFieldOffset(field->getFieldIndex());
5181     return CGM.getContext().toCharUnitsFromBits(offsetInBits);
5182   });
5183 }
5184
5185 template <class Iterator, class GetOffsetFn>
5186 void IvarLayoutBuilder::visitAggregate(Iterator begin, Iterator end,
5187                                        CharUnits aggregateOffset,
5188                                        const GetOffsetFn &getOffset) {
5189   for (; begin != end; ++begin) {
5190     auto field = *begin;
5191
5192     // Skip over bitfields.
5193     if (field->isBitField()) {
5194       continue;
5195     }
5196
5197     // Compute the offset of the field within the aggregate.
5198     CharUnits fieldOffset = aggregateOffset + getOffset(field);
5199
5200     visitField(field, fieldOffset);
5201   }
5202 }
5203
5204 /// Collect layout information for the given fields into IvarsInfo.
5205 void IvarLayoutBuilder::visitField(const FieldDecl *field,
5206                                    CharUnits fieldOffset) {
5207   QualType fieldType = field->getType();
5208
5209   // Drill down into arrays.
5210   uint64_t numElts = 1;
5211   if (auto arrayType = CGM.getContext().getAsIncompleteArrayType(fieldType)) {
5212     numElts = 0;
5213     fieldType = arrayType->getElementType();
5214   }
5215   // Unlike incomplete arrays, constant arrays can be nested.
5216   while (auto arrayType = CGM.getContext().getAsConstantArrayType(fieldType)) {
5217     numElts *= arrayType->getSize().getZExtValue();
5218     fieldType = arrayType->getElementType();
5219   }
5220
5221   assert(!fieldType->isArrayType() && "ivar of non-constant array type?");
5222
5223   // If we ended up with a zero-sized array, we've done what we can do within
5224   // the limits of this layout encoding.
5225   if (numElts == 0) return;
5226
5227   // Recurse if the base element type is a record type.
5228   if (auto recType = fieldType->getAs<RecordType>()) {
5229     size_t oldEnd = IvarsInfo.size();
5230
5231     visitRecord(recType, fieldOffset);
5232
5233     // If we have an array, replicate the first entry's layout information.
5234     auto numEltEntries = IvarsInfo.size() - oldEnd;
5235     if (numElts != 1 && numEltEntries != 0) {
5236       CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5237       for (uint64_t eltIndex = 1; eltIndex != numElts; ++eltIndex) {
5238         // Copy the last numEltEntries onto the end of the array, adjusting
5239         // each for the element size.
5240         for (size_t i = 0; i != numEltEntries; ++i) {
5241           auto firstEntry = IvarsInfo[oldEnd + i];
5242           IvarsInfo.push_back(IvarInfo(firstEntry.Offset + eltIndex * eltSize,
5243                                        firstEntry.SizeInWords));
5244         }
5245       }
5246     }
5247
5248     return;
5249   }
5250
5251   // Classify the element type.
5252   Qualifiers::GC GCAttr = GetGCAttrTypeForType(CGM.getContext(), fieldType);
5253
5254   // If it matches what we're looking for, add an entry.
5255   if ((ForStrongLayout && GCAttr == Qualifiers::Strong)
5256       || (!ForStrongLayout && GCAttr == Qualifiers::Weak)) {
5257     assert(CGM.getContext().getTypeSizeInChars(fieldType)
5258              == CGM.getPointerSize());
5259     IvarsInfo.push_back(IvarInfo(fieldOffset, numElts));
5260   }
5261 }
5262
5263 /// buildBitmap - This routine does the horsework of taking the offsets of
5264 /// strong/weak references and creating a bitmap.  The bitmap is also
5265 /// returned in the given buffer, suitable for being passed to \c dump().
5266 llvm::Constant *IvarLayoutBuilder::buildBitmap(CGObjCCommonMac &CGObjC,
5267                                 llvm::SmallVectorImpl<unsigned char> &buffer) {
5268   // The bitmap is a series of skip/scan instructions, aligned to word
5269   // boundaries.  The skip is performed first.
5270   const unsigned char MaxNibble = 0xF;
5271   const unsigned char SkipMask = 0xF0, SkipShift = 4;
5272   const unsigned char ScanMask = 0x0F, ScanShift = 0;
5273
5274   assert(!IvarsInfo.empty() && "generating bitmap for no data");
5275
5276   // Sort the ivar info on byte position in case we encounterred a
5277   // union nested in the ivar list.
5278   if (IsDisordered) {
5279     // This isn't a stable sort, but our algorithm should handle it fine.
5280     llvm::array_pod_sort(IvarsInfo.begin(), IvarsInfo.end());
5281   } else {
5282     assert(std::is_sorted(IvarsInfo.begin(), IvarsInfo.end()));
5283   }
5284   assert(IvarsInfo.back().Offset < InstanceEnd);
5285
5286   assert(buffer.empty());
5287
5288   // Skip the next N words.
5289   auto skip = [&](unsigned numWords) {
5290     assert(numWords > 0);
5291
5292     // Try to merge into the previous byte.  Since scans happen second, we
5293     // can't do this if it includes a scan.
5294     if (!buffer.empty() && !(buffer.back() & ScanMask)) {
5295       unsigned lastSkip = buffer.back() >> SkipShift;
5296       if (lastSkip < MaxNibble) {
5297         unsigned claimed = std::min(MaxNibble - lastSkip, numWords);
5298         numWords -= claimed;
5299         lastSkip += claimed;
5300         buffer.back() = (lastSkip << SkipShift);
5301       }
5302     }
5303
5304     while (numWords >= MaxNibble) {
5305       buffer.push_back(MaxNibble << SkipShift);
5306       numWords -= MaxNibble;
5307     }
5308     if (numWords) {
5309       buffer.push_back(numWords << SkipShift);
5310     }
5311   };
5312
5313   // Scan the next N words.
5314   auto scan = [&](unsigned numWords) {
5315     assert(numWords > 0);
5316
5317     // Try to merge into the previous byte.  Since scans happen second, we can
5318     // do this even if it includes a skip.
5319     if (!buffer.empty()) {
5320       unsigned lastScan = (buffer.back() & ScanMask) >> ScanShift;
5321       if (lastScan < MaxNibble) {
5322         unsigned claimed = std::min(MaxNibble - lastScan, numWords);
5323         numWords -= claimed;
5324         lastScan += claimed;
5325         buffer.back() = (buffer.back() & SkipMask) | (lastScan << ScanShift);
5326       }
5327     }
5328
5329     while (numWords >= MaxNibble) {
5330       buffer.push_back(MaxNibble << ScanShift);
5331       numWords -= MaxNibble;
5332     }
5333     if (numWords) {
5334       buffer.push_back(numWords << ScanShift);
5335     }
5336   };
5337
5338   // One past the end of the last scan.
5339   unsigned endOfLastScanInWords = 0;
5340   const CharUnits WordSize = CGM.getPointerSize();
5341
5342   // Consider all the scan requests.
5343   for (auto &request : IvarsInfo) {
5344     CharUnits beginOfScan = request.Offset - InstanceBegin;
5345
5346     // Ignore scan requests that don't start at an even multiple of the
5347     // word size.  We can't encode them.
5348     if ((beginOfScan % WordSize) != 0) continue;
5349
5350     // Ignore scan requests that start before the instance start.
5351     // This assumes that scans never span that boundary.  The boundary
5352     // isn't the true start of the ivars, because in the fragile-ARC case
5353     // it's rounded up to word alignment, but the test above should leave
5354     // us ignoring that possibility.
5355     if (beginOfScan.isNegative()) {
5356       assert(request.Offset + request.SizeInWords * WordSize <= InstanceBegin);
5357       continue;
5358     }
5359
5360     unsigned beginOfScanInWords = beginOfScan / WordSize;
5361     unsigned endOfScanInWords = beginOfScanInWords + request.SizeInWords;
5362
5363     // If the scan starts some number of words after the last one ended,
5364     // skip forward.
5365     if (beginOfScanInWords > endOfLastScanInWords) {
5366       skip(beginOfScanInWords - endOfLastScanInWords);
5367
5368     // Otherwise, start scanning where the last left off.
5369     } else {
5370       beginOfScanInWords = endOfLastScanInWords;
5371
5372       // If that leaves us with nothing to scan, ignore this request.
5373       if (beginOfScanInWords >= endOfScanInWords) continue;
5374     }
5375
5376     // Scan to the end of the request.
5377     assert(beginOfScanInWords < endOfScanInWords);
5378     scan(endOfScanInWords - beginOfScanInWords);
5379     endOfLastScanInWords = endOfScanInWords;
5380   }
5381
5382   if (buffer.empty())
5383     return llvm::ConstantPointerNull::get(CGM.Int8PtrTy);
5384
5385   // For GC layouts, emit a skip to the end of the allocation so that we
5386   // have precise information about the entire thing.  This isn't useful
5387   // or necessary for the ARC-style layout strings.
5388   if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
5389     unsigned lastOffsetInWords =
5390       (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5391     if (lastOffsetInWords > endOfLastScanInWords) {
5392       skip(lastOffsetInWords - endOfLastScanInWords);
5393     }
5394   }
5395
5396   // Null terminate the string.
5397   buffer.push_back(0);
5398
5399   auto *Entry = CGObjC.CreateCStringLiteral(
5400       reinterpret_cast<char *>(buffer.data()), ObjCLabelType::ClassName);
5401   return getConstantGEP(CGM.getLLVMContext(), Entry, 0, 0);
5402 }
5403
5404 /// BuildIvarLayout - Builds ivar layout bitmap for the class
5405 /// implementation for the __strong or __weak case.
5406 /// The layout map displays which words in ivar list must be skipped
5407 /// and which must be scanned by GC (see below). String is built of bytes.
5408 /// Each byte is divided up in two nibbles (4-bit each). Left nibble is count
5409 /// of words to skip and right nibble is count of words to scan. So, each
5410 /// nibble represents up to 15 workds to skip or scan. Skipping the rest is
5411 /// represented by a 0x00 byte which also ends the string.
5412 /// 1. when ForStrongLayout is true, following ivars are scanned:
5413 /// - id, Class
5414 /// - object *
5415 /// - __strong anything
5416 ///
5417 /// 2. When ForStrongLayout is false, following ivars are scanned:
5418 /// - __weak anything
5419 ///
5420 llvm::Constant *
5421 CGObjCCommonMac::BuildIvarLayout(const ObjCImplementationDecl *OMD,
5422                                  CharUnits beginOffset, CharUnits endOffset,
5423                                  bool ForStrongLayout, bool HasMRCWeakIvars) {
5424   // If this is MRC, and we're either building a strong layout or there
5425   // are no weak ivars, bail out early.
5426   llvm::Type *PtrTy = CGM.Int8PtrTy;
5427   if (CGM.getLangOpts().getGC() == LangOptions::NonGC &&
5428       !CGM.getLangOpts().ObjCAutoRefCount &&
5429       (ForStrongLayout || !HasMRCWeakIvars))
5430     return llvm::Constant::getNullValue(PtrTy);
5431
5432   const ObjCInterfaceDecl *OI = OMD->getClassInterface();
5433   SmallVector<const ObjCIvarDecl*, 32> ivars;
5434
5435   // GC layout strings include the complete object layout, possibly
5436   // inaccurately in the non-fragile ABI; the runtime knows how to fix this
5437   // up.
5438   //
5439   // ARC layout strings only include the class's ivars.  In non-fragile
5440   // runtimes, that means starting at InstanceStart, rounded up to word
5441   // alignment.  In fragile runtimes, there's no InstanceStart, so it means
5442   // starting at the offset of the first ivar, rounded up to word alignment.
5443   //
5444   // MRC weak layout strings follow the ARC style.
5445   CharUnits baseOffset;
5446   if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
5447     for (const ObjCIvarDecl *IVD = OI->all_declared_ivar_begin();
5448          IVD; IVD = IVD->getNextIvar())
5449       ivars.push_back(IVD);
5450
5451     if (isNonFragileABI()) {
5452       baseOffset = beginOffset; // InstanceStart
5453     } else if (!ivars.empty()) {
5454       baseOffset =
5455         CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5456     } else {
5457       baseOffset = CharUnits::Zero();
5458     }
5459
5460     baseOffset = baseOffset.alignTo(CGM.getPointerAlign());
5461   }
5462   else {
5463     CGM.getContext().DeepCollectObjCIvars(OI, true, ivars);
5464
5465     baseOffset = CharUnits::Zero();
5466   }
5467
5468   if (ivars.empty())
5469     return llvm::Constant::getNullValue(PtrTy);
5470
5471   IvarLayoutBuilder builder(CGM, baseOffset, endOffset, ForStrongLayout);
5472
5473   builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5474                          [&](const ObjCIvarDecl *ivar) -> CharUnits {
5475       return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
5476   });
5477
5478   if (!builder.hasBitmapData())
5479     return llvm::Constant::getNullValue(PtrTy);
5480
5481   llvm::SmallVector<unsigned char, 4> buffer;
5482   llvm::Constant *C = builder.buildBitmap(*this, buffer);
5483
5484    if (CGM.getLangOpts().ObjCGCBitmapPrint && !buffer.empty()) {
5485     printf("\n%s ivar layout for class '%s': ",
5486            ForStrongLayout ? "strong" : "weak",
5487            OMD->getClassInterface()->getName().str().c_str());
5488     builder.dump(buffer);
5489   }
5490   return C;
5491 }
5492
5493 llvm::Constant *CGObjCCommonMac::GetMethodVarName(Selector Sel) {
5494   llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5495   // FIXME: Avoid std::string in "Sel.getAsString()"
5496   if (!Entry)
5497     Entry = CreateCStringLiteral(Sel.getAsString(), ObjCLabelType::MethodVarName);
5498   return getConstantGEP(VMContext, Entry, 0, 0);
5499 }
5500
5501 // FIXME: Merge into a single cstring creation function.
5502 llvm::Constant *CGObjCCommonMac::GetMethodVarName(IdentifierInfo *ID) {
5503   return GetMethodVarName(CGM.getContext().Selectors.getNullarySelector(ID));
5504 }
5505
5506 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const FieldDecl *Field) {
5507   std::string TypeStr;
5508   CGM.getContext().getObjCEncodingForType(Field->getType(), TypeStr, Field);
5509
5510   llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5511   if (!Entry)
5512     Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5513   return getConstantGEP(VMContext, Entry, 0, 0);
5514 }
5515
5516 llvm::Constant *CGObjCCommonMac::GetMethodVarType(const ObjCMethodDecl *D,
5517                                                   bool Extended) {
5518   std::string TypeStr =
5519     CGM.getContext().getObjCEncodingForMethodDecl(D, Extended);
5520
5521   llvm::GlobalVariable *&Entry = MethodVarTypes[TypeStr];
5522   if (!Entry)
5523     Entry = CreateCStringLiteral(TypeStr, ObjCLabelType::MethodVarType);
5524   return getConstantGEP(VMContext, Entry, 0, 0);
5525 }
5526
5527 // FIXME: Merge into a single cstring creation function.
5528 llvm::Constant *CGObjCCommonMac::GetPropertyName(IdentifierInfo *Ident) {
5529   llvm::GlobalVariable *&Entry = PropertyNames[Ident];
5530   if (!Entry)
5531     Entry = CreateCStringLiteral(Ident->getName(), ObjCLabelType::PropertyName);
5532   return getConstantGEP(VMContext, Entry, 0, 0);
5533 }
5534
5535 // FIXME: Merge into a single cstring creation function.
5536 // FIXME: This Decl should be more precise.
5537 llvm::Constant *
5538 CGObjCCommonMac::GetPropertyTypeString(const ObjCPropertyDecl *PD,
5539                                        const Decl *Container) {
5540   std::string TypeStr =
5541     CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
5542   return GetPropertyName(&CGM.getContext().Idents.get(TypeStr));
5543 }
5544
5545 void CGObjCCommonMac::GetNameForMethod(const ObjCMethodDecl *D,
5546                                        const ObjCContainerDecl *CD,
5547                                        SmallVectorImpl<char> &Name) {
5548   llvm::raw_svector_ostream OS(Name);
5549   assert (CD && "Missing container decl in GetNameForMethod");
5550   OS << '\01' << (D->isInstanceMethod() ? '-' : '+')
5551      << '[' << CD->getName();
5552   if (const ObjCCategoryImplDecl *CID =
5553       dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
5554     OS << '(' << *CID << ')';
5555   OS << ' ' << D->getSelector().getAsString() << ']';
5556 }
5557
5558 void CGObjCMac::FinishModule() {
5559   EmitModuleInfo();
5560
5561   // Emit the dummy bodies for any protocols which were referenced but
5562   // never defined.
5563   for (auto &entry : Protocols) {
5564     llvm::GlobalVariable *global = entry.second;
5565     if (global->hasInitializer())
5566       continue;
5567
5568     ConstantInitBuilder builder(CGM);
5569     auto values = builder.beginStruct(ObjCTypes.ProtocolTy);
5570     values.addNullPointer(ObjCTypes.ProtocolExtensionPtrTy);
5571     values.add(GetClassName(entry.first->getName()));
5572     values.addNullPointer(ObjCTypes.ProtocolListPtrTy);
5573     values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5574     values.addNullPointer(ObjCTypes.MethodDescriptionListPtrTy);
5575     values.finishAndSetAsInitializer(global);
5576     CGM.addCompilerUsedGlobal(global);
5577   }
5578
5579   // Add assembler directives to add lazy undefined symbol references
5580   // for classes which are referenced but not defined. This is
5581   // important for correct linker interaction.
5582   //
5583   // FIXME: It would be nice if we had an LLVM construct for this.
5584   if ((!LazySymbols.empty() || !DefinedSymbols.empty()) &&
5585       CGM.getTriple().isOSBinFormatMachO()) {
5586     SmallString<256> Asm;
5587     Asm += CGM.getModule().getModuleInlineAsm();
5588     if (!Asm.empty() && Asm.back() != '\n')
5589       Asm += '\n';
5590
5591     llvm::raw_svector_ostream OS(Asm);
5592     for (const auto *Sym : DefinedSymbols)
5593       OS << "\t.objc_class_name_" << Sym->getName() << "=0\n"
5594          << "\t.globl .objc_class_name_" << Sym->getName() << "\n";
5595     for (const auto *Sym : LazySymbols)
5596       OS << "\t.lazy_reference .objc_class_name_" << Sym->getName() << "\n";
5597     for (const auto &Category : DefinedCategoryNames)
5598       OS << "\t.objc_category_name_" << Category << "=0\n"
5599          << "\t.globl .objc_category_name_" << Category << "\n";
5600
5601     CGM.getModule().setModuleInlineAsm(OS.str());
5602   }
5603 }
5604
5605 CGObjCNonFragileABIMac::CGObjCNonFragileABIMac(CodeGen::CodeGenModule &cgm)
5606     : CGObjCCommonMac(cgm), ObjCTypes(cgm), ObjCEmptyCacheVar(nullptr),
5607       ObjCEmptyVtableVar(nullptr) {
5608   ObjCABI = 2;
5609 }
5610
5611 /* *** */
5612
5613 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
5614   : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
5615 {
5616   CodeGen::CodeGenTypes &Types = CGM.getTypes();
5617   ASTContext &Ctx = CGM.getContext();
5618
5619   ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
5620   IntTy = CGM.IntTy;
5621   LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
5622   Int8PtrTy = CGM.Int8PtrTy;
5623   Int8PtrPtrTy = CGM.Int8PtrPtrTy;
5624
5625   // arm64 targets use "int" ivar offset variables. All others,
5626   // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
5627   if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
5628     IvarOffsetVarTy = IntTy;
5629   else
5630     IvarOffsetVarTy = LongTy;
5631
5632   ObjectPtrTy =
5633     cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCIdType()));
5634   PtrObjectPtrTy =
5635     llvm::PointerType::getUnqual(ObjectPtrTy);
5636   SelectorPtrTy =
5637     cast<llvm::PointerType>(Types.ConvertType(Ctx.getObjCSelType()));
5638
5639   // I'm not sure I like this. The implicit coordination is a bit
5640   // gross. We should solve this in a reasonable fashion because this
5641   // is a pretty common task (match some runtime data structure with
5642   // an LLVM data structure).
5643
5644   // FIXME: This is leaked.
5645   // FIXME: Merge with rewriter code?
5646
5647   // struct _objc_super {
5648   //   id self;
5649   //   Class cls;
5650   // }
5651   RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
5652                                       Ctx.getTranslationUnitDecl(),
5653                                       SourceLocation(), SourceLocation(),
5654                                       &Ctx.Idents.get("_objc_super"));
5655   RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5656                                 nullptr, Ctx.getObjCIdType(), nullptr, nullptr,
5657                                 false, ICIS_NoInit));
5658   RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
5659                                 nullptr, Ctx.getObjCClassType(), nullptr,
5660                                 nullptr, false, ICIS_NoInit));
5661   RD->completeDefinition();
5662
5663   SuperCTy = Ctx.getTagDeclType(RD);
5664   SuperPtrCTy = Ctx.getPointerType(SuperCTy);
5665
5666   SuperTy = cast<llvm::StructType>(Types.ConvertType(SuperCTy));
5667   SuperPtrTy = llvm::PointerType::getUnqual(SuperTy);
5668
5669   // struct _prop_t {
5670   //   char *name;
5671   //   char *attributes;
5672   // }
5673   PropertyTy = llvm::StructType::create("struct._prop_t", Int8PtrTy, Int8PtrTy);
5674
5675   // struct _prop_list_t {
5676   //   uint32_t entsize;      // sizeof(struct _prop_t)
5677   //   uint32_t count_of_properties;
5678   //   struct _prop_t prop_list[count_of_properties];
5679   // }
5680   PropertyListTy = llvm::StructType::create(
5681       "struct._prop_list_t", IntTy, IntTy, llvm::ArrayType::get(PropertyTy, 0));
5682   // struct _prop_list_t *
5683   PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
5684
5685   // struct _objc_method {
5686   //   SEL _cmd;
5687   //   char *method_type;
5688   //   char *_imp;
5689   // }
5690   MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy,
5691                                       Int8PtrTy, Int8PtrTy);
5692
5693   // struct _objc_cache *
5694   CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
5695   CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
5696 }
5697
5698 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
5699   : ObjCCommonTypesHelper(cgm) {
5700   // struct _objc_method_description {
5701   //   SEL name;
5702   //   char *types;
5703   // }
5704   MethodDescriptionTy = llvm::StructType::create(
5705       "struct._objc_method_description", SelectorPtrTy, Int8PtrTy);
5706
5707   // struct _objc_method_description_list {
5708   //   int count;
5709   //   struct _objc_method_description[1];
5710   // }
5711   MethodDescriptionListTy =
5712       llvm::StructType::create("struct._objc_method_description_list", IntTy,
5713                                llvm::ArrayType::get(MethodDescriptionTy, 0));
5714
5715   // struct _objc_method_description_list *
5716   MethodDescriptionListPtrTy =
5717     llvm::PointerType::getUnqual(MethodDescriptionListTy);
5718
5719   // Protocol description structures
5720
5721   // struct _objc_protocol_extension {
5722   //   uint32_t size;  // sizeof(struct _objc_protocol_extension)
5723   //   struct _objc_method_description_list *optional_instance_methods;
5724   //   struct _objc_method_description_list *optional_class_methods;
5725   //   struct _objc_property_list *instance_properties;
5726   //   const char ** extendedMethodTypes;
5727   //   struct _objc_property_list *class_properties;
5728   // }
5729   ProtocolExtensionTy = llvm::StructType::create(
5730       "struct._objc_protocol_extension", IntTy, MethodDescriptionListPtrTy,
5731       MethodDescriptionListPtrTy, PropertyListPtrTy, Int8PtrPtrTy,
5732       PropertyListPtrTy);
5733
5734   // struct _objc_protocol_extension *
5735   ProtocolExtensionPtrTy = llvm::PointerType::getUnqual(ProtocolExtensionTy);
5736
5737   // Handle recursive construction of Protocol and ProtocolList types
5738
5739   ProtocolTy =
5740     llvm::StructType::create(VMContext, "struct._objc_protocol");
5741
5742   ProtocolListTy =
5743     llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5744   ProtocolListTy->setBody(llvm::PointerType::getUnqual(ProtocolListTy), LongTy,
5745                           llvm::ArrayType::get(ProtocolTy, 0));
5746
5747   // struct _objc_protocol {
5748   //   struct _objc_protocol_extension *isa;
5749   //   char *protocol_name;
5750   //   struct _objc_protocol **_objc_protocol_list;
5751   //   struct _objc_method_description_list *instance_methods;
5752   //   struct _objc_method_description_list *class_methods;
5753   // }
5754   ProtocolTy->setBody(ProtocolExtensionPtrTy, Int8PtrTy,
5755                       llvm::PointerType::getUnqual(ProtocolListTy),
5756                       MethodDescriptionListPtrTy, MethodDescriptionListPtrTy);
5757
5758   // struct _objc_protocol_list *
5759   ProtocolListPtrTy = llvm::PointerType::getUnqual(ProtocolListTy);
5760
5761   ProtocolPtrTy = llvm::PointerType::getUnqual(ProtocolTy);
5762
5763   // Class description structures
5764
5765   // struct _objc_ivar {
5766   //   char *ivar_name;
5767   //   char *ivar_type;
5768   //   int  ivar_offset;
5769   // }
5770   IvarTy = llvm::StructType::create("struct._objc_ivar", Int8PtrTy, Int8PtrTy,
5771                                     IntTy);
5772
5773   // struct _objc_ivar_list *
5774   IvarListTy =
5775     llvm::StructType::create(VMContext, "struct._objc_ivar_list");
5776   IvarListPtrTy = llvm::PointerType::getUnqual(IvarListTy);
5777
5778   // struct _objc_method_list *
5779   MethodListTy =
5780     llvm::StructType::create(VMContext, "struct._objc_method_list");
5781   MethodListPtrTy = llvm::PointerType::getUnqual(MethodListTy);
5782
5783   // struct _objc_class_extension *
5784   ClassExtensionTy = llvm::StructType::create(
5785       "struct._objc_class_extension", IntTy, Int8PtrTy, PropertyListPtrTy);
5786   ClassExtensionPtrTy = llvm::PointerType::getUnqual(ClassExtensionTy);
5787
5788   ClassTy = llvm::StructType::create(VMContext, "struct._objc_class");
5789
5790   // struct _objc_class {
5791   //   Class isa;
5792   //   Class super_class;
5793   //   char *name;
5794   //   long version;
5795   //   long info;
5796   //   long instance_size;
5797   //   struct _objc_ivar_list *ivars;
5798   //   struct _objc_method_list *methods;
5799   //   struct _objc_cache *cache;
5800   //   struct _objc_protocol_list *protocols;
5801   //   char *ivar_layout;
5802   //   struct _objc_class_ext *ext;
5803   // };
5804   ClassTy->setBody(llvm::PointerType::getUnqual(ClassTy),
5805                    llvm::PointerType::getUnqual(ClassTy), Int8PtrTy, LongTy,
5806                    LongTy, LongTy, IvarListPtrTy, MethodListPtrTy, CachePtrTy,
5807                    ProtocolListPtrTy, Int8PtrTy, ClassExtensionPtrTy);
5808
5809   ClassPtrTy = llvm::PointerType::getUnqual(ClassTy);
5810
5811   // struct _objc_category {
5812   //   char *category_name;
5813   //   char *class_name;
5814   //   struct _objc_method_list *instance_method;
5815   //   struct _objc_method_list *class_method;
5816   //   struct _objc_protocol_list *protocols;
5817   //   uint32_t size;  // sizeof(struct _objc_category)
5818   //   struct _objc_property_list *instance_properties;// category's @property
5819   //   struct _objc_property_list *class_properties;
5820   // }
5821   CategoryTy = llvm::StructType::create(
5822       "struct._objc_category", Int8PtrTy, Int8PtrTy, MethodListPtrTy,
5823       MethodListPtrTy, ProtocolListPtrTy, IntTy, PropertyListPtrTy,
5824       PropertyListPtrTy);
5825
5826   // Global metadata structures
5827
5828   // struct _objc_symtab {
5829   //   long sel_ref_cnt;
5830   //   SEL *refs;
5831   //   short cls_def_cnt;
5832   //   short cat_def_cnt;
5833   //   char *defs[cls_def_cnt + cat_def_cnt];
5834   // }
5835   SymtabTy = llvm::StructType::create("struct._objc_symtab", LongTy,
5836                                       SelectorPtrTy, ShortTy, ShortTy,
5837                                       llvm::ArrayType::get(Int8PtrTy, 0));
5838   SymtabPtrTy = llvm::PointerType::getUnqual(SymtabTy);
5839
5840   // struct _objc_module {
5841   //   long version;
5842   //   long size;   // sizeof(struct _objc_module)
5843   //   char *name;
5844   //   struct _objc_symtab* symtab;
5845   //  }
5846   ModuleTy = llvm::StructType::create("struct._objc_module", LongTy, LongTy,
5847                                       Int8PtrTy, SymtabPtrTy);
5848
5849   // FIXME: This is the size of the setjmp buffer and should be target
5850   // specific. 18 is what's used on 32-bit X86.
5851   uint64_t SetJmpBufferSize = 18;
5852
5853   // Exceptions
5854   llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
5855
5856   ExceptionDataTy = llvm::StructType::create(
5857       "struct._objc_exception_data",
5858       llvm::ArrayType::get(CGM.Int32Ty, SetJmpBufferSize), StackPtrTy);
5859 }
5860
5861 ObjCNonFragileABITypesHelper::ObjCNonFragileABITypesHelper(CodeGen::CodeGenModule &cgm)
5862   : ObjCCommonTypesHelper(cgm) {
5863   // struct _method_list_t {
5864   //   uint32_t entsize;  // sizeof(struct _objc_method)
5865   //   uint32_t method_count;
5866   //   struct _objc_method method_list[method_count];
5867   // }
5868   MethodListnfABITy =
5869       llvm::StructType::create("struct.__method_list_t", IntTy, IntTy,
5870                                llvm::ArrayType::get(MethodTy, 0));
5871   // struct method_list_t *
5872   MethodListnfABIPtrTy = llvm::PointerType::getUnqual(MethodListnfABITy);
5873
5874   // struct _protocol_t {
5875   //   id isa;  // NULL
5876   //   const char * const protocol_name;
5877   //   const struct _protocol_list_t * protocol_list; // super protocols
5878   //   const struct method_list_t * const instance_methods;
5879   //   const struct method_list_t * const class_methods;
5880   //   const struct method_list_t *optionalInstanceMethods;
5881   //   const struct method_list_t *optionalClassMethods;
5882   //   const struct _prop_list_t * properties;
5883   //   const uint32_t size;  // sizeof(struct _protocol_t)
5884   //   const uint32_t flags;  // = 0
5885   //   const char ** extendedMethodTypes;
5886   //   const char *demangledName;
5887   //   const struct _prop_list_t * class_properties;
5888   // }
5889
5890   // Holder for struct _protocol_list_t *
5891   ProtocolListnfABITy =
5892     llvm::StructType::create(VMContext, "struct._objc_protocol_list");
5893
5894   ProtocolnfABITy = llvm::StructType::create(
5895       "struct._protocol_t", ObjectPtrTy, Int8PtrTy,
5896       llvm::PointerType::getUnqual(ProtocolListnfABITy), MethodListnfABIPtrTy,
5897       MethodListnfABIPtrTy, MethodListnfABIPtrTy, MethodListnfABIPtrTy,
5898       PropertyListPtrTy, IntTy, IntTy, Int8PtrPtrTy, Int8PtrTy,
5899       PropertyListPtrTy);
5900
5901   // struct _protocol_t*
5902   ProtocolnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolnfABITy);
5903
5904   // struct _protocol_list_t {
5905   //   long protocol_count;   // Note, this is 32/64 bit
5906   //   struct _protocol_t *[protocol_count];
5907   // }
5908   ProtocolListnfABITy->setBody(LongTy,
5909                                llvm::ArrayType::get(ProtocolnfABIPtrTy, 0));
5910
5911   // struct _objc_protocol_list*
5912   ProtocolListnfABIPtrTy = llvm::PointerType::getUnqual(ProtocolListnfABITy);
5913
5914   // struct _ivar_t {
5915   //   unsigned [long] int *offset;  // pointer to ivar offset location
5916   //   char *name;
5917   //   char *type;
5918   //   uint32_t alignment;
5919   //   uint32_t size;
5920   // }
5921   IvarnfABITy = llvm::StructType::create(
5922       "struct._ivar_t", llvm::PointerType::getUnqual(IvarOffsetVarTy),
5923       Int8PtrTy, Int8PtrTy, IntTy, IntTy);
5924
5925   // struct _ivar_list_t {
5926   //   uint32 entsize;  // sizeof(struct _ivar_t)
5927   //   uint32 count;
5928   //   struct _iver_t list[count];
5929   // }
5930   IvarListnfABITy =
5931       llvm::StructType::create("struct._ivar_list_t", IntTy, IntTy,
5932                                llvm::ArrayType::get(IvarnfABITy, 0));
5933
5934   IvarListnfABIPtrTy = llvm::PointerType::getUnqual(IvarListnfABITy);
5935
5936   // struct _class_ro_t {
5937   //   uint32_t const flags;
5938   //   uint32_t const instanceStart;
5939   //   uint32_t const instanceSize;
5940   //   uint32_t const reserved;  // only when building for 64bit targets
5941   //   const uint8_t * const ivarLayout;
5942   //   const char *const name;
5943   //   const struct _method_list_t * const baseMethods;
5944   //   const struct _objc_protocol_list *const baseProtocols;
5945   //   const struct _ivar_list_t *const ivars;
5946   //   const uint8_t * const weakIvarLayout;
5947   //   const struct _prop_list_t * const properties;
5948   // }
5949
5950   // FIXME. Add 'reserved' field in 64bit abi mode!
5951   ClassRonfABITy = llvm::StructType::create(
5952       "struct._class_ro_t", IntTy, IntTy, IntTy, Int8PtrTy, Int8PtrTy,
5953       MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, IvarListnfABIPtrTy,
5954       Int8PtrTy, PropertyListPtrTy);
5955
5956   // ImpnfABITy - LLVM for id (*)(id, SEL, ...)
5957   llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
5958   ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
5959                  ->getPointerTo();
5960
5961   // struct _class_t {
5962   //   struct _class_t *isa;
5963   //   struct _class_t * const superclass;
5964   //   void *cache;
5965   //   IMP *vtable;
5966   //   struct class_ro_t *ro;
5967   // }
5968
5969   ClassnfABITy = llvm::StructType::create(VMContext, "struct._class_t");
5970   ClassnfABITy->setBody(llvm::PointerType::getUnqual(ClassnfABITy),
5971                         llvm::PointerType::getUnqual(ClassnfABITy), CachePtrTy,
5972                         llvm::PointerType::getUnqual(ImpnfABITy),
5973                         llvm::PointerType::getUnqual(ClassRonfABITy));
5974
5975   // LLVM for struct _class_t *
5976   ClassnfABIPtrTy = llvm::PointerType::getUnqual(ClassnfABITy);
5977
5978   // struct _category_t {
5979   //   const char * const name;
5980   //   struct _class_t *const cls;
5981   //   const struct _method_list_t * const instance_methods;
5982   //   const struct _method_list_t * const class_methods;
5983   //   const struct _protocol_list_t * const protocols;
5984   //   const struct _prop_list_t * const properties;
5985   //   const struct _prop_list_t * const class_properties;
5986   //   const uint32_t size;
5987   // }
5988   CategorynfABITy = llvm::StructType::create(
5989       "struct._category_t", Int8PtrTy, ClassnfABIPtrTy, MethodListnfABIPtrTy,
5990       MethodListnfABIPtrTy, ProtocolListnfABIPtrTy, PropertyListPtrTy,
5991       PropertyListPtrTy, IntTy);
5992
5993   // New types for nonfragile abi messaging.
5994   CodeGen::CodeGenTypes &Types = CGM.getTypes();
5995   ASTContext &Ctx = CGM.getContext();
5996
5997   // MessageRefTy - LLVM for:
5998   // struct _message_ref_t {
5999   //   IMP messenger;
6000   //   SEL name;
6001   // };
6002
6003   // First the clang type for struct _message_ref_t
6004   RecordDecl *RD = RecordDecl::Create(Ctx, TTK_Struct,
6005                                       Ctx.getTranslationUnitDecl(),
6006                                       SourceLocation(), SourceLocation(),
6007                                       &Ctx.Idents.get("_message_ref_t"));
6008   RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
6009                                 nullptr, Ctx.VoidPtrTy, nullptr, nullptr, false,
6010                                 ICIS_NoInit));
6011   RD->addDecl(FieldDecl::Create(Ctx, RD, SourceLocation(), SourceLocation(),
6012                                 nullptr, Ctx.getObjCSelType(), nullptr, nullptr,
6013                                 false, ICIS_NoInit));
6014   RD->completeDefinition();
6015
6016   MessageRefCTy = Ctx.getTagDeclType(RD);
6017   MessageRefCPtrTy = Ctx.getPointerType(MessageRefCTy);
6018   MessageRefTy = cast<llvm::StructType>(Types.ConvertType(MessageRefCTy));
6019
6020   // MessageRefPtrTy - LLVM for struct _message_ref_t*
6021   MessageRefPtrTy = llvm::PointerType::getUnqual(MessageRefTy);
6022
6023   // SuperMessageRefTy - LLVM for:
6024   // struct _super_message_ref_t {
6025   //   SUPER_IMP messenger;
6026   //   SEL name;
6027   // };
6028   SuperMessageRefTy = llvm::StructType::create("struct._super_message_ref_t",
6029                                                ImpnfABITy, SelectorPtrTy);
6030
6031   // SuperMessageRefPtrTy - LLVM for struct _super_message_ref_t*
6032   SuperMessageRefPtrTy = llvm::PointerType::getUnqual(SuperMessageRefTy);
6033
6034
6035   // struct objc_typeinfo {
6036   //   const void** vtable; // objc_ehtype_vtable + 2
6037   //   const char*  name;    // c++ typeinfo string
6038   //   Class        cls;
6039   // };
6040   EHTypeTy = llvm::StructType::create("struct._objc_typeinfo",
6041                                       llvm::PointerType::getUnqual(Int8PtrTy),
6042                                       Int8PtrTy, ClassnfABIPtrTy);
6043   EHTypePtrTy = llvm::PointerType::getUnqual(EHTypeTy);
6044 }
6045
6046 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
6047   FinishNonFragileABIModule();
6048
6049   return nullptr;
6050 }
6051
6052 void CGObjCNonFragileABIMac::AddModuleClassList(
6053     ArrayRef<llvm::GlobalValue *> Container, StringRef SymbolName,
6054     StringRef SectionName) {
6055   unsigned NumClasses = Container.size();
6056
6057   if (!NumClasses)
6058     return;
6059
6060   SmallVector<llvm::Constant*, 8> Symbols(NumClasses);
6061   for (unsigned i=0; i<NumClasses; i++)
6062     Symbols[i] = llvm::ConstantExpr::getBitCast(Container[i],
6063                                                 ObjCTypes.Int8PtrTy);
6064   llvm::Constant *Init =
6065     llvm::ConstantArray::get(llvm::ArrayType::get(ObjCTypes.Int8PtrTy,
6066                                                   Symbols.size()),
6067                              Symbols);
6068
6069   // Section name is obtained by calling GetSectionName, which returns
6070   // sections in the __DATA segment on MachO.
6071   assert((!CGM.getTriple().isOSBinFormatMachO() ||
6072           SectionName.startswith("__DATA")) &&
6073          "SectionName expected to start with __DATA on MachO");
6074   llvm::GlobalValue::LinkageTypes LT =
6075       getLinkageTypeForObjCMetadata(CGM, SectionName);
6076   llvm::GlobalVariable *GV =
6077     new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false, LT, Init,
6078                              SymbolName);
6079   GV->setAlignment(CGM.getDataLayout().getABITypeAlignment(Init->getType()));
6080   GV->setSection(SectionName);
6081   CGM.addCompilerUsedGlobal(GV);
6082 }
6083
6084 void CGObjCNonFragileABIMac::FinishNonFragileABIModule() {
6085   // nonfragile abi has no module definition.
6086
6087   // Build list of all implemented class addresses in array
6088   // L_OBJC_LABEL_CLASS_$.
6089
6090   for (unsigned i=0, NumClasses=ImplementedClasses.size(); i<NumClasses; i++) {
6091     const ObjCInterfaceDecl *ID = ImplementedClasses[i];
6092     assert(ID);
6093     if (ObjCImplementationDecl *IMP = ID->getImplementation())
6094       // We are implementing a weak imported interface. Give it external linkage
6095       if (ID->isWeakImported() && !IMP->isWeakImported()) {
6096         DefinedClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6097         DefinedMetaClasses[i]->setLinkage(llvm::GlobalVariable::ExternalLinkage);
6098       }
6099   }
6100
6101   AddModuleClassList(DefinedClasses, "OBJC_LABEL_CLASS_$",
6102                      GetSectionName("__objc_classlist",
6103                                     "regular,no_dead_strip"));
6104
6105   AddModuleClassList(DefinedNonLazyClasses, "OBJC_LABEL_NONLAZY_CLASS_$",
6106                      GetSectionName("__objc_nlclslist",
6107                                     "regular,no_dead_strip"));
6108
6109   // Build list of all implemented category addresses in array
6110   // L_OBJC_LABEL_CATEGORY_$.
6111   AddModuleClassList(DefinedCategories, "OBJC_LABEL_CATEGORY_$",
6112                      GetSectionName("__objc_catlist",
6113                                     "regular,no_dead_strip"));
6114   AddModuleClassList(DefinedStubCategories, "OBJC_LABEL_STUB_CATEGORY_$",
6115                      GetSectionName("__objc_catlist2",
6116                                     "regular,no_dead_strip"));
6117   AddModuleClassList(DefinedNonLazyCategories, "OBJC_LABEL_NONLAZY_CATEGORY_$",
6118                      GetSectionName("__objc_nlcatlist",
6119                                     "regular,no_dead_strip"));
6120
6121   EmitImageInfo();
6122 }
6123
6124 /// isVTableDispatchedSelector - Returns true if SEL is not in the list of
6125 /// VTableDispatchMethods; false otherwise. What this means is that
6126 /// except for the 19 selectors in the list, we generate 32bit-style
6127 /// message dispatch call for all the rest.
6128 bool CGObjCNonFragileABIMac::isVTableDispatchedSelector(Selector Sel) {
6129   // At various points we've experimented with using vtable-based
6130   // dispatch for all methods.
6131   switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
6132   case CodeGenOptions::Legacy:
6133     return false;
6134   case CodeGenOptions::NonLegacy:
6135     return true;
6136   case CodeGenOptions::Mixed:
6137     break;
6138   }
6139
6140   // If so, see whether this selector is in the white-list of things which must
6141   // use the new dispatch convention. We lazily build a dense set for this.
6142   if (VTableDispatchMethods.empty()) {
6143     VTableDispatchMethods.insert(GetNullarySelector("alloc"));
6144     VTableDispatchMethods.insert(GetNullarySelector("class"));
6145     VTableDispatchMethods.insert(GetNullarySelector("self"));
6146     VTableDispatchMethods.insert(GetNullarySelector("isFlipped"));
6147     VTableDispatchMethods.insert(GetNullarySelector("length"));
6148     VTableDispatchMethods.insert(GetNullarySelector("count"));
6149
6150     // These are vtable-based if GC is disabled.
6151     // Optimistically use vtable dispatch for hybrid compiles.
6152     if (CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
6153       VTableDispatchMethods.insert(GetNullarySelector("retain"));
6154       VTableDispatchMethods.insert(GetNullarySelector("release"));
6155       VTableDispatchMethods.insert(GetNullarySelector("autorelease"));
6156     }
6157
6158     VTableDispatchMethods.insert(GetUnarySelector("allocWithZone"));
6159     VTableDispatchMethods.insert(GetUnarySelector("isKindOfClass"));
6160     VTableDispatchMethods.insert(GetUnarySelector("respondsToSelector"));
6161     VTableDispatchMethods.insert(GetUnarySelector("objectForKey"));
6162     VTableDispatchMethods.insert(GetUnarySelector("objectAtIndex"));
6163     VTableDispatchMethods.insert(GetUnarySelector("isEqualToString"));
6164     VTableDispatchMethods.insert(GetUnarySelector("isEqual"));
6165
6166     // These are vtable-based if GC is enabled.
6167     // Optimistically use vtable dispatch for hybrid compiles.
6168     if (CGM.getLangOpts().getGC() != LangOptions::NonGC) {
6169       VTableDispatchMethods.insert(GetNullarySelector("hash"));
6170       VTableDispatchMethods.insert(GetUnarySelector("addObject"));
6171
6172       // "countByEnumeratingWithState:objects:count"
6173       IdentifierInfo *KeyIdents[] = {
6174         &CGM.getContext().Idents.get("countByEnumeratingWithState"),
6175         &CGM.getContext().Idents.get("objects"),
6176         &CGM.getContext().Idents.get("count")
6177       };
6178       VTableDispatchMethods.insert(
6179         CGM.getContext().Selectors.getSelector(3, KeyIdents));
6180     }
6181   }
6182
6183   return VTableDispatchMethods.count(Sel);
6184 }
6185
6186 /// BuildClassRoTInitializer - generate meta-data for:
6187 /// struct _class_ro_t {
6188 ///   uint32_t const flags;
6189 ///   uint32_t const instanceStart;
6190 ///   uint32_t const instanceSize;
6191 ///   uint32_t const reserved;  // only when building for 64bit targets
6192 ///   const uint8_t * const ivarLayout;
6193 ///   const char *const name;
6194 ///   const struct _method_list_t * const baseMethods;
6195 ///   const struct _protocol_list_t *const baseProtocols;
6196 ///   const struct _ivar_list_t *const ivars;
6197 ///   const uint8_t * const weakIvarLayout;
6198 ///   const struct _prop_list_t * const properties;
6199 /// }
6200 ///
6201 llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
6202   unsigned flags,
6203   unsigned InstanceStart,
6204   unsigned InstanceSize,
6205   const ObjCImplementationDecl *ID) {
6206   std::string ClassName = ID->getObjCRuntimeNameAsString();
6207
6208   CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
6209   CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
6210
6211   bool hasMRCWeak = false;
6212   if (CGM.getLangOpts().ObjCAutoRefCount)
6213     flags |= NonFragileABI_Class_CompiledByARC;
6214   else if ((hasMRCWeak = hasMRCWeakIvars(CGM, ID)))
6215     flags |= NonFragileABI_Class_HasMRCWeakIvars;
6216
6217   ConstantInitBuilder builder(CGM);
6218   auto values = builder.beginStruct(ObjCTypes.ClassRonfABITy);
6219
6220   values.addInt(ObjCTypes.IntTy, flags);
6221   values.addInt(ObjCTypes.IntTy, InstanceStart);
6222   values.addInt(ObjCTypes.IntTy, InstanceSize);
6223   values.add((flags & NonFragileABI_Class_Meta)
6224                 ? GetIvarLayoutName(nullptr, ObjCTypes)
6225                 : BuildStrongIvarLayout(ID, beginInstance, endInstance));
6226   values.add(GetClassName(ID->getObjCRuntimeNameAsString()));
6227
6228   // const struct _method_list_t * const baseMethods;
6229   SmallVector<const ObjCMethodDecl*, 16> methods;
6230   if (flags & NonFragileABI_Class_Meta) {
6231     for (const auto *MD : ID->class_methods())
6232       methods.push_back(MD);
6233   } else {
6234     for (const auto *MD : ID->instance_methods())
6235       methods.push_back(MD);
6236
6237     for (const auto *PID : ID->property_impls()) {
6238       if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize){
6239         ObjCPropertyDecl *PD = PID->getPropertyDecl();
6240
6241         if (auto MD = PD->getGetterMethodDecl())
6242           if (GetMethodDefinition(MD))
6243             methods.push_back(MD);
6244         if (auto MD = PD->getSetterMethodDecl())
6245           if (GetMethodDefinition(MD))
6246             methods.push_back(MD);
6247       }
6248     }
6249   }
6250
6251   values.add(emitMethodList(ID->getObjCRuntimeNameAsString(),
6252                             (flags & NonFragileABI_Class_Meta)
6253                                ? MethodListType::ClassMethods
6254                                : MethodListType::InstanceMethods,
6255                             methods));
6256
6257   const ObjCInterfaceDecl *OID = ID->getClassInterface();
6258   assert(OID && "CGObjCNonFragileABIMac::BuildClassRoTInitializer");
6259   values.add(EmitProtocolList("_OBJC_CLASS_PROTOCOLS_$_"
6260                                 + OID->getObjCRuntimeNameAsString(),
6261                               OID->all_referenced_protocol_begin(),
6262                               OID->all_referenced_protocol_end()));
6263
6264   if (flags & NonFragileABI_Class_Meta) {
6265     values.addNullPointer(ObjCTypes.IvarListnfABIPtrTy);
6266     values.add(GetIvarLayoutName(nullptr, ObjCTypes));
6267     values.add(EmitPropertyList(
6268         "_OBJC_$_CLASS_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6269         ID, ID->getClassInterface(), ObjCTypes, true));
6270   } else {
6271     values.add(EmitIvarList(ID));
6272     values.add(BuildWeakIvarLayout(ID, beginInstance, endInstance, hasMRCWeak));
6273     values.add(EmitPropertyList(
6274         "_OBJC_$_PROP_LIST_" + ID->getObjCRuntimeNameAsString(),
6275         ID, ID->getClassInterface(), ObjCTypes, false));
6276   }
6277
6278   llvm::SmallString<64> roLabel;
6279   llvm::raw_svector_ostream(roLabel)
6280       << ((flags & NonFragileABI_Class_Meta) ? "_OBJC_METACLASS_RO_$_"
6281                                              : "_OBJC_CLASS_RO_$_")
6282       << ClassName;
6283
6284   return finishAndCreateGlobal(values, roLabel, CGM);
6285 }
6286
6287 /// Build the metaclass object for a class.
6288 ///
6289 /// struct _class_t {
6290 ///   struct _class_t *isa;
6291 ///   struct _class_t * const superclass;
6292 ///   void *cache;
6293 ///   IMP *vtable;
6294 ///   struct class_ro_t *ro;
6295 /// }
6296 ///
6297 llvm::GlobalVariable *
6298 CGObjCNonFragileABIMac::BuildClassObject(const ObjCInterfaceDecl *CI,
6299                                          bool isMetaclass,
6300                                          llvm::Constant *IsAGV,
6301                                          llvm::Constant *SuperClassGV,
6302                                          llvm::Constant *ClassRoGV,
6303                                          bool HiddenVisibility) {
6304   ConstantInitBuilder builder(CGM);
6305   auto values = builder.beginStruct(ObjCTypes.ClassnfABITy);
6306   values.add(IsAGV);
6307   if (SuperClassGV) {
6308     values.add(SuperClassGV);
6309   } else {
6310     values.addNullPointer(ObjCTypes.ClassnfABIPtrTy);
6311   }
6312   values.add(ObjCEmptyCacheVar);
6313   values.add(ObjCEmptyVtableVar);
6314   values.add(ClassRoGV);
6315
6316   llvm::GlobalVariable *GV =
6317     cast<llvm::GlobalVariable>(GetClassGlobal(CI, isMetaclass, ForDefinition));
6318   values.finishAndSetAsInitializer(GV);
6319
6320   if (CGM.getTriple().isOSBinFormatMachO())
6321     GV->setSection("__DATA, __objc_data");
6322   GV->setAlignment(
6323       CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy));
6324   if (!CGM.getTriple().isOSBinFormatCOFF())
6325     if (HiddenVisibility)
6326       GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6327   return GV;
6328 }
6329
6330 bool CGObjCNonFragileABIMac::ImplementationIsNonLazy(
6331     const ObjCImplDecl *OD) const {
6332   return OD->getClassMethod(GetNullarySelector("load")) != nullptr ||
6333          OD->getClassInterface()->hasAttr<ObjCNonLazyClassAttr>() ||
6334          OD->hasAttr<ObjCNonLazyClassAttr>();
6335 }
6336
6337 void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
6338                                               uint32_t &InstanceStart,
6339                                               uint32_t &InstanceSize) {
6340   const ASTRecordLayout &RL =
6341     CGM.getContext().getASTObjCImplementationLayout(OID);
6342
6343   // InstanceSize is really instance end.
6344   InstanceSize = RL.getDataSize().getQuantity();
6345
6346   // If there are no fields, the start is the same as the end.
6347   if (!RL.getFieldCount())
6348     InstanceStart = InstanceSize;
6349   else
6350     InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
6351 }
6352
6353 static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM,
6354                                                           StringRef Name) {
6355   IdentifierInfo &II = CGM.getContext().Idents.get(Name);
6356   TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
6357   DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
6358
6359   const VarDecl *VD = nullptr;
6360   for (const auto &Result : DC->lookup(&II))
6361     if ((VD = dyn_cast<VarDecl>(Result)))
6362       break;
6363
6364   if (!VD)
6365     return llvm::GlobalValue::DLLImportStorageClass;
6366   if (VD->hasAttr<DLLExportAttr>())
6367     return llvm::GlobalValue::DLLExportStorageClass;
6368   if (VD->hasAttr<DLLImportAttr>())
6369     return llvm::GlobalValue::DLLImportStorageClass;
6370   return llvm::GlobalValue::DefaultStorageClass;
6371 }
6372
6373 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
6374   if (!ObjCEmptyCacheVar) {
6375     ObjCEmptyCacheVar =
6376         new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false,
6377                                  llvm::GlobalValue::ExternalLinkage, nullptr,
6378                                  "_objc_empty_cache");
6379     if (CGM.getTriple().isOSBinFormatCOFF())
6380       ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache"));
6381
6382     // Only OS X with deployment version <10.9 use the empty vtable symbol
6383     const llvm::Triple &Triple = CGM.getTarget().getTriple();
6384     if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9))
6385       ObjCEmptyVtableVar =
6386           new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false,
6387                                    llvm::GlobalValue::ExternalLinkage, nullptr,
6388                                    "_objc_empty_vtable");
6389     else
6390       ObjCEmptyVtableVar =
6391         llvm::ConstantPointerNull::get(ObjCTypes.ImpnfABITy->getPointerTo());
6392   }
6393
6394   // FIXME: Is this correct (that meta class size is never computed)?
6395   uint32_t InstanceStart =
6396     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ClassnfABITy);
6397   uint32_t InstanceSize = InstanceStart;
6398   uint32_t flags = NonFragileABI_Class_Meta;
6399
6400   llvm::Constant *SuperClassGV, *IsAGV;
6401
6402   const auto *CI = ID->getClassInterface();
6403   assert(CI && "CGObjCNonFragileABIMac::GenerateClass - class is 0");
6404
6405   // Build the flags for the metaclass.
6406   bool classIsHidden = (CGM.getTriple().isOSBinFormatCOFF())
6407                            ? !CI->hasAttr<DLLExportAttr>()
6408                            : CI->getVisibility() == HiddenVisibility;
6409   if (classIsHidden)
6410     flags |= NonFragileABI_Class_Hidden;
6411
6412   // FIXME: why is this flag set on the metaclass?
6413   // ObjC metaclasses have no fields and don't really get constructed.
6414   if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6415     flags |= NonFragileABI_Class_HasCXXStructors;
6416     if (!ID->hasNonZeroConstructors())
6417       flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6418   }
6419
6420   if (!CI->getSuperClass()) {
6421     // class is root
6422     flags |= NonFragileABI_Class_Root;
6423
6424     SuperClassGV = GetClassGlobal(CI, /*metaclass*/ false, NotForDefinition);
6425     IsAGV = GetClassGlobal(CI, /*metaclass*/ true, NotForDefinition);
6426   } else {
6427     // Has a root. Current class is not a root.
6428     const ObjCInterfaceDecl *Root = ID->getClassInterface();
6429     while (const ObjCInterfaceDecl *Super = Root->getSuperClass())
6430       Root = Super;
6431
6432     const auto *Super = CI->getSuperClass();
6433     IsAGV = GetClassGlobal(Root, /*metaclass*/ true, NotForDefinition);
6434     SuperClassGV = GetClassGlobal(Super, /*metaclass*/ true, NotForDefinition);
6435   }
6436
6437   llvm::GlobalVariable *CLASS_RO_GV =
6438       BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6439
6440   llvm::GlobalVariable *MetaTClass =
6441     BuildClassObject(CI, /*metaclass*/ true,
6442                      IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden);
6443   CGM.setGVProperties(MetaTClass, CI);
6444   DefinedMetaClasses.push_back(MetaTClass);
6445
6446   // Metadata for the class
6447   flags = 0;
6448   if (classIsHidden)
6449     flags |= NonFragileABI_Class_Hidden;
6450
6451   if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
6452     flags |= NonFragileABI_Class_HasCXXStructors;
6453
6454     // Set a flag to enable a runtime optimization when a class has
6455     // fields that require destruction but which don't require
6456     // anything except zero-initialization during construction.  This
6457     // is most notably true of __strong and __weak types, but you can
6458     // also imagine there being C++ types with non-trivial default
6459     // constructors that merely set all fields to null.
6460     if (!ID->hasNonZeroConstructors())
6461       flags |= NonFragileABI_Class_HasCXXDestructorOnly;
6462   }
6463
6464   if (hasObjCExceptionAttribute(CGM.getContext(), CI))
6465     flags |= NonFragileABI_Class_Exception;
6466
6467   if (!CI->getSuperClass()) {
6468     flags |= NonFragileABI_Class_Root;
6469     SuperClassGV = nullptr;
6470   } else {
6471     // Has a root. Current class is not a root.
6472     const auto *Super = CI->getSuperClass();
6473     SuperClassGV = GetClassGlobal(Super, /*metaclass*/ false, NotForDefinition);
6474   }
6475
6476   GetClassSizeInfo(ID, InstanceStart, InstanceSize);
6477   CLASS_RO_GV =
6478       BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
6479
6480   llvm::GlobalVariable *ClassMD =
6481     BuildClassObject(CI, /*metaclass*/ false,
6482                      MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden);
6483   CGM.setGVProperties(ClassMD, CI);
6484   DefinedClasses.push_back(ClassMD);
6485   ImplementedClasses.push_back(CI);
6486
6487   // Determine if this class is also "non-lazy".
6488   if (ImplementationIsNonLazy(ID))
6489     DefinedNonLazyClasses.push_back(ClassMD);
6490
6491   // Force the definition of the EHType if necessary.
6492   if (flags & NonFragileABI_Class_Exception)
6493     (void) GetInterfaceEHType(CI, ForDefinition);
6494   // Make sure method definition entries are all clear for next implementation.
6495   MethodDefinitions.clear();
6496 }
6497
6498 /// GenerateProtocolRef - This routine is called to generate code for
6499 /// a protocol reference expression; as in:
6500 /// @code
6501 ///   @protocol(Proto1);
6502 /// @endcode
6503 /// It generates a weak reference to l_OBJC_PROTOCOL_REFERENCE_$_Proto1
6504 /// which will hold address of the protocol meta-data.
6505 ///
6506 llvm::Value *CGObjCNonFragileABIMac::GenerateProtocolRef(CodeGenFunction &CGF,
6507                                                          const ObjCProtocolDecl *PD) {
6508
6509   // This routine is called for @protocol only. So, we must build definition
6510   // of protocol's meta-data (not a reference to it!)
6511   //
6512   llvm::Constant *Init =
6513     llvm::ConstantExpr::getBitCast(GetOrEmitProtocol(PD),
6514                                    ObjCTypes.getExternalProtocolPtrTy());
6515
6516   std::string ProtocolName("_OBJC_PROTOCOL_REFERENCE_$_");
6517   ProtocolName += PD->getObjCRuntimeNameAsString();
6518
6519   CharUnits Align = CGF.getPointerAlign();
6520
6521   llvm::GlobalVariable *PTGV = CGM.getModule().getGlobalVariable(ProtocolName);
6522   if (PTGV)
6523     return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6524   PTGV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), false,
6525                                   llvm::GlobalValue::WeakAnyLinkage, Init,
6526                                   ProtocolName);
6527   PTGV->setSection(GetSectionName("__objc_protorefs",
6528                                   "coalesced,no_dead_strip"));
6529   PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6530   PTGV->setAlignment(Align.getQuantity());
6531   if (!CGM.getTriple().isOSBinFormatMachO())
6532     PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolName));
6533   CGM.addUsedGlobal(PTGV);
6534   return CGF.Builder.CreateAlignedLoad(PTGV, Align);
6535 }
6536
6537 /// GenerateCategory - Build metadata for a category implementation.
6538 /// struct _category_t {
6539 ///   const char * const name;
6540 ///   struct _class_t *const cls;
6541 ///   const struct _method_list_t * const instance_methods;
6542 ///   const struct _method_list_t * const class_methods;
6543 ///   const struct _protocol_list_t * const protocols;
6544 ///   const struct _prop_list_t * const properties;
6545 ///   const struct _prop_list_t * const class_properties;
6546 ///   const uint32_t size;
6547 /// }
6548 ///
6549 void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
6550   const ObjCInterfaceDecl *Interface = OCD->getClassInterface();
6551   const char *Prefix = "_OBJC_$_CATEGORY_";
6552
6553   llvm::SmallString<64> ExtCatName(Prefix);
6554   ExtCatName += Interface->getObjCRuntimeNameAsString();
6555   ExtCatName += "_$_";
6556   ExtCatName += OCD->getNameAsString();
6557
6558   ConstantInitBuilder builder(CGM);
6559   auto values = builder.beginStruct(ObjCTypes.CategorynfABITy);
6560   values.add(GetClassName(OCD->getIdentifier()->getName()));
6561   // meta-class entry symbol
6562   values.add(GetClassGlobal(Interface, /*metaclass*/ false, NotForDefinition));
6563   std::string listName =
6564       (Interface->getObjCRuntimeNameAsString() + "_$_" + OCD->getName()).str();
6565
6566   SmallVector<const ObjCMethodDecl *, 16> instanceMethods;
6567   SmallVector<const ObjCMethodDecl *, 8> classMethods;
6568   for (const auto *MD : OCD->methods()) {
6569     if (MD->isInstanceMethod()) {
6570       instanceMethods.push_back(MD);
6571     } else {
6572       classMethods.push_back(MD);
6573     }
6574   }
6575
6576   values.add(emitMethodList(listName, MethodListType::CategoryInstanceMethods,
6577                             instanceMethods));
6578   values.add(emitMethodList(listName, MethodListType::CategoryClassMethods,
6579                             classMethods));
6580
6581   const ObjCCategoryDecl *Category =
6582     Interface->FindCategoryDeclaration(OCD->getIdentifier());
6583   if (Category) {
6584     SmallString<256> ExtName;
6585     llvm::raw_svector_ostream(ExtName) << Interface->getObjCRuntimeNameAsString() << "_$_"
6586                                        << OCD->getName();
6587     values.add(EmitProtocolList("_OBJC_CATEGORY_PROTOCOLS_$_"
6588                                    + Interface->getObjCRuntimeNameAsString() + "_$_"
6589                                    + Category->getName(),
6590                                 Category->protocol_begin(),
6591                                 Category->protocol_end()));
6592     values.add(EmitPropertyList("_OBJC_$_PROP_LIST_" + ExtName.str(),
6593                                 OCD, Category, ObjCTypes, false));
6594     values.add(EmitPropertyList("_OBJC_$_CLASS_PROP_LIST_" + ExtName.str(),
6595                                 OCD, Category, ObjCTypes, true));
6596   } else {
6597     values.addNullPointer(ObjCTypes.ProtocolListnfABIPtrTy);
6598     values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6599     values.addNullPointer(ObjCTypes.PropertyListPtrTy);
6600   }
6601
6602   unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.CategorynfABITy);
6603   values.addInt(ObjCTypes.IntTy, Size);
6604
6605   llvm::GlobalVariable *GCATV =
6606       finishAndCreateGlobal(values, ExtCatName.str(), CGM);
6607   CGM.addCompilerUsedGlobal(GCATV);
6608   if (Interface->hasAttr<ObjCClassStubAttr>())
6609     DefinedStubCategories.push_back(GCATV);
6610   else
6611     DefinedCategories.push_back(GCATV);
6612
6613   // Determine if this category is also "non-lazy".
6614   if (ImplementationIsNonLazy(OCD))
6615     DefinedNonLazyCategories.push_back(GCATV);
6616   // method definition entries must be clear for next implementation.
6617   MethodDefinitions.clear();
6618 }
6619
6620 /// emitMethodConstant - Return a struct objc_method constant.  If
6621 /// forProtocol is true, the implementation will be null; otherwise,
6622 /// the method must have a definition registered with the runtime.
6623 ///
6624 /// struct _objc_method {
6625 ///   SEL _cmd;
6626 ///   char *method_type;
6627 ///   char *_imp;
6628 /// }
6629 void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
6630                                                 const ObjCMethodDecl *MD,
6631                                                 bool forProtocol) {
6632   auto method = builder.beginStruct(ObjCTypes.MethodTy);
6633   method.addBitCast(GetMethodVarName(MD->getSelector()),
6634                     ObjCTypes.SelectorPtrTy);
6635   method.add(GetMethodVarType(MD));
6636
6637   if (forProtocol) {
6638     // Protocol methods have no implementation. So, this entry is always NULL.
6639     method.addNullPointer(ObjCTypes.Int8PtrTy);
6640   } else {
6641     llvm::Function *fn = GetMethodDefinition(MD);
6642     assert(fn && "no definition for method?");
6643     method.addBitCast(fn, ObjCTypes.Int8PtrTy);
6644   }
6645
6646   method.finishAndAddTo(builder);
6647 }
6648
6649 /// Build meta-data for method declarations.
6650 ///
6651 /// struct _method_list_t {
6652 ///   uint32_t entsize;  // sizeof(struct _objc_method)
6653 ///   uint32_t method_count;
6654 ///   struct _objc_method method_list[method_count];
6655 /// }
6656 ///
6657 llvm::Constant *
6658 CGObjCNonFragileABIMac::emitMethodList(Twine name, MethodListType kind,
6659                               ArrayRef<const ObjCMethodDecl *> methods) {
6660   // Return null for empty list.
6661   if (methods.empty())
6662     return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
6663
6664   StringRef prefix;
6665   bool forProtocol;
6666   switch (kind) {
6667   case MethodListType::CategoryInstanceMethods:
6668     prefix = "_OBJC_$_CATEGORY_INSTANCE_METHODS_";
6669     forProtocol = false;
6670     break;
6671   case MethodListType::CategoryClassMethods:
6672     prefix = "_OBJC_$_CATEGORY_CLASS_METHODS_";
6673     forProtocol = false;
6674     break;
6675   case MethodListType::InstanceMethods:
6676     prefix = "_OBJC_$_INSTANCE_METHODS_";
6677     forProtocol = false;
6678     break;
6679   case MethodListType::ClassMethods:
6680     prefix = "_OBJC_$_CLASS_METHODS_";
6681     forProtocol = false;
6682     break;
6683
6684   case MethodListType::ProtocolInstanceMethods:
6685     prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_";
6686     forProtocol = true;
6687     break;
6688   case MethodListType::ProtocolClassMethods:
6689     prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_";
6690     forProtocol = true;
6691     break;
6692   case MethodListType::OptionalProtocolInstanceMethods:
6693     prefix = "_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT_";
6694     forProtocol = true;
6695     break;
6696   case MethodListType::OptionalProtocolClassMethods:
6697     prefix = "_OBJC_$_PROTOCOL_CLASS_METHODS_OPT_";
6698     forProtocol = true;
6699     break;
6700   }
6701
6702   ConstantInitBuilder builder(CGM);
6703   auto values = builder.beginStruct();
6704
6705   // sizeof(struct _objc_method)
6706   unsigned Size = CGM.getDataLayout().getTypeAllocSize(ObjCTypes.MethodTy);
6707   values.addInt(ObjCTypes.IntTy, Size);
6708   // method_count
6709   values.addInt(ObjCTypes.IntTy, methods.size());
6710   auto methodArray = values.beginArray(ObjCTypes.MethodTy);
6711   for (auto MD : methods) {
6712     emitMethodConstant(methodArray, MD, forProtocol);
6713   }
6714   methodArray.finishAndAddTo(values);
6715
6716   llvm::GlobalVariable *GV = finishAndCreateGlobal(values, prefix + name, CGM);
6717   CGM.addCompilerUsedGlobal(GV);
6718   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.MethodListnfABIPtrTy);
6719 }
6720
6721 /// ObjCIvarOffsetVariable - Returns the ivar offset variable for
6722 /// the given ivar.
6723 llvm::GlobalVariable *
6724 CGObjCNonFragileABIMac::ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
6725                                                const ObjCIvarDecl *Ivar) {
6726   const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
6727   llvm::SmallString<64> Name("OBJC_IVAR_$_");
6728   Name += Container->getObjCRuntimeNameAsString();
6729   Name += ".";
6730   Name += Ivar->getName();
6731   llvm::GlobalVariable *IvarOffsetGV = CGM.getModule().getGlobalVariable(Name);
6732   if (!IvarOffsetGV) {
6733     IvarOffsetGV =
6734         new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.IvarOffsetVarTy,
6735                                  false, llvm::GlobalValue::ExternalLinkage,
6736                                  nullptr, Name.str());
6737     if (CGM.getTriple().isOSBinFormatCOFF()) {
6738       bool IsPrivateOrPackage =
6739           Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6740           Ivar->getAccessControl() == ObjCIvarDecl::Package;
6741
6742       const ObjCInterfaceDecl *ContainingID = Ivar->getContainingInterface();
6743
6744       if (ContainingID->hasAttr<DLLImportAttr>())
6745         IvarOffsetGV
6746             ->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6747       else if (ContainingID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage)
6748         IvarOffsetGV
6749             ->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6750     }
6751   }
6752   return IvarOffsetGV;
6753 }
6754
6755 llvm::Constant *
6756 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
6757                                           const ObjCIvarDecl *Ivar,
6758                                           unsigned long int Offset) {
6759   llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
6760   IvarOffsetGV->setInitializer(
6761       llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
6762   IvarOffsetGV->setAlignment(
6763       CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy));
6764
6765   if (!CGM.getTriple().isOSBinFormatCOFF()) {
6766     // FIXME: This matches gcc, but shouldn't the visibility be set on the use
6767     // as well (i.e., in ObjCIvarOffsetVariable).
6768     if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
6769         Ivar->getAccessControl() == ObjCIvarDecl::Package ||
6770         ID->getVisibility() == HiddenVisibility)
6771       IvarOffsetGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6772     else
6773       IvarOffsetGV->setVisibility(llvm::GlobalValue::DefaultVisibility);
6774   }
6775
6776   // If ID's layout is known, then make the global constant. This serves as a
6777   // useful assertion: we'll never use this variable to calculate ivar offsets,
6778   // so if the runtime tries to patch it then we should crash.
6779   if (isClassLayoutKnownStatically(ID))
6780     IvarOffsetGV->setConstant(true);
6781
6782   if (CGM.getTriple().isOSBinFormatMachO())
6783     IvarOffsetGV->setSection("__DATA, __objc_ivar");
6784   return IvarOffsetGV;
6785 }
6786
6787 /// EmitIvarList - Emit the ivar list for the given
6788 /// implementation. The return value has type
6789 /// IvarListnfABIPtrTy.
6790 ///  struct _ivar_t {
6791 ///   unsigned [long] int *offset;  // pointer to ivar offset location
6792 ///   char *name;
6793 ///   char *type;
6794 ///   uint32_t alignment;
6795 ///   uint32_t size;
6796 /// }
6797 /// struct _ivar_list_t {
6798 ///   uint32 entsize;  // sizeof(struct _ivar_t)
6799 ///   uint32 count;
6800 ///   struct _iver_t list[count];
6801 /// }
6802 ///
6803
6804 llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
6805   const ObjCImplementationDecl *ID) {
6806
6807   ConstantInitBuilder builder(CGM);
6808   auto ivarList = builder.beginStruct();
6809   ivarList.addInt(ObjCTypes.IntTy,
6810                   CGM.getDataLayout().getTypeAllocSize(ObjCTypes.IvarnfABITy));
6811   auto ivarCountSlot = ivarList.addPlaceholder();
6812   auto ivars = ivarList.beginArray(ObjCTypes.IvarnfABITy);
6813
6814   const ObjCInterfaceDecl *OID = ID->getClassInterface();
6815   assert(OID && "CGObjCNonFragileABIMac::EmitIvarList - null interface");
6816
6817   // FIXME. Consolidate this with similar code in GenerateClass.
6818
6819   for (const ObjCIvarDecl *IVD = OID->all_declared_ivar_begin();
6820        IVD; IVD = IVD->getNextIvar()) {
6821     // Ignore unnamed bit-fields.
6822     if (!IVD->getDeclName())
6823       continue;
6824
6825     auto ivar = ivars.beginStruct(ObjCTypes.IvarnfABITy);
6826     ivar.add(EmitIvarOffsetVar(ID->getClassInterface(), IVD,
6827                                ComputeIvarBaseOffset(CGM, ID, IVD)));
6828     ivar.add(GetMethodVarName(IVD->getIdentifier()));
6829     ivar.add(GetMethodVarType(IVD));
6830     llvm::Type *FieldTy =
6831       CGM.getTypes().ConvertTypeForMem(IVD->getType());
6832     unsigned Size = CGM.getDataLayout().getTypeAllocSize(FieldTy);
6833     unsigned Align = CGM.getContext().getPreferredTypeAlign(
6834       IVD->getType().getTypePtr()) >> 3;
6835     Align = llvm::Log2_32(Align);
6836     ivar.addInt(ObjCTypes.IntTy, Align);
6837     // NOTE. Size of a bitfield does not match gcc's, because of the
6838     // way bitfields are treated special in each. But I am told that
6839     // 'size' for bitfield ivars is ignored by the runtime so it does
6840     // not matter.  If it matters, there is enough info to get the
6841     // bitfield right!
6842     ivar.addInt(ObjCTypes.IntTy, Size);
6843     ivar.finishAndAddTo(ivars);
6844   }
6845   // Return null for empty list.
6846   if (ivars.empty()) {
6847     ivars.abandon();
6848     ivarList.abandon();
6849     return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
6850   }
6851
6852   auto ivarCount = ivars.size();
6853   ivars.finishAndAddTo(ivarList);
6854   ivarList.fillPlaceholderWithInt(ivarCountSlot, ObjCTypes.IntTy, ivarCount);
6855
6856   const char *Prefix = "_OBJC_$_INSTANCE_VARIABLES_";
6857   llvm::GlobalVariable *GV = finishAndCreateGlobal(
6858       ivarList, Prefix + OID->getObjCRuntimeNameAsString(), CGM);
6859   CGM.addCompilerUsedGlobal(GV);
6860   return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.IvarListnfABIPtrTy);
6861 }
6862
6863 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocolRef(
6864   const ObjCProtocolDecl *PD) {
6865   llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
6866
6867   if (!Entry) {
6868     // We use the initializer as a marker of whether this is a forward
6869     // reference or not. At module finalization we add the empty
6870     // contents for protocols which were referenced but never defined.
6871     llvm::SmallString<64> Protocol;
6872     llvm::raw_svector_ostream(Protocol) << "_OBJC_PROTOCOL_$_"
6873                                         << PD->getObjCRuntimeNameAsString();
6874
6875     Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABITy,
6876                                      false, llvm::GlobalValue::ExternalLinkage,
6877                                      nullptr, Protocol);
6878     if (!CGM.getTriple().isOSBinFormatMachO())
6879       Entry->setComdat(CGM.getModule().getOrInsertComdat(Protocol));
6880   }
6881
6882   return Entry;
6883 }
6884
6885 /// GetOrEmitProtocol - Generate the protocol meta-data:
6886 /// @code
6887 /// struct _protocol_t {
6888 ///   id isa;  // NULL
6889 ///   const char * const protocol_name;
6890 ///   const struct _protocol_list_t * protocol_list; // super protocols
6891 ///   const struct method_list_t * const instance_methods;
6892 ///   const struct method_list_t * const class_methods;
6893 ///   const struct method_list_t *optionalInstanceMethods;
6894 ///   const struct method_list_t *optionalClassMethods;
6895 ///   const struct _prop_list_t * properties;
6896 ///   const uint32_t size;  // sizeof(struct _protocol_t)
6897 ///   const uint32_t flags;  // = 0
6898 ///   const char ** extendedMethodTypes;
6899 ///   const char *demangledName;
6900 ///   const struct _prop_list_t * class_properties;
6901 /// }
6902 /// @endcode
6903 ///
6904
6905 llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
6906   const ObjCProtocolDecl *PD) {
6907   llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
6908
6909   // Early exit if a defining object has already been generated.
6910   if (Entry && Entry->hasInitializer())
6911     return Entry;
6912
6913   // Use the protocol definition, if there is one.
6914   assert(PD->hasDefinition() &&
6915          "emitting protocol metadata without definition");
6916   PD = PD->getDefinition();
6917
6918   auto methodLists = ProtocolMethodLists::get(PD);
6919
6920   ConstantInitBuilder builder(CGM);
6921   auto values = builder.beginStruct(ObjCTypes.ProtocolnfABITy);
6922
6923   // isa is NULL
6924   values.addNullPointer(ObjCTypes.ObjectPtrTy);
6925   values.add(GetClassName(PD->getObjCRuntimeNameAsString()));
6926   values.add(EmitProtocolList("_OBJC_$_PROTOCOL_REFS_"
6927                                 + PD->getObjCRuntimeNameAsString(),
6928                                PD->protocol_begin(),
6929                                PD->protocol_end()));
6930   values.add(methodLists.emitMethodList(this, PD,
6931                                  ProtocolMethodLists::RequiredInstanceMethods));
6932   values.add(methodLists.emitMethodList(this, PD,
6933                                  ProtocolMethodLists::RequiredClassMethods));
6934   values.add(methodLists.emitMethodList(this, PD,
6935                                  ProtocolMethodLists::OptionalInstanceMethods));
6936   values.add(methodLists.emitMethodList(this, PD,
6937                                  ProtocolMethodLists::OptionalClassMethods));
6938   values.add(EmitPropertyList(
6939                "_OBJC_$_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6940                nullptr, PD, ObjCTypes, false));
6941   uint32_t Size =
6942     CGM.getDataLayout().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
6943   values.addInt(ObjCTypes.IntTy, Size);
6944   values.addInt(ObjCTypes.IntTy, 0);
6945   values.add(EmitProtocolMethodTypes("_OBJC_$_PROTOCOL_METHOD_TYPES_"
6946                                        + PD->getObjCRuntimeNameAsString(),
6947                                      methodLists.emitExtendedTypesArray(this),
6948                                      ObjCTypes));
6949
6950   // const char *demangledName;
6951   values.addNullPointer(ObjCTypes.Int8PtrTy);
6952
6953   values.add(EmitPropertyList(
6954       "_OBJC_$_CLASS_PROP_LIST_" + PD->getObjCRuntimeNameAsString(),
6955       nullptr, PD, ObjCTypes, true));
6956
6957   if (Entry) {
6958     // Already created, fix the linkage and update the initializer.
6959     Entry->setLinkage(llvm::GlobalValue::WeakAnyLinkage);
6960     values.finishAndSetAsInitializer(Entry);
6961   } else {
6962     llvm::SmallString<64> symbolName;
6963     llvm::raw_svector_ostream(symbolName)
6964       << "_OBJC_PROTOCOL_$_" << PD->getObjCRuntimeNameAsString();
6965
6966     Entry = values.finishAndCreateGlobal(symbolName, CGM.getPointerAlign(),
6967                                          /*constant*/ false,
6968                                          llvm::GlobalValue::WeakAnyLinkage);
6969     if (!CGM.getTriple().isOSBinFormatMachO())
6970       Entry->setComdat(CGM.getModule().getOrInsertComdat(symbolName));
6971
6972     Protocols[PD->getIdentifier()] = Entry;
6973   }
6974   Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
6975   CGM.addUsedGlobal(Entry);
6976
6977   // Use this protocol meta-data to build protocol list table in section
6978   // __DATA, __objc_protolist
6979   llvm::SmallString<64> ProtocolRef;
6980   llvm::raw_svector_ostream(ProtocolRef) << "_OBJC_LABEL_PROTOCOL_$_"
6981                                          << PD->getObjCRuntimeNameAsString();
6982
6983   llvm::GlobalVariable *PTGV =
6984     new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ProtocolnfABIPtrTy,
6985                              false, llvm::GlobalValue::WeakAnyLinkage, Entry,
6986                              ProtocolRef);
6987   if (!CGM.getTriple().isOSBinFormatMachO())
6988     PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef));
6989   PTGV->setAlignment(
6990     CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy));
6991   PTGV->setSection(GetSectionName("__objc_protolist",
6992                                   "coalesced,no_dead_strip"));
6993   PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
6994   CGM.addUsedGlobal(PTGV);
6995   return Entry;
6996 }
6997
6998 /// EmitProtocolList - Generate protocol list meta-data:
6999 /// @code
7000 /// struct _protocol_list_t {
7001 ///   long protocol_count;   // Note, this is 32/64 bit
7002 ///   struct _protocol_t[protocol_count];
7003 /// }
7004 /// @endcode
7005 ///
7006 llvm::Constant *
7007 CGObjCNonFragileABIMac::EmitProtocolList(Twine Name,
7008                                       ObjCProtocolDecl::protocol_iterator begin,
7009                                       ObjCProtocolDecl::protocol_iterator end) {
7010   SmallVector<llvm::Constant *, 16> ProtocolRefs;
7011
7012   // Just return null for empty protocol lists
7013   if (begin == end)
7014     return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
7015
7016   // FIXME: We shouldn't need to do this lookup here, should we?
7017   SmallString<256> TmpName;
7018   Name.toVector(TmpName);
7019   llvm::GlobalVariable *GV =
7020     CGM.getModule().getGlobalVariable(TmpName.str(), true);
7021   if (GV)
7022     return llvm::ConstantExpr::getBitCast(GV, ObjCTypes.ProtocolListnfABIPtrTy);
7023
7024   ConstantInitBuilder builder(CGM);
7025   auto values = builder.beginStruct();
7026   auto countSlot = values.addPlaceholder();
7027
7028   // A null-terminated array of protocols.
7029   auto array = values.beginArray(ObjCTypes.ProtocolnfABIPtrTy);
7030   for (; begin != end; ++begin)
7031     array.add(GetProtocolRef(*begin));  // Implemented???
7032   auto count = array.size();
7033   array.addNullPointer(ObjCTypes.ProtocolnfABIPtrTy);
7034
7035   array.finishAndAddTo(values);
7036   values.fillPlaceholderWithInt(countSlot, ObjCTypes.LongTy, count);
7037
7038   GV = finishAndCreateGlobal(values, Name, CGM);
7039   CGM.addCompilerUsedGlobal(GV);
7040   return llvm::ConstantExpr::getBitCast(GV,
7041                                         ObjCTypes.ProtocolListnfABIPtrTy);
7042 }
7043
7044 /// EmitObjCValueForIvar - Code Gen for nonfragile ivar reference.
7045 /// This code gen. amounts to generating code for:
7046 /// @code
7047 /// (type *)((char *)base + _OBJC_IVAR_$_.ivar;
7048 /// @encode
7049 ///
7050 LValue CGObjCNonFragileABIMac::EmitObjCValueForIvar(
7051                                                CodeGen::CodeGenFunction &CGF,
7052                                                QualType ObjectTy,
7053                                                llvm::Value *BaseValue,
7054                                                const ObjCIvarDecl *Ivar,
7055                                                unsigned CVRQualifiers) {
7056   ObjCInterfaceDecl *ID = ObjectTy->getAs<ObjCObjectType>()->getInterface();
7057   llvm::Value *Offset = EmitIvarOffset(CGF, ID, Ivar);
7058   return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
7059                                   Offset);
7060 }
7061
7062 llvm::Value *
7063 CGObjCNonFragileABIMac::EmitIvarOffset(CodeGen::CodeGenFunction &CGF,
7064                                        const ObjCInterfaceDecl *Interface,
7065                                        const ObjCIvarDecl *Ivar) {
7066   llvm::Value *IvarOffsetValue;
7067   if (isClassLayoutKnownStatically(Interface)) {
7068     IvarOffsetValue = llvm::ConstantInt::get(
7069         ObjCTypes.IvarOffsetVarTy,
7070         ComputeIvarBaseOffset(CGM, Interface->getImplementation(), Ivar));
7071   } else {
7072     llvm::GlobalVariable *GV = ObjCIvarOffsetVariable(Interface, Ivar);
7073     IvarOffsetValue =
7074         CGF.Builder.CreateAlignedLoad(GV, CGF.getSizeAlign(), "ivar");
7075     if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
7076       cast<llvm::LoadInst>(IvarOffsetValue)
7077           ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7078                         llvm::MDNode::get(VMContext, None));
7079   }
7080
7081   // This could be 32bit int or 64bit integer depending on the architecture.
7082   // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
7083   //  as this is what caller always expects.
7084   if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
7085     IvarOffsetValue = CGF.Builder.CreateIntCast(
7086         IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
7087   return IvarOffsetValue;
7088 }
7089
7090 static void appendSelectorForMessageRefTable(std::string &buffer,
7091                                              Selector selector) {
7092   if (selector.isUnarySelector()) {
7093     buffer += selector.getNameForSlot(0);
7094     return;
7095   }
7096
7097   for (unsigned i = 0, e = selector.getNumArgs(); i != e; ++i) {
7098     buffer += selector.getNameForSlot(i);
7099     buffer += '_';
7100   }
7101 }
7102
7103 /// Emit a "vtable" message send.  We emit a weak hidden-visibility
7104 /// struct, initially containing the selector pointer and a pointer to
7105 /// a "fixup" variant of the appropriate objc_msgSend.  To call, we
7106 /// load and call the function pointer, passing the address of the
7107 /// struct as the second parameter.  The runtime determines whether
7108 /// the selector is currently emitted using vtable dispatch; if so, it
7109 /// substitutes a stub function which simply tail-calls through the
7110 /// appropriate vtable slot, and if not, it substitues a stub function
7111 /// which tail-calls objc_msgSend.  Both stubs adjust the selector
7112 /// argument to correctly point to the selector.
7113 RValue
7114 CGObjCNonFragileABIMac::EmitVTableMessageSend(CodeGenFunction &CGF,
7115                                               ReturnValueSlot returnSlot,
7116                                               QualType resultType,
7117                                               Selector selector,
7118                                               llvm::Value *arg0,
7119                                               QualType arg0Type,
7120                                               bool isSuper,
7121                                               const CallArgList &formalArgs,
7122                                               const ObjCMethodDecl *method) {
7123   // Compute the actual arguments.
7124   CallArgList args;
7125
7126   // First argument: the receiver / super-call structure.
7127   if (!isSuper)
7128     arg0 = CGF.Builder.CreateBitCast(arg0, ObjCTypes.ObjectPtrTy);
7129   args.add(RValue::get(arg0), arg0Type);
7130
7131   // Second argument: a pointer to the message ref structure.  Leave
7132   // the actual argument value blank for now.
7133   args.add(RValue::get(nullptr), ObjCTypes.MessageRefCPtrTy);
7134
7135   args.insert(args.end(), formalArgs.begin(), formalArgs.end());
7136
7137   MessageSendInfo MSI = getMessageSendInfo(method, resultType, args);
7138
7139   NullReturnState nullReturn;
7140
7141   // Find the function to call and the mangled name for the message
7142   // ref structure.  Using a different mangled name wouldn't actually
7143   // be a problem; it would just be a waste.
7144   //
7145   // The runtime currently never uses vtable dispatch for anything
7146   // except normal, non-super message-sends.
7147   // FIXME: don't use this for that.
7148   llvm::FunctionCallee fn = nullptr;
7149   std::string messageRefName("_");
7150   if (CGM.ReturnSlotInterferesWithArgs(MSI.CallInfo)) {
7151     if (isSuper) {
7152       fn = ObjCTypes.getMessageSendSuper2StretFixupFn();
7153       messageRefName += "objc_msgSendSuper2_stret_fixup";
7154     } else {
7155       nullReturn.init(CGF, arg0);
7156       fn = ObjCTypes.getMessageSendStretFixupFn();
7157       messageRefName += "objc_msgSend_stret_fixup";
7158     }
7159   } else if (!isSuper && CGM.ReturnTypeUsesFPRet(resultType)) {
7160     fn = ObjCTypes.getMessageSendFpretFixupFn();
7161     messageRefName += "objc_msgSend_fpret_fixup";
7162   } else {
7163     if (isSuper) {
7164       fn = ObjCTypes.getMessageSendSuper2FixupFn();
7165       messageRefName += "objc_msgSendSuper2_fixup";
7166     } else {
7167       fn = ObjCTypes.getMessageSendFixupFn();
7168       messageRefName += "objc_msgSend_fixup";
7169     }
7170   }
7171   assert(fn && "CGObjCNonFragileABIMac::EmitMessageSend");
7172   messageRefName += '_';
7173
7174   // Append the selector name, except use underscores anywhere we
7175   // would have used colons.
7176   appendSelectorForMessageRefTable(messageRefName, selector);
7177
7178   llvm::GlobalVariable *messageRef
7179     = CGM.getModule().getGlobalVariable(messageRefName);
7180   if (!messageRef) {
7181     // Build the message ref structure.
7182     ConstantInitBuilder builder(CGM);
7183     auto values = builder.beginStruct();
7184     values.add(cast<llvm::Constant>(fn.getCallee()));
7185     values.add(GetMethodVarName(selector));
7186     messageRef = values.finishAndCreateGlobal(messageRefName,
7187                                               CharUnits::fromQuantity(16),
7188                                               /*constant*/ false,
7189                                         llvm::GlobalValue::WeakAnyLinkage);
7190     messageRef->setVisibility(llvm::GlobalValue::HiddenVisibility);
7191     messageRef->setSection(GetSectionName("__objc_msgrefs", "coalesced"));
7192   }
7193
7194   bool requiresnullCheck = false;
7195   if (CGM.getLangOpts().ObjCAutoRefCount && method)
7196     for (const auto *ParamDecl : method->parameters()) {
7197       if (ParamDecl->hasAttr<NSConsumedAttr>()) {
7198         if (!nullReturn.NullBB)
7199           nullReturn.init(CGF, arg0);
7200         requiresnullCheck = true;
7201         break;
7202       }
7203     }
7204
7205   Address mref =
7206     Address(CGF.Builder.CreateBitCast(messageRef, ObjCTypes.MessageRefPtrTy),
7207             CGF.getPointerAlign());
7208
7209   // Update the message ref argument.
7210   args[1].setRValue(RValue::get(mref.getPointer()));
7211
7212   // Load the function to call from the message ref table.
7213   Address calleeAddr = CGF.Builder.CreateStructGEP(mref, 0);
7214   llvm::Value *calleePtr = CGF.Builder.CreateLoad(calleeAddr, "msgSend_fn");
7215
7216   calleePtr = CGF.Builder.CreateBitCast(calleePtr, MSI.MessengerType);
7217   CGCallee callee(CGCalleeInfo(), calleePtr);
7218
7219   RValue result = CGF.EmitCall(MSI.CallInfo, callee, returnSlot, args);
7220   return nullReturn.complete(CGF, returnSlot, result, resultType, formalArgs,
7221                              requiresnullCheck ? method : nullptr);
7222 }
7223
7224 /// Generate code for a message send expression in the nonfragile abi.
7225 CodeGen::RValue
7226 CGObjCNonFragileABIMac::GenerateMessageSend(CodeGen::CodeGenFunction &CGF,
7227                                             ReturnValueSlot Return,
7228                                             QualType ResultType,
7229                                             Selector Sel,
7230                                             llvm::Value *Receiver,
7231                                             const CallArgList &CallArgs,
7232                                             const ObjCInterfaceDecl *Class,
7233                                             const ObjCMethodDecl *Method) {
7234   return isVTableDispatchedSelector(Sel)
7235     ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7236                             Receiver, CGF.getContext().getObjCIdType(),
7237                             false, CallArgs, Method)
7238     : EmitMessageSend(CGF, Return, ResultType,
7239                       EmitSelector(CGF, Sel),
7240                       Receiver, CGF.getContext().getObjCIdType(),
7241                       false, CallArgs, Method, Class, ObjCTypes);
7242 }
7243
7244 llvm::Constant *
7245 CGObjCNonFragileABIMac::GetClassGlobal(const ObjCInterfaceDecl *ID,
7246                                        bool metaclass,
7247                                        ForDefinition_t isForDefinition) {
7248   auto prefix =
7249     (metaclass ? getMetaclassSymbolPrefix() : getClassSymbolPrefix());
7250   return GetClassGlobal((prefix + ID->getObjCRuntimeNameAsString()).str(),
7251                         isForDefinition,
7252                         ID->isWeakImported(),
7253                         !isForDefinition
7254                           && CGM.getTriple().isOSBinFormatCOFF()
7255                           && ID->hasAttr<DLLImportAttr>());
7256 }
7257
7258 llvm::Constant *
7259 CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
7260                                        ForDefinition_t IsForDefinition,
7261                                        bool Weak, bool DLLImport) {
7262   llvm::GlobalValue::LinkageTypes L =
7263       Weak ? llvm::GlobalValue::ExternalWeakLinkage
7264            : llvm::GlobalValue::ExternalLinkage;
7265
7266   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
7267   if (!GV || GV->getType() != ObjCTypes.ClassnfABITy->getPointerTo()) {
7268     auto *NewGV = new llvm::GlobalVariable(ObjCTypes.ClassnfABITy, false, L,
7269                                            nullptr, Name);
7270
7271     if (DLLImport)
7272       NewGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
7273
7274     if (GV) {
7275       GV->replaceAllUsesWith(
7276           llvm::ConstantExpr::getBitCast(NewGV, GV->getType()));
7277       GV->eraseFromParent();
7278     }
7279     GV = NewGV;
7280     CGM.getModule().getGlobalList().push_back(GV);
7281   }
7282
7283   assert(GV->getLinkage() == L);
7284   return GV;
7285 }
7286
7287 llvm::Constant *
7288 CGObjCNonFragileABIMac::GetClassGlobalForClassRef(const ObjCInterfaceDecl *ID) {
7289   llvm::Constant *ClassGV = GetClassGlobal(ID, /*metaclass*/ false,
7290                                            NotForDefinition);
7291
7292   if (!ID->hasAttr<ObjCClassStubAttr>())
7293     return ClassGV;
7294
7295   ClassGV = llvm::ConstantExpr::getPointerCast(ClassGV, ObjCTypes.Int8PtrTy);
7296
7297   // Stub classes are pointer-aligned. Classrefs pointing at stub classes
7298   // must set the least significant bit set to 1.
7299   auto *Idx = llvm::ConstantInt::get(CGM.Int32Ty, 1);
7300   return llvm::ConstantExpr::getGetElementPtr(CGM.Int8Ty, ClassGV, Idx);
7301 }
7302
7303 llvm::Value *
7304 CGObjCNonFragileABIMac::EmitLoadOfClassRef(CodeGenFunction &CGF,
7305                                            const ObjCInterfaceDecl *ID,
7306                                            llvm::GlobalVariable *Entry) {
7307   if (ID && ID->hasAttr<ObjCClassStubAttr>()) {
7308     // Classrefs pointing at Objective-C stub classes must be loaded by calling
7309     // a special runtime function.
7310     return CGF.EmitRuntimeCall(
7311       ObjCTypes.getLoadClassrefFn(), Entry, "load_classref_result");
7312   }
7313
7314   CharUnits Align = CGF.getPointerAlign();
7315   return CGF.Builder.CreateAlignedLoad(Entry, Align);
7316 }
7317
7318 llvm::Value *
7319 CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
7320                                            IdentifierInfo *II,
7321                                            const ObjCInterfaceDecl *ID) {
7322   llvm::GlobalVariable *&Entry = ClassReferences[II];
7323
7324   if (!Entry) {
7325     llvm::Constant *ClassGV;
7326     if (ID) {
7327       ClassGV = GetClassGlobalForClassRef(ID);
7328     } else {
7329       ClassGV = GetClassGlobal((getClassSymbolPrefix() + II->getName()).str(),
7330                                NotForDefinition);
7331       assert(ClassGV->getType() == ObjCTypes.ClassnfABIPtrTy &&
7332              "classref was emitted with the wrong type?");
7333     }
7334
7335     std::string SectionName =
7336         GetSectionName("__objc_classrefs", "regular,no_dead_strip");
7337     Entry = new llvm::GlobalVariable(
7338         CGM.getModule(), ClassGV->getType(), false,
7339         getLinkageTypeForObjCMetadata(CGM, SectionName), ClassGV,
7340         "OBJC_CLASSLIST_REFERENCES_$_");
7341     Entry->setAlignment(CGF.getPointerAlign().getQuantity());
7342     if (!ID || !ID->hasAttr<ObjCClassStubAttr>())
7343       Entry->setSection(SectionName);
7344
7345     CGM.addCompilerUsedGlobal(Entry);
7346   }
7347
7348   return EmitLoadOfClassRef(CGF, ID, Entry);
7349 }
7350
7351 llvm::Value *CGObjCNonFragileABIMac::EmitClassRef(CodeGenFunction &CGF,
7352                                                   const ObjCInterfaceDecl *ID) {
7353   // If the class has the objc_runtime_visible attribute, we need to
7354   // use the Objective-C runtime to get the class.
7355   if (ID->hasAttr<ObjCRuntimeVisibleAttr>())
7356     return EmitClassRefViaRuntime(CGF, ID, ObjCTypes);
7357
7358   return EmitClassRefFromId(CGF, ID->getIdentifier(), ID);
7359 }
7360
7361 llvm::Value *CGObjCNonFragileABIMac::EmitNSAutoreleasePoolClassRef(
7362                                                     CodeGenFunction &CGF) {
7363   IdentifierInfo *II = &CGM.getContext().Idents.get("NSAutoreleasePool");
7364   return EmitClassRefFromId(CGF, II, nullptr);
7365 }
7366
7367 llvm::Value *
7368 CGObjCNonFragileABIMac::EmitSuperClassRef(CodeGenFunction &CGF,
7369                                           const ObjCInterfaceDecl *ID) {
7370   llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
7371
7372   if (!Entry) {
7373     llvm::Constant *ClassGV = GetClassGlobalForClassRef(ID);
7374     std::string SectionName =
7375         GetSectionName("__objc_superrefs", "regular,no_dead_strip");
7376     Entry = new llvm::GlobalVariable(
7377         CGM.getModule(), ClassGV->getType(), false,
7378         getLinkageTypeForObjCMetadata(CGM, SectionName), ClassGV,
7379         "OBJC_CLASSLIST_SUP_REFS_$_");
7380     Entry->setAlignment(CGF.getPointerAlign().getQuantity());
7381     Entry->setSection(SectionName);
7382     CGM.addCompilerUsedGlobal(Entry);
7383   }
7384
7385   return EmitLoadOfClassRef(CGF, ID, Entry);
7386 }
7387
7388 /// EmitMetaClassRef - Return a Value * of the address of _class_t
7389 /// meta-data
7390 ///
7391 llvm::Value *CGObjCNonFragileABIMac::EmitMetaClassRef(CodeGenFunction &CGF,
7392                                                       const ObjCInterfaceDecl *ID,
7393                                                       bool Weak) {
7394   CharUnits Align = CGF.getPointerAlign();
7395   llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
7396   if (!Entry) {
7397     auto MetaClassGV = GetClassGlobal(ID, /*metaclass*/ true, NotForDefinition);
7398     std::string SectionName =
7399         GetSectionName("__objc_superrefs", "regular,no_dead_strip");
7400     Entry = new llvm::GlobalVariable(
7401         CGM.getModule(), ObjCTypes.ClassnfABIPtrTy, false,
7402         getLinkageTypeForObjCMetadata(CGM, SectionName), MetaClassGV,
7403         "OBJC_CLASSLIST_SUP_REFS_$_");
7404     Entry->setAlignment(Align.getQuantity());
7405     Entry->setSection(SectionName);
7406     CGM.addCompilerUsedGlobal(Entry);
7407   }
7408
7409   return CGF.Builder.CreateAlignedLoad(Entry, Align);
7410 }
7411
7412 /// GetClass - Return a reference to the class for the given interface
7413 /// decl.
7414 llvm::Value *CGObjCNonFragileABIMac::GetClass(CodeGenFunction &CGF,
7415                                               const ObjCInterfaceDecl *ID) {
7416   if (ID->isWeakImported()) {
7417     auto ClassGV = GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition);
7418     (void)ClassGV;
7419     assert(!isa<llvm::GlobalVariable>(ClassGV) ||
7420            cast<llvm::GlobalVariable>(ClassGV)->hasExternalWeakLinkage());
7421   }
7422
7423   return EmitClassRef(CGF, ID);
7424 }
7425
7426 /// Generates a message send where the super is the receiver.  This is
7427 /// a message send to self with special delivery semantics indicating
7428 /// which class's method should be called.
7429 CodeGen::RValue
7430 CGObjCNonFragileABIMac::GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF,
7431                                                  ReturnValueSlot Return,
7432                                                  QualType ResultType,
7433                                                  Selector Sel,
7434                                                  const ObjCInterfaceDecl *Class,
7435                                                  bool isCategoryImpl,
7436                                                  llvm::Value *Receiver,
7437                                                  bool IsClassMessage,
7438                                                  const CodeGen::CallArgList &CallArgs,
7439                                                  const ObjCMethodDecl *Method) {
7440   // ...
7441   // Create and init a super structure; this is a (receiver, class)
7442   // pair we will pass to objc_msgSendSuper.
7443   Address ObjCSuper =
7444     CGF.CreateTempAlloca(ObjCTypes.SuperTy, CGF.getPointerAlign(),
7445                          "objc_super");
7446
7447   llvm::Value *ReceiverAsObject =
7448     CGF.Builder.CreateBitCast(Receiver, ObjCTypes.ObjectPtrTy);
7449   CGF.Builder.CreateStore(ReceiverAsObject,
7450                           CGF.Builder.CreateStructGEP(ObjCSuper, 0));
7451
7452   // If this is a class message the metaclass is passed as the target.
7453   llvm::Value *Target;
7454   if (IsClassMessage)
7455       Target = EmitMetaClassRef(CGF, Class, Class->isWeakImported());
7456   else
7457     Target = EmitSuperClassRef(CGF, Class);
7458
7459   // FIXME: We shouldn't need to do this cast, rectify the ASTContext and
7460   // ObjCTypes types.
7461   llvm::Type *ClassTy =
7462     CGM.getTypes().ConvertType(CGF.getContext().getObjCClassType());
7463   Target = CGF.Builder.CreateBitCast(Target, ClassTy);
7464   CGF.Builder.CreateStore(Target, CGF.Builder.CreateStructGEP(ObjCSuper, 1));
7465
7466   return (isVTableDispatchedSelector(Sel))
7467     ? EmitVTableMessageSend(CGF, Return, ResultType, Sel,
7468                             ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7469                             true, CallArgs, Method)
7470     : EmitMessageSend(CGF, Return, ResultType,
7471                       EmitSelector(CGF, Sel),
7472                       ObjCSuper.getPointer(), ObjCTypes.SuperPtrCTy,
7473                       true, CallArgs, Method, Class, ObjCTypes);
7474 }
7475
7476 llvm::Value *CGObjCNonFragileABIMac::EmitSelector(CodeGenFunction &CGF,
7477                                                   Selector Sel) {
7478   Address Addr = EmitSelectorAddr(CGF, Sel);
7479
7480   llvm::LoadInst* LI = CGF.Builder.CreateLoad(Addr);
7481   LI->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
7482                   llvm::MDNode::get(VMContext, None));
7483   return LI;
7484 }
7485
7486 Address CGObjCNonFragileABIMac::EmitSelectorAddr(CodeGenFunction &CGF,
7487                                                  Selector Sel) {
7488   llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
7489
7490   CharUnits Align = CGF.getPointerAlign();
7491   if (!Entry) {
7492     llvm::Constant *Casted =
7493       llvm::ConstantExpr::getBitCast(GetMethodVarName(Sel),
7494                                      ObjCTypes.SelectorPtrTy);
7495     std::string SectionName =
7496         GetSectionName("__objc_selrefs", "literal_pointers,no_dead_strip");
7497     Entry = new llvm::GlobalVariable(
7498         CGM.getModule(), ObjCTypes.SelectorPtrTy, false,
7499         getLinkageTypeForObjCMetadata(CGM, SectionName), Casted,
7500         "OBJC_SELECTOR_REFERENCES_");
7501     Entry->setExternallyInitialized(true);
7502     Entry->setSection(SectionName);
7503     Entry->setAlignment(Align.getQuantity());
7504     CGM.addCompilerUsedGlobal(Entry);
7505   }
7506
7507   return Address(Entry, Align);
7508 }
7509
7510 /// EmitObjCIvarAssign - Code gen for assigning to a __strong object.
7511 /// objc_assign_ivar (id src, id *dst, ptrdiff_t)
7512 ///
7513 void CGObjCNonFragileABIMac::EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF,
7514                                                 llvm::Value *src,
7515                                                 Address dst,
7516                                                 llvm::Value *ivarOffset) {
7517   llvm::Type * SrcTy = src->getType();
7518   if (!isa<llvm::PointerType>(SrcTy)) {
7519     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7520     assert(Size <= 8 && "does not support size > 8");
7521     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7522            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7523     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7524   }
7525   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7526   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7527   llvm::Value *args[] = { src, dst.getPointer(), ivarOffset };
7528   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignIvarFn(), args);
7529 }
7530
7531 /// EmitObjCStrongCastAssign - Code gen for assigning to a __strong cast object.
7532 /// objc_assign_strongCast (id src, id *dst)
7533 ///
7534 void CGObjCNonFragileABIMac::EmitObjCStrongCastAssign(
7535   CodeGen::CodeGenFunction &CGF,
7536   llvm::Value *src, Address dst) {
7537   llvm::Type * SrcTy = src->getType();
7538   if (!isa<llvm::PointerType>(SrcTy)) {
7539     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7540     assert(Size <= 8 && "does not support size > 8");
7541     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7542            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7543     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7544   }
7545   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7546   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7547   llvm::Value *args[] = { src, dst.getPointer() };
7548   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignStrongCastFn(),
7549                               args, "weakassign");
7550 }
7551
7552 void CGObjCNonFragileABIMac::EmitGCMemmoveCollectable(
7553   CodeGen::CodeGenFunction &CGF,
7554   Address DestPtr,
7555   Address SrcPtr,
7556   llvm::Value *Size) {
7557   SrcPtr = CGF.Builder.CreateBitCast(SrcPtr, ObjCTypes.Int8PtrTy);
7558   DestPtr = CGF.Builder.CreateBitCast(DestPtr, ObjCTypes.Int8PtrTy);
7559   llvm::Value *args[] = { DestPtr.getPointer(), SrcPtr.getPointer(), Size };
7560   CGF.EmitNounwindRuntimeCall(ObjCTypes.GcMemmoveCollectableFn(), args);
7561 }
7562
7563 /// EmitObjCWeakRead - Code gen for loading value of a __weak
7564 /// object: objc_read_weak (id *src)
7565 ///
7566 llvm::Value * CGObjCNonFragileABIMac::EmitObjCWeakRead(
7567   CodeGen::CodeGenFunction &CGF,
7568   Address AddrWeakObj) {
7569   llvm::Type *DestTy = AddrWeakObj.getElementType();
7570   AddrWeakObj = CGF.Builder.CreateBitCast(AddrWeakObj, ObjCTypes.PtrObjectPtrTy);
7571   llvm::Value *read_weak =
7572     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcReadWeakFn(),
7573                                 AddrWeakObj.getPointer(), "weakread");
7574   read_weak = CGF.Builder.CreateBitCast(read_weak, DestTy);
7575   return read_weak;
7576 }
7577
7578 /// EmitObjCWeakAssign - Code gen for assigning to a __weak object.
7579 /// objc_assign_weak (id src, id *dst)
7580 ///
7581 void CGObjCNonFragileABIMac::EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF,
7582                                                 llvm::Value *src, Address dst) {
7583   llvm::Type * SrcTy = src->getType();
7584   if (!isa<llvm::PointerType>(SrcTy)) {
7585     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7586     assert(Size <= 8 && "does not support size > 8");
7587     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7588            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7589     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7590   }
7591   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7592   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7593   llvm::Value *args[] = { src, dst.getPointer() };
7594   CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignWeakFn(),
7595                               args, "weakassign");
7596 }
7597
7598 /// EmitObjCGlobalAssign - Code gen for assigning to a __strong object.
7599 /// objc_assign_global (id src, id *dst)
7600 ///
7601 void CGObjCNonFragileABIMac::EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF,
7602                                           llvm::Value *src, Address dst,
7603                                           bool threadlocal) {
7604   llvm::Type * SrcTy = src->getType();
7605   if (!isa<llvm::PointerType>(SrcTy)) {
7606     unsigned Size = CGM.getDataLayout().getTypeAllocSize(SrcTy);
7607     assert(Size <= 8 && "does not support size > 8");
7608     src = (Size == 4 ? CGF.Builder.CreateBitCast(src, ObjCTypes.IntTy)
7609            : CGF.Builder.CreateBitCast(src, ObjCTypes.LongTy));
7610     src = CGF.Builder.CreateIntToPtr(src, ObjCTypes.Int8PtrTy);
7611   }
7612   src = CGF.Builder.CreateBitCast(src, ObjCTypes.ObjectPtrTy);
7613   dst = CGF.Builder.CreateBitCast(dst, ObjCTypes.PtrObjectPtrTy);
7614   llvm::Value *args[] = { src, dst.getPointer() };
7615   if (!threadlocal)
7616     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignGlobalFn(),
7617                                 args, "globalassign");
7618   else
7619     CGF.EmitNounwindRuntimeCall(ObjCTypes.getGcAssignThreadLocalFn(),
7620                                 args, "threadlocalassign");
7621 }
7622
7623 void
7624 CGObjCNonFragileABIMac::EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
7625                                              const ObjCAtSynchronizedStmt &S) {
7626   EmitAtSynchronizedStmt(CGF, S, ObjCTypes.getSyncEnterFn(),
7627                          ObjCTypes.getSyncExitFn());
7628 }
7629
7630 llvm::Constant *
7631 CGObjCNonFragileABIMac::GetEHType(QualType T) {
7632   // There's a particular fixed type info for 'id'.
7633   if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
7634     auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
7635     if (!IDEHType) {
7636       IDEHType =
7637           new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
7638                                    llvm::GlobalValue::ExternalLinkage, nullptr,
7639                                    "OBJC_EHTYPE_id");
7640       if (CGM.getTriple().isOSBinFormatCOFF())
7641         IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id"));
7642     }
7643     return IDEHType;
7644   }
7645
7646   // All other types should be Objective-C interface pointer types.
7647   const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
7648   assert(PT && "Invalid @catch type.");
7649
7650   const ObjCInterfaceType *IT = PT->getInterfaceType();
7651   assert(IT && "Invalid @catch type.");
7652
7653   return GetInterfaceEHType(IT->getDecl(), NotForDefinition);
7654 }
7655
7656 void CGObjCNonFragileABIMac::EmitTryStmt(CodeGen::CodeGenFunction &CGF,
7657                                          const ObjCAtTryStmt &S) {
7658   EmitTryCatchStmt(CGF, S, ObjCTypes.getObjCBeginCatchFn(),
7659                    ObjCTypes.getObjCEndCatchFn(),
7660                    ObjCTypes.getExceptionRethrowFn());
7661 }
7662
7663 /// EmitThrowStmt - Generate code for a throw statement.
7664 void CGObjCNonFragileABIMac::EmitThrowStmt(CodeGen::CodeGenFunction &CGF,
7665                                            const ObjCAtThrowStmt &S,
7666                                            bool ClearInsertionPoint) {
7667   if (const Expr *ThrowExpr = S.getThrowExpr()) {
7668     llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
7669     Exception = CGF.Builder.CreateBitCast(Exception, ObjCTypes.ObjectPtrTy);
7670     llvm::CallBase *Call =
7671         CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionThrowFn(), Exception);
7672     Call->setDoesNotReturn();
7673   } else {
7674     llvm::CallBase *Call =
7675         CGF.EmitRuntimeCallOrInvoke(ObjCTypes.getExceptionRethrowFn());
7676     Call->setDoesNotReturn();
7677   }
7678
7679   CGF.Builder.CreateUnreachable();
7680   if (ClearInsertionPoint)
7681     CGF.Builder.ClearInsertionPoint();
7682 }
7683
7684 llvm::Constant *
7685 CGObjCNonFragileABIMac::GetInterfaceEHType(const ObjCInterfaceDecl *ID,
7686                                            ForDefinition_t IsForDefinition) {
7687   llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];
7688   StringRef ClassName = ID->getObjCRuntimeNameAsString();
7689
7690   // If we don't need a definition, return the entry if found or check
7691   // if we use an external reference.
7692   if (!IsForDefinition) {
7693     if (Entry)
7694       return Entry;
7695
7696     // If this type (or a super class) has the __objc_exception__
7697     // attribute, emit an external reference.
7698     if (hasObjCExceptionAttribute(CGM.getContext(), ID)) {
7699       std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str();
7700       Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
7701                                        false, llvm::GlobalValue::ExternalLinkage,
7702                                        nullptr, EHTypeName);
7703       CGM.setGVProperties(Entry, ID);
7704       return Entry;
7705     }
7706   }
7707
7708   // Otherwise we need to either make a new entry or fill in the initializer.
7709   assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
7710
7711   std::string VTableName = "objc_ehtype_vtable";
7712   auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName);
7713   if (!VTableGV) {
7714     VTableGV =
7715         new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false,
7716                                  llvm::GlobalValue::ExternalLinkage, nullptr,
7717                                  VTableName);
7718     if (CGM.getTriple().isOSBinFormatCOFF())
7719       VTableGV->setDLLStorageClass(getStorage(CGM, VTableName));
7720   }
7721
7722   llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
7723   ConstantInitBuilder builder(CGM);
7724   auto values = builder.beginStruct(ObjCTypes.EHTypeTy);
7725   values.add(
7726     llvm::ConstantExpr::getInBoundsGetElementPtr(VTableGV->getValueType(),
7727                                                  VTableGV, VTableIdx));
7728   values.add(GetClassName(ClassName));
7729   values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition));
7730
7731   llvm::GlobalValue::LinkageTypes L = IsForDefinition
7732                                           ? llvm::GlobalValue::ExternalLinkage
7733                                           : llvm::GlobalValue::WeakAnyLinkage;
7734   if (Entry) {
7735     values.finishAndSetAsInitializer(Entry);
7736     Entry->setAlignment(CGM.getPointerAlign().getQuantity());
7737   } else {
7738     Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName,
7739                                          CGM.getPointerAlign(),
7740                                          /*constant*/ false,
7741                                          L);
7742     if (hasObjCExceptionAttribute(CGM.getContext(), ID))
7743       CGM.setGVProperties(Entry, ID);
7744   }
7745   assert(Entry->getLinkage() == L);
7746
7747   if (!CGM.getTriple().isOSBinFormatCOFF())
7748     if (ID->getVisibility() == HiddenVisibility)
7749       Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
7750
7751   if (IsForDefinition)
7752     if (CGM.getTriple().isOSBinFormatMachO())
7753       Entry->setSection("__DATA,__objc_const");
7754
7755   return Entry;
7756 }
7757
7758 /* *** */
7759
7760 CodeGen::CGObjCRuntime *
7761 CodeGen::CreateMacObjCRuntime(CodeGen::CodeGenModule &CGM) {
7762   switch (CGM.getLangOpts().ObjCRuntime.getKind()) {
7763   case ObjCRuntime::FragileMacOSX:
7764   return new CGObjCMac(CGM);
7765
7766   case ObjCRuntime::MacOSX:
7767   case ObjCRuntime::iOS:
7768   case ObjCRuntime::WatchOS:
7769     return new CGObjCNonFragileABIMac(CGM);
7770
7771   case ObjCRuntime::GNUstep:
7772   case ObjCRuntime::GCC:
7773   case ObjCRuntime::ObjFW:
7774     llvm_unreachable("these runtimes are not Mac runtimes");
7775   }
7776   llvm_unreachable("bad runtime");
7777 }