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

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