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

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