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