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