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