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