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

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