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

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