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

   1 //===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
   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 GNU runtime.  The
  11 // class in this file generates structures used by the GNU Objective-C runtime
  12 // library.  These structures are defined in objc/objc.h and objc/objc-api.h in
  13 // the GNU runtime distribution.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "CGObjCRuntime.h"
  18 #include "CodeGenModule.h"
  19 #include "CodeGenFunction.h"
  20 #include "CGCleanup.h"
  21
  22 #include "clang/AST/ASTContext.h"
  23 #include "clang/AST/Decl.h"
  24 #include "clang/AST/DeclObjC.h"
  25 #include "clang/AST/RecordLayout.h"
  26 #include "clang/AST/StmtObjC.h"
  27 #include "clang/Basic/SourceManager.h"
  28 #include "clang/Basic/FileManager.h"
  29
  30 #include "llvm/Intrinsics.h"
  31 #include "llvm/Module.h"
  32 #include "llvm/LLVMContext.h"
  33 #include "llvm/ADT/SmallVector.h"
  34 #include "llvm/ADT/StringMap.h"
  35 #include "llvm/Support/CallSite.h"
  36 #include "llvm/Support/Compiler.h"
  37 #include "llvm/Target/TargetData.h"
  38
  39 #include <stdarg.h>
  40
  41
  42 using namespace clang;
  43 using namespace CodeGen;
  44 using llvm::dyn_cast;
  45
  46
  47 namespace {
  48 /// Class that lazily initialises the runtime function.  Avoids inserting the
  49 /// types and the function declaration into a module if they're not used, and
  50 /// avoids constructing the type more than once if it's used more than once.
  51 class LazyRuntimeFunction {
  52   CodeGenModule *CGM;
  53   std::vector<llvm::Type*> ArgTys;
  54   const char *FunctionName;
  55   llvm::Constant *Function;
  56   public:
  57     /// Constructor leaves this class uninitialized, because it is intended to
  58     /// be used as a field in another class and not all of the types that are
  59     /// used as arguments will necessarily be available at construction time.
  60     LazyRuntimeFunction() : CGM(0), FunctionName(0), Function(0) {}
  61
  62     /// Initialises the lazy function with the name, return type, and the types
  63     /// of the arguments.
  64     END_WITH_NULL
  65     void init(CodeGenModule *Mod, const char *name,
  66         llvm::Type *RetTy, ...) {
  67        CGM =Mod;
  68        FunctionName = name;
  69        Function = 0;
  70        ArgTys.clear();
  71        va_list Args;
  72        va_start(Args, RetTy);
  73          while (llvm::Type *ArgTy = va_arg(Args, llvm::Type*))
  74            ArgTys.push_back(ArgTy);
  75        va_end(Args);
  76        // Push the return type on at the end so we can pop it off easily
  77        ArgTys.push_back(RetTy);
  78    }
  79    /// Overloaded cast operator, allows the class to be implicitly cast to an
  80    /// LLVM constant.
  81    operator llvm::Constant*() {
  82      if (!Function) {
  83        if (0 == FunctionName) return 0;
  84        // We put the return type on the end of the vector, so pop it back off
  85        const llvm::Type *RetTy = ArgTys.back();
  86        ArgTys.pop_back();
  87        llvm::FunctionType *FTy = llvm::FunctionType::get(RetTy, ArgTys, false);
  88        Function =
  89          cast<llvm::Constant>(CGM->CreateRuntimeFunction(FTy, FunctionName));
  90        // We won't need to use the types again, so we may as well clean up the
  91        // vector now
  92        ArgTys.resize(0);
  93      }
  94      return Function;
  95    }
  96    operator llvm::Function*() {
  97      return cast<llvm::Function>((llvm::Constant*)*this);
  98    }
  99
 100 };
 101
 102
 103 /// GNU Objective-C runtime code generation.  This class implements the parts of
 104 /// Objective-C support that are specific to the GNU family of runtimes (GCC and
 105 /// GNUstep).
 106 class CGObjCGNU : public CGObjCRuntime {
 107 protected:
 108   /// The module that is using this class
 109   CodeGenModule &CGM;
 110   /// The LLVM module into which output is inserted
 111   llvm::Module &TheModule;
 112   /// strut objc_super.  Used for sending messages to super.  This structure
 113   /// contains the receiver (object) and the expected class.
 114   const llvm::StructType *ObjCSuperTy;
 115   /// struct objc_super*.  The type of the argument to the superclass message
 116   /// lookup functions.
 117   const llvm::PointerType *PtrToObjCSuperTy;
 118   /// LLVM type for selectors.  Opaque pointer (i8*) unless a header declaring
 119   /// SEL is included in a header somewhere, in which case it will be whatever
 120   /// type is declared in that header, most likely {i8*, i8*}.
 121   llvm::PointerType *SelectorTy;
 122   /// LLVM i8 type.  Cached here to avoid repeatedly getting it in all of the
 123   /// places where it's used
 124   const llvm::IntegerType *Int8Ty;
 125   /// Pointer to i8 - LLVM type of char*, for all of the places where the
 126   /// runtime needs to deal with C strings.
 127   llvm::PointerType *PtrToInt8Ty;
 128   /// Instance Method Pointer type.  This is a pointer to a function that takes,
 129   /// at a minimum, an object and a selector, and is the generic type for
 130   /// Objective-C methods.  Due to differences between variadic / non-variadic
 131   /// calling conventions, it must always be cast to the correct type before
 132   /// actually being used.
 133   llvm::PointerType *IMPTy;
 134   /// Type of an untyped Objective-C object.  Clang treats id as a built-in type
 135   /// when compiling Objective-C code, so this may be an opaque pointer (i8*),
 136   /// but if the runtime header declaring it is included then it may be a
 137   /// pointer to a structure.
 138   llvm::PointerType *IdTy;
 139   /// Pointer to a pointer to an Objective-C object.  Used in the new ABI
 140   /// message lookup function and some GC-related functions.
 141   const llvm::PointerType *PtrToIdTy;
 142   /// The clang type of id.  Used when using the clang CGCall infrastructure to
 143   /// call Objective-C methods.
 144   CanQualType ASTIdTy;
 145   /// LLVM type for C int type.
 146   llvm::IntegerType *IntTy;
 147   /// LLVM type for an opaque pointer.  This is identical to PtrToInt8Ty, but is
 148   /// used in the code to document the difference between i8* meaning a pointer
 149   /// to a C string and i8* meaning a pointer to some opaque type.
 150   llvm::PointerType *PtrTy;
 151   /// LLVM type for C long type.  The runtime uses this in a lot of places where
 152   /// it should be using intptr_t, but we can't fix this without breaking
 153   /// compatibility with GCC...
 154   llvm::IntegerType *LongTy;
 155   /// LLVM type for C size_t.  Used in various runtime data structures.
 156   const llvm::IntegerType *SizeTy;
 157   /// LLVM type for C ptrdiff_t.  Mainly used in property accessor functions.
 158   const llvm::IntegerType *PtrDiffTy;
 159   /// LLVM type for C int*.  Used for GCC-ABI-compatible non-fragile instance
 160   /// variables.
 161   const llvm::PointerType *PtrToIntTy;
 162   /// LLVM type for Objective-C BOOL type.
 163   const llvm::Type *BoolTy;
 164   /// Metadata kind used to tie method lookups to message sends.  The GNUstep
 165   /// runtime provides some LLVM passes that can use this to do things like
 166   /// automatic IMP caching and speculative inlining.
 167   unsigned msgSendMDKind;
 168   /// Helper function that generates a constant string and returns a pointer to
 169   /// the start of the string.  The result of this function can be used anywhere
 170   /// where the C code specifies const char*.
 171   llvm::Constant *MakeConstantString(const std::string &Str,
 172                                      const std::string &Name="") {
 173     llvm::Constant *ConstStr = CGM.GetAddrOfConstantCString(Str, Name.c_str());
 174     return llvm::ConstantExpr::getGetElementPtr(ConstStr, Zeros, 2);
 175   }
 176   /// Emits a linkonce_odr string, whose name is the prefix followed by the
 177   /// string value.  This allows the linker to combine the strings between
 178   /// different modules.  Used for EH typeinfo names, selector strings, and a
 179   /// few other things.
 180   llvm::Constant *ExportUniqueString(const std::string &Str,
 181                                      const std::string prefix) {
 182     std::string name = prefix + Str;
 183     llvm::Constant *ConstStr = TheModule.getGlobalVariable(name);
 184     if (!ConstStr) {
 185       llvm::Constant *value = llvm::ConstantArray::get(VMContext, Str, true);
 186       ConstStr = new llvm::GlobalVariable(TheModule, value->getType(), true,
 187               llvm::GlobalValue::LinkOnceODRLinkage, value, prefix + Str);
 188     }
 189     return llvm::ConstantExpr::getGetElementPtr(ConstStr, Zeros, 2);
 190   }
 191   /// Generates a global structure, initialized by the elements in the vector.
 192   /// The element types must match the types of the structure elements in the
 193   /// first argument.
 194   llvm::GlobalVariable *MakeGlobal(const llvm::StructType *Ty,
 195                                    std::vector<llvm::Constant*> &V,
 196                                    llvm::StringRef Name="",
 197                                    llvm::GlobalValue::LinkageTypes linkage
 198                                          =llvm::GlobalValue::InternalLinkage) {
 199     llvm::Constant *C = llvm::ConstantStruct::get(Ty, V);
 200     return new llvm::GlobalVariable(TheModule, Ty, false,
 201         linkage, C, Name);
 202   }
 203   /// Generates a global array.  The vector must contain the same number of
 204   /// elements that the array type declares, of the type specified as the array
 205   /// element type.
 206   llvm::GlobalVariable *MakeGlobal(const llvm::ArrayType *Ty,
 207                                    std::vector<llvm::Constant*> &V,
 208                                    llvm::StringRef Name="",
 209                                    llvm::GlobalValue::LinkageTypes linkage
 210                                          =llvm::GlobalValue::InternalLinkage) {
 211     llvm::Constant *C = llvm::ConstantArray::get(Ty, V);
 212     return new llvm::GlobalVariable(TheModule, Ty, false,
 213                                     linkage, C, Name);
 214   }
 215   /// Generates a global array, inferring the array type from the specified
 216   /// element type and the size of the initialiser.
 217   llvm::GlobalVariable *MakeGlobalArray(const llvm::Type *Ty,
 218                                         std::vector<llvm::Constant*> &V,
 219                                         llvm::StringRef Name="",
 220                                         llvm::GlobalValue::LinkageTypes linkage
 221                                          =llvm::GlobalValue::InternalLinkage) {
 222     llvm::ArrayType *ArrayTy = llvm::ArrayType::get(Ty, V.size());
 223     return MakeGlobal(ArrayTy, V, Name, linkage);
 224   }
 225   /// Ensures that the value has the required type, by inserting a bitcast if
 226   /// required.  This function lets us avoid inserting bitcasts that are
 227   /// redundant.
 228   llvm::Value* EnforceType(CGBuilderTy B, llvm::Value *V, const llvm::Type *Ty){
 229     if (V->getType() == Ty) return V;
 230     return B.CreateBitCast(V, Ty);
 231   }
 232   // Some zeros used for GEPs in lots of places.
 233   llvm::Constant *Zeros[2];
 234   /// Null pointer value.  Mainly used as a terminator in various arrays.
 235   llvm::Constant *NULLPtr;
 236   /// LLVM context.
 237   llvm::LLVMContext &VMContext;
 238 private:
 239   /// Placeholder for the class.  Lots of things refer to the class before we've
 240   /// actually emitted it.  We use this alias as a placeholder, and then replace
 241   /// it with a pointer to the class structure before finally emitting the
 242   /// module.
 243   llvm::GlobalAlias *ClassPtrAlias;
 244   /// Placeholder for the metaclass.  Lots of things refer to the class before
 245   /// we've / actually emitted it.  We use this alias as a placeholder, and then
 246   /// replace / it with a pointer to the metaclass structure before finally
 247   /// emitting the / module.
 248   llvm::GlobalAlias *MetaClassPtrAlias;
 249   /// All of the classes that have been generated for this compilation units.
 250   std::vector<llvm::Constant*> Classes;
 251   /// All of the categories that have been generated for this compilation units.
 252   std::vector<llvm::Constant*> Categories;
 253   /// All of the Objective-C constant strings that have been generated for this
 254   /// compilation units.
 255   std::vector<llvm::Constant*> ConstantStrings;
 256   /// Map from string values to Objective-C constant strings in the output.
 257   /// Used to prevent emitting Objective-C strings more than once.  This should
 258   /// not be required at all - CodeGenModule should manage this list.
 259   llvm::StringMap<llvm::Constant*> ObjCStrings;
 260   /// All of the protocols that have been declared.
 261   llvm::StringMap<llvm::Constant*> ExistingProtocols;
 262   /// For each variant of a selector, we store the type encoding and a
 263   /// placeholder value.  For an untyped selector, the type will be the empty
 264   /// string.  Selector references are all done via the module's selector table,
 265   /// so we create an alias as a placeholder and then replace it with the real
 266   /// value later.
 267   typedef std::pair<std::string, llvm::GlobalAlias*> TypedSelector;
 268   /// Type of the selector map.  This is roughly equivalent to the structure
 269   /// used in the GNUstep runtime, which maintains a list of all of the valid
 270   /// types for a selector in a table.
 271   typedef llvm::DenseMap<Selector, llvm::SmallVector<TypedSelector, 2> >
 272     SelectorMap;
 273   /// A map from selectors to selector types.  This allows us to emit all
 274   /// selectors of the same name and type together.
 275   SelectorMap SelectorTable;
 276
 277   /// Selectors related to memory management.  When compiling in GC mode, we
 278   /// omit these.
 279   Selector RetainSel, ReleaseSel, AutoreleaseSel;
 280   /// Runtime functions used for memory management in GC mode.  Note that clang
 281   /// supports code generation for calling these functions, but neither GNU
 282   /// runtime actually supports this API properly yet.
 283   LazyRuntimeFunction IvarAssignFn, StrongCastAssignFn, MemMoveFn, WeakReadFn,
 284     WeakAssignFn, GlobalAssignFn;
 285
 286 protected:
 287   /// Function used for throwing Objective-C exceptions.
 288   LazyRuntimeFunction ExceptionThrowFn;
 289   /// Function used for rethrowing exceptions, used at the end of @finally or
 290   /// @synchronize blocks.
 291   LazyRuntimeFunction ExceptionReThrowFn;
 292   /// Function called when entering a catch function.  This is required for
 293   /// differentiating Objective-C exceptions and foreign exceptions.
 294   LazyRuntimeFunction EnterCatchFn;
 295   /// Function called when exiting from a catch block.  Used to do exception
 296   /// cleanup.
 297   LazyRuntimeFunction ExitCatchFn;
 298   /// Function called when entering an @synchronize block.  Acquires the lock.
 299   LazyRuntimeFunction SyncEnterFn;
 300   /// Function called when exiting an @synchronize block.  Releases the lock.
 301   LazyRuntimeFunction SyncExitFn;
 302
 303 private:
 304
 305   /// Function called if fast enumeration detects that the collection is
 306   /// modified during the update.
 307   LazyRuntimeFunction EnumerationMutationFn;
 308   /// Function for implementing synthesized property getters that return an
 309   /// object.
 310   LazyRuntimeFunction GetPropertyFn;
 311   /// Function for implementing synthesized property setters that return an
 312   /// object.
 313   LazyRuntimeFunction SetPropertyFn;
 314   /// Function used for non-object declared property getters.
 315   LazyRuntimeFunction GetStructPropertyFn;
 316   /// Function used for non-object declared property setters.
 317   LazyRuntimeFunction SetStructPropertyFn;
 318
 319   /// The version of the runtime that this class targets.  Must match the
 320   /// version in the runtime.
 321   int RuntimeVersion;
 322   /// The version of the protocol class.  Used to differentiate between ObjC1
 323   /// and ObjC2 protocols.  Objective-C 1 protocols can not contain optional
 324   /// components and can not contain declared properties.  We always emit
 325   /// Objective-C 2 property structures, but we have to pretend that they're
 326   /// Objective-C 1 property structures when targeting the GCC runtime or it
 327   /// will abort.
 328   const int ProtocolVersion;
 329 private:
 330   /// Generates an instance variable list structure.  This is a structure
 331   /// containing a size and an array of structures containing instance variable
 332   /// metadata.  This is used purely for introspection in the fragile ABI.  In
 333   /// the non-fragile ABI, it's used for instance variable fixup.
 334   llvm::Constant *GenerateIvarList(
 335       const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
 336       const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
 337       const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets);
 338   /// Generates a method list structure.  This is a structure containing a size
 339   /// and an array of structures containing method metadata.
 340   ///
 341   /// This structure is used by both classes and categories, and contains a next
 342   /// pointer allowing them to be chained together in a linked list.
 343   llvm::Constant *GenerateMethodList(const llvm::StringRef &ClassName,
 344       const llvm::StringRef &CategoryName,
 345       const llvm::SmallVectorImpl<Selector>  &MethodSels,
 346       const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes,
 347       bool isClassMethodList);
 348   /// Emits an empty protocol.  This is used for @protocol() where no protocol
 349   /// is found.  The runtime will (hopefully) fix up the pointer to refer to the
 350   /// real protocol.
 351   llvm::Constant *GenerateEmptyProtocol(const std::string &ProtocolName);
 352   /// Generates a list of property metadata structures.  This follows the same
 353   /// pattern as method and instance variable metadata lists.
 354   llvm::Constant *GeneratePropertyList(const ObjCImplementationDecl *OID,
 355         llvm::SmallVectorImpl<Selector> &InstanceMethodSels,
 356         llvm::SmallVectorImpl<llvm::Constant*> &InstanceMethodTypes);
 357   /// Generates a list of referenced protocols.  Classes, categories, and
 358   /// protocols all use this structure.
 359   llvm::Constant *GenerateProtocolList(
 360       const llvm::SmallVectorImpl<std::string> &Protocols);
 361   /// To ensure that all protocols are seen by the runtime, we add a category on
 362   /// a class defined in the runtime, declaring no methods, but adopting the
 363   /// protocols.  This is a horribly ugly hack, but it allows us to collect all
 364   /// of the protocols without changing the ABI.
 365   void GenerateProtocolHolderCategory(void);
 366   /// Generates a class structure.
 367   llvm::Constant *GenerateClassStructure(
 368       llvm::Constant *MetaClass,
 369       llvm::Constant *SuperClass,
 370       unsigned info,
 371       const char *Name,
 372       llvm::Constant *Version,
 373       llvm::Constant *InstanceSize,
 374       llvm::Constant *IVars,
 375       llvm::Constant *Methods,
 376       llvm::Constant *Protocols,
 377       llvm::Constant *IvarOffsets,
 378       llvm::Constant *Properties,
 379       bool isMeta=false);
 380   /// Generates a method list.  This is used by protocols to define the required
 381   /// and optional methods.
 382   llvm::Constant *GenerateProtocolMethodList(
 383       const llvm::SmallVectorImpl<llvm::Constant *>  &MethodNames,
 384       const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes);
 385   /// Returns a selector with the specified type encoding.  An empty string is
 386   /// used to return an untyped selector (with the types field set to NULL).
 387   llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel,
 388     const std::string &TypeEncoding, bool lval);
 389   /// Returns the variable used to store the offset of an instance variable.
 390   llvm::GlobalVariable *ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
 391       const ObjCIvarDecl *Ivar);
 392   /// Emits a reference to a class.  This allows the linker to object if there
 393   /// is no class of the matching name.
 394   void EmitClassRef(const std::string &className);
 395   /// Emits a pointer to the named class
 396   llvm::Value *GetClassNamed(CGBuilderTy &Builder, const std::string &Name,
 397                              bool isWeak);
 398 protected:
 399   /// Looks up the method for sending a message to the specified object.  This
 400   /// mechanism differs between the GCC and GNU runtimes, so this method must be
 401   /// overridden in subclasses.
 402   virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
 403                                  llvm::Value *&Receiver,
 404                                  llvm::Value *cmd,
 405                                  llvm::MDNode *node) = 0;
 406   /// Looks up the method for sending a message to a superclass.  This mechanism
 407   /// differs between the GCC and GNU runtimes, so this method must be
 408   /// overridden in subclasses.
 409   virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
 410                                       llvm::Value *ObjCSuper,
 411                                       llvm::Value *cmd) = 0;
 412 public:
 413   CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
 414       unsigned protocolClassVersion);
 415
 416   virtual llvm::Constant *GenerateConstantString(const StringLiteral *);
 417
 418   virtual RValue
 419   GenerateMessageSend(CodeGenFunction &CGF,
 420                       ReturnValueSlot Return,
 421                       QualType ResultType,
 422                       Selector Sel,
 423                       llvm::Value *Receiver,
 424                       const CallArgList &CallArgs,
 425                       const ObjCInterfaceDecl *Class,
 426                       const ObjCMethodDecl *Method);
 427   virtual RValue
 428   GenerateMessageSendSuper(CodeGenFunction &CGF,
 429                            ReturnValueSlot Return,
 430                            QualType ResultType,
 431                            Selector Sel,
 432                            const ObjCInterfaceDecl *Class,
 433                            bool isCategoryImpl,
 434                            llvm::Value *Receiver,
 435                            bool IsClassMessage,
 436                            const CallArgList &CallArgs,
 437                            const ObjCMethodDecl *Method);
 438   virtual llvm::Value *GetClass(CGBuilderTy &Builder,
 439                                 const ObjCInterfaceDecl *OID);
 440   virtual llvm::Value *GetSelector(CGBuilderTy &Builder, Selector Sel,
 441                                    bool lval = false);
 442   virtual llvm::Value *GetSelector(CGBuilderTy &Builder, const ObjCMethodDecl
 443       *Method);
 444   virtual llvm::Constant *GetEHType(QualType T);
 445
 446   virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
 447                                          const ObjCContainerDecl *CD);
 448   virtual void GenerateCategory(const ObjCCategoryImplDecl *CMD);
 449   virtual void GenerateClass(const ObjCImplementationDecl *ClassDecl);
 450   virtual llvm::Value *GenerateProtocolRef(CGBuilderTy &Builder,
 451                                            const ObjCProtocolDecl *PD);
 452   virtual void GenerateProtocol(const ObjCProtocolDecl *PD);
 453   virtual llvm::Function *ModuleInitFunction();
 454   virtual llvm::Constant *GetPropertyGetFunction();
 455   virtual llvm::Constant *GetPropertySetFunction();
 456   virtual llvm::Constant *GetSetStructFunction();
 457   virtual llvm::Constant *GetGetStructFunction();
 458   virtual llvm::Constant *EnumerationMutationFunction();
 459
 460   virtual void EmitTryStmt(CodeGenFunction &CGF,
 461                            const ObjCAtTryStmt &S);
 462   virtual void EmitSynchronizedStmt(CodeGenFunction &CGF,
 463                                     const ObjCAtSynchronizedStmt &S);
 464   virtual void EmitThrowStmt(CodeGenFunction &CGF,
 465                              const ObjCAtThrowStmt &S);
 466   virtual llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF,
 467                                          llvm::Value *AddrWeakObj);
 468   virtual void EmitObjCWeakAssign(CodeGenFunction &CGF,
 469                                   llvm::Value *src, llvm::Value *dst);
 470   virtual void EmitObjCGlobalAssign(CodeGenFunction &CGF,
 471                                     llvm::Value *src, llvm::Value *dest,
 472                                     bool threadlocal=false);
 473   virtual void EmitObjCIvarAssign(CodeGenFunction &CGF,
 474                                     llvm::Value *src, llvm::Value *dest,
 475                                     llvm::Value *ivarOffset);
 476   virtual void EmitObjCStrongCastAssign(CodeGenFunction &CGF,
 477                                         llvm::Value *src, llvm::Value *dest);
 478   virtual void EmitGCMemmoveCollectable(CodeGenFunction &CGF,
 479                                         llvm::Value *DestPtr,
 480                                         llvm::Value *SrcPtr,
 481                                         llvm::Value *Size);
 482   virtual LValue EmitObjCValueForIvar(CodeGenFunction &CGF,
 483                                       QualType ObjectTy,
 484                                       llvm::Value *BaseValue,
 485                                       const ObjCIvarDecl *Ivar,
 486                                       unsigned CVRQualifiers);
 487   virtual llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
 488                                       const ObjCInterfaceDecl *Interface,
 489                                       const ObjCIvarDecl *Ivar);
 490   virtual llvm::Value *EmitNSAutoreleasePoolClassRef(CGBuilderTy &Builder);
 491   virtual llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM,
 492                                              const CGBlockInfo &blockInfo) {
 493     return NULLPtr;
 494   }
 495
 496   virtual llvm::GlobalVariable *GetClassGlobal(const std::string &Name) {
 497     return 0;
 498   }
 499 };
 500 /// Class representing the legacy GCC Objective-C ABI.  This is the default when
 501 /// -fobjc-nonfragile-abi is not specified.
 502 ///
 503 /// The GCC ABI target actually generates code that is approximately compatible
 504 /// with the new GNUstep runtime ABI, but refrains from using any features that
 505 /// would not work with the GCC runtime.  For example, clang always generates
 506 /// the extended form of the class structure, and the extra fields are simply
 507 /// ignored by GCC libobjc.
 508 class CGObjCGCC : public CGObjCGNU {
 509   /// The GCC ABI message lookup function.  Returns an IMP pointing to the
 510   /// method implementation for this message.
 511   LazyRuntimeFunction MsgLookupFn;
 512   /// The GCC ABI superclass message lookup function.  Takes a pointer to a
 513   /// structure describing the receiver and the class, and a selector as
 514   /// arguments.  Returns the IMP for the corresponding method.
 515   LazyRuntimeFunction MsgLookupSuperFn;
 516 protected:
 517   virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
 518                                  llvm::Value *&Receiver,
 519                                  llvm::Value *cmd,
 520                                  llvm::MDNode *node) {
 521     CGBuilderTy &Builder = CGF.Builder;
 522     llvm::Value *imp = Builder.CreateCall2(MsgLookupFn,
 523             EnforceType(Builder, Receiver, IdTy),
 524             EnforceType(Builder, cmd, SelectorTy));
 525     cast<llvm::CallInst>(imp)->setMetadata(msgSendMDKind, node);
 526     return imp;
 527   }
 528   virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
 529                                       llvm::Value *ObjCSuper,
 530                                       llvm::Value *cmd) {
 531       CGBuilderTy &Builder = CGF.Builder;
 532       llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper,
 533           PtrToObjCSuperTy), cmd};
 534       return Builder.CreateCall(MsgLookupSuperFn, lookupArgs);
 535     }
 536   public:
 537     CGObjCGCC(CodeGenModule &Mod) : CGObjCGNU(Mod, 8, 2) {
 538       // IMP objc_msg_lookup(id, SEL);
 539       MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy, NULL);
 540       // IMP objc_msg_lookup_super(struct objc_super*, SEL);
 541       MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
 542               PtrToObjCSuperTy, SelectorTy, NULL);
 543     }
 544 };
 545 /// Class used when targeting the new GNUstep runtime ABI.
 546 class CGObjCGNUstep : public CGObjCGNU {
 547     /// The slot lookup function.  Returns a pointer to a cacheable structure
 548     /// that contains (among other things) the IMP.
 549     LazyRuntimeFunction SlotLookupFn;
 550     /// The GNUstep ABI superclass message lookup function.  Takes a pointer to
 551     /// a structure describing the receiver and the class, and a selector as
 552     /// arguments.  Returns the slot for the corresponding method.  Superclass
 553     /// message lookup rarely changes, so this is a good caching opportunity.
 554     LazyRuntimeFunction SlotLookupSuperFn;
 555     /// Type of an slot structure pointer.  This is returned by the various
 556     /// lookup functions.
 557     llvm::Type *SlotTy;
 558   protected:
 559     virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
 560                                    llvm::Value *&Receiver,
 561                                    llvm::Value *cmd,
 562                                    llvm::MDNode *node) {
 563       CGBuilderTy &Builder = CGF.Builder;
 564       llvm::Function *LookupFn = SlotLookupFn;
 565
 566       // Store the receiver on the stack so that we can reload it later
 567       llvm::Value *ReceiverPtr = CGF.CreateTempAlloca(Receiver->getType());
 568       Builder.CreateStore(Receiver, ReceiverPtr);
 569
 570       llvm::Value *self;
 571
 572       if (isa<ObjCMethodDecl>(CGF.CurCodeDecl)) {
 573         self = CGF.LoadObjCSelf();
 574       } else {
 575         self = llvm::ConstantPointerNull::get(IdTy);
 576       }
 577
 578       // The lookup function is guaranteed not to capture the receiver pointer.
 579       LookupFn->setDoesNotCapture(1);
 580
 581       llvm::CallInst *slot =
 582           Builder.CreateCall3(LookupFn,
 583               EnforceType(Builder, ReceiverPtr, PtrToIdTy),
 584               EnforceType(Builder, cmd, SelectorTy),
 585               EnforceType(Builder, self, IdTy));
 586       slot->setOnlyReadsMemory();
 587       slot->setMetadata(msgSendMDKind, node);
 588
 589       // Load the imp from the slot
 590       llvm::Value *imp = Builder.CreateLoad(Builder.CreateStructGEP(slot, 4));
 591
 592       // The lookup function may have changed the receiver, so make sure we use
 593       // the new one.
 594       Receiver = Builder.CreateLoad(ReceiverPtr, true);
 595       return imp;
 596     }
 597     virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
 598                                         llvm::Value *ObjCSuper,
 599                                         llvm::Value *cmd) {
 600       CGBuilderTy &Builder = CGF.Builder;
 601       llvm::Value *lookupArgs[] = {ObjCSuper, cmd};
 602
 603       llvm::CallInst *slot = Builder.CreateCall(SlotLookupSuperFn, lookupArgs);
 604       slot->setOnlyReadsMemory();
 605
 606       return Builder.CreateLoad(Builder.CreateStructGEP(slot, 4));
 607     }
 608   public:
 609     CGObjCGNUstep(CodeGenModule &Mod) : CGObjCGNU(Mod, 9, 3) {
 610       llvm::StructType *SlotStructTy = llvm::StructType::get(PtrTy,
 611           PtrTy, PtrTy, IntTy, IMPTy, NULL);
 612       SlotTy = llvm::PointerType::getUnqual(SlotStructTy);
 613       // Slot_t objc_msg_lookup_sender(id *receiver, SEL selector, id sender);
 614       SlotLookupFn.init(&CGM, "objc_msg_lookup_sender", SlotTy, PtrToIdTy,
 615           SelectorTy, IdTy, NULL);
 616       // Slot_t objc_msg_lookup_super(struct objc_super*, SEL);
 617       SlotLookupSuperFn.init(&CGM, "objc_slot_lookup_super", SlotTy,
 618               PtrToObjCSuperTy, SelectorTy, NULL);
 619       // If we're in ObjC++ mode, then we want to make
 620       if (CGM.getLangOptions().CPlusPlus) {
 621         llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
 622         // void *__cxa_begin_catch(void *e)
 623         EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy, NULL);
 624         // void __cxa_end_catch(void)
 625         EnterCatchFn.init(&CGM, "__cxa_end_catch", VoidTy, NULL);
 626         // void _Unwind_Resume_or_Rethrow(void*)
 627         ExceptionReThrowFn.init(&CGM, "_Unwind_Resume_or_Rethrow", VoidTy, PtrTy, NULL);
 628       }
 629     }
 630 };
 631
 632 } // end anonymous namespace
 633
 634
 635 /// Emits a reference to a dummy variable which is emitted with each class.
 636 /// This ensures that a linker error will be generated when trying to link
 637 /// together modules where a referenced class is not defined.
 638 void CGObjCGNU::EmitClassRef(const std::string &className) {
 639   std::string symbolRef = "__objc_class_ref_" + className;
 640   // Don't emit two copies of the same symbol
 641   if (TheModule.getGlobalVariable(symbolRef))
 642     return;
 643   std::string symbolName = "__objc_class_name_" + className;
 644   llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName);
 645   if (!ClassSymbol) {
 646     ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
 647         llvm::GlobalValue::ExternalLinkage, 0, symbolName);
 648   }
 649   new llvm::GlobalVariable(TheModule, ClassSymbol->getType(), true,
 650     llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef);
 651 }
 652
 653 static std::string SymbolNameForMethod(const llvm::StringRef &ClassName,
 654     const llvm::StringRef &CategoryName, const Selector MethodName,
 655     bool isClassMethod) {
 656   std::string MethodNameColonStripped = MethodName.getAsString();
 657   std::replace(MethodNameColonStripped.begin(), MethodNameColonStripped.end(),
 658       ':', '_');
 659   return (llvm::Twine(isClassMethod ? "_c_" : "_i_") + ClassName + "_" +
 660     CategoryName + "_" + MethodNameColonStripped).str();
 661 }
 662
 663 CGObjCGNU::CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
 664     unsigned protocolClassVersion)
 665   : CGM(cgm), TheModule(CGM.getModule()), VMContext(cgm.getLLVMContext()),
 666   ClassPtrAlias(0), MetaClassPtrAlias(0), RuntimeVersion(runtimeABIVersion),
 667   ProtocolVersion(protocolClassVersion) {
 668
 669   msgSendMDKind = VMContext.getMDKindID("GNUObjCMessageSend");
 670
 671   CodeGenTypes &Types = CGM.getTypes();
 672   IntTy = cast<llvm::IntegerType>(
 673       Types.ConvertType(CGM.getContext().IntTy));
 674   LongTy = cast<llvm::IntegerType>(
 675       Types.ConvertType(CGM.getContext().LongTy));
 676   SizeTy = cast<llvm::IntegerType>(
 677       Types.ConvertType(CGM.getContext().getSizeType()));
 678   PtrDiffTy = cast<llvm::IntegerType>(
 679       Types.ConvertType(CGM.getContext().getPointerDiffType()));
 680   BoolTy = CGM.getTypes().ConvertType(CGM.getContext().BoolTy);
 681
 682   Int8Ty = llvm::Type::getInt8Ty(VMContext);
 683   // C string type.  Used in lots of places.
 684   PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
 685
 686   Zeros[0] = llvm::ConstantInt::get(LongTy, 0);
 687   Zeros[1] = Zeros[0];
 688   NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty);
 689   // Get the selector Type.
 690   QualType selTy = CGM.getContext().getObjCSelType();
 691   if (QualType() == selTy) {
 692     SelectorTy = PtrToInt8Ty;
 693   } else {
 694     SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy));
 695   }
 696
 697   PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
 698   PtrTy = PtrToInt8Ty;
 699
 700   // Object type
 701   QualType UnqualIdTy = CGM.getContext().getObjCIdType();
 702   ASTIdTy = CanQualType();
 703   if (UnqualIdTy != QualType()) {
 704     ASTIdTy = CGM.getContext().getCanonicalType(UnqualIdTy);
 705     IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
 706   } else {
 707     IdTy = PtrToInt8Ty;
 708   }
 709   PtrToIdTy = llvm::PointerType::getUnqual(IdTy);
 710
 711   ObjCSuperTy = llvm::StructType::get(IdTy, IdTy, NULL);
 712   PtrToObjCSuperTy = llvm::PointerType::getUnqual(ObjCSuperTy);
 713
 714   llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
 715
 716   // void objc_exception_throw(id);
 717   ExceptionThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy, NULL);
 718   ExceptionReThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy, NULL);
 719   // int objc_sync_enter(id);
 720   SyncEnterFn.init(&CGM, "objc_sync_enter", IntTy, IdTy, NULL);
 721   // int objc_sync_exit(id);
 722   SyncExitFn.init(&CGM, "objc_sync_exit", IntTy, IdTy, NULL);
 723
 724   // void objc_enumerationMutation (id)
 725   EnumerationMutationFn.init(&CGM, "objc_enumerationMutation", VoidTy,
 726       IdTy, NULL);
 727
 728   // id objc_getProperty(id, SEL, ptrdiff_t, BOOL)
 729   GetPropertyFn.init(&CGM, "objc_getProperty", IdTy, IdTy, SelectorTy,
 730       PtrDiffTy, BoolTy, NULL);
 731   // void objc_setProperty(id, SEL, ptrdiff_t, id, BOOL, BOOL)
 732   SetPropertyFn.init(&CGM, "objc_setProperty", VoidTy, IdTy, SelectorTy,
 733       PtrDiffTy, IdTy, BoolTy, BoolTy, NULL);
 734   // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
 735   GetStructPropertyFn.init(&CGM, "objc_getPropertyStruct", VoidTy, PtrTy, PtrTy,
 736       PtrDiffTy, BoolTy, BoolTy, NULL);
 737   // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
 738   SetStructPropertyFn.init(&CGM, "objc_setPropertyStruct", VoidTy, PtrTy, PtrTy,
 739       PtrDiffTy, BoolTy, BoolTy, NULL);
 740
 741   // IMP type
 742   llvm::Type *IMPArgs[] = { IdTy, SelectorTy };
 743   IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs,
 744               true));
 745
 746   const LangOptions &Opts = CGM.getLangOptions();
 747   if ((Opts.getGCMode() != LangOptions::NonGC) || Opts.ObjCAutoRefCount)
 748     RuntimeVersion = 10;
 749
 750   // Don't bother initialising the GC stuff unless we're compiling in GC mode
 751   if (Opts.getGCMode() != LangOptions::NonGC) {
 752     // This is a bit of an hack.  We should sort this out by having a proper
 753     // CGObjCGNUstep subclass for GC, but we may want to really support the old
 754     // ABI and GC added in ObjectiveC2.framework, so we fudge it a bit for now
 755     // Get selectors needed in GC mode
 756     RetainSel = GetNullarySelector("retain", CGM.getContext());
 757     ReleaseSel = GetNullarySelector("release", CGM.getContext());
 758     AutoreleaseSel = GetNullarySelector("autorelease", CGM.getContext());
 759
 760     // Get functions needed in GC mode
 761
 762     // id objc_assign_ivar(id, id, ptrdiff_t);
 763     IvarAssignFn.init(&CGM, "objc_assign_ivar", IdTy, IdTy, IdTy, PtrDiffTy,
 764         NULL);
 765     // id objc_assign_strongCast (id, id*)
 766     StrongCastAssignFn.init(&CGM, "objc_assign_strongCast", IdTy, IdTy,
 767         PtrToIdTy, NULL);
 768     // id objc_assign_global(id, id*);
 769     GlobalAssignFn.init(&CGM, "objc_assign_global", IdTy, IdTy, PtrToIdTy,
 770         NULL);
 771     // id objc_assign_weak(id, id*);
 772     WeakAssignFn.init(&CGM, "objc_assign_weak", IdTy, IdTy, PtrToIdTy, NULL);
 773     // id objc_read_weak(id*);
 774     WeakReadFn.init(&CGM, "objc_read_weak", IdTy, PtrToIdTy, NULL);
 775     // void *objc_memmove_collectable(void*, void *, size_t);
 776     MemMoveFn.init(&CGM, "objc_memmove_collectable", PtrTy, PtrTy, PtrTy,
 777         SizeTy, NULL);
 778   }
 779 }
 780
 781 llvm::Value *CGObjCGNU::GetClassNamed(CGBuilderTy &Builder,
 782                                       const std::string &Name,
 783                                       bool isWeak) {
 784   llvm::Value *ClassName = CGM.GetAddrOfConstantCString(Name);
 785   // With the incompatible ABI, this will need to be replaced with a direct
 786   // reference to the class symbol.  For the compatible nonfragile ABI we are
 787   // still performing this lookup at run time but emitting the symbol for the
 788   // class externally so that we can make the switch later.
 789   //
 790   // Libobjc2 contains an LLVM pass that replaces calls to objc_lookup_class
 791   // with memoized versions or with static references if it's safe to do so.
 792   if (!isWeak)
 793     EmitClassRef(Name);
 794   ClassName = Builder.CreateStructGEP(ClassName, 0);
 795
 796   llvm::Type *ArgTys[] = { PtrToInt8Ty };
 797   llvm::Constant *ClassLookupFn =
 798     CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, ArgTys, true),
 799                               "objc_lookup_class");
 800   return Builder.CreateCall(ClassLookupFn, ClassName);
 801 }
 802
 803 // This has to perform the lookup every time, since posing and related
 804 // techniques can modify the name -> class mapping.
 805 llvm::Value *CGObjCGNU::GetClass(CGBuilderTy &Builder,
 806                                  const ObjCInterfaceDecl *OID) {
 807   return GetClassNamed(Builder, OID->getNameAsString(), OID->isWeakImported());
 808 }
 809 llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(CGBuilderTy &Builder) {
 810   return GetClassNamed(Builder, "NSAutoreleasePool", false);
 811 }
 812
 813 llvm::Value *CGObjCGNU::GetSelector(CGBuilderTy &Builder, Selector Sel,
 814     const std::string &TypeEncoding, bool lval) {
 815
 816   llvm::SmallVector<TypedSelector, 2> &Types = SelectorTable[Sel];
 817   llvm::GlobalAlias *SelValue = 0;
 818
 819
 820   for (llvm::SmallVectorImpl<TypedSelector>::iterator i = Types.begin(),
 821       e = Types.end() ; i!=e ; i++) {
 822     if (i->first == TypeEncoding) {
 823       SelValue = i->second;
 824       break;
 825     }
 826   }
 827   if (0 == SelValue) {
 828     SelValue = new llvm::GlobalAlias(SelectorTy,
 829                                      llvm::GlobalValue::PrivateLinkage,
 830                                      ".objc_selector_"+Sel.getAsString(), NULL,
 831                                      &TheModule);
 832     Types.push_back(TypedSelector(TypeEncoding, SelValue));
 833   }
 834
 835   if (lval) {
 836     llvm::Value *tmp = Builder.CreateAlloca(SelValue->getType());
 837     Builder.CreateStore(SelValue, tmp);
 838     return tmp;
 839   }
 840   return SelValue;
 841 }
 842
 843 llvm::Value *CGObjCGNU::GetSelector(CGBuilderTy &Builder, Selector Sel,
 844                                     bool lval) {
 845   return GetSelector(Builder, Sel, std::string(), lval);
 846 }
 847
 848 llvm::Value *CGObjCGNU::GetSelector(CGBuilderTy &Builder, const ObjCMethodDecl
 849     *Method) {
 850   std::string SelTypes;
 851   CGM.getContext().getObjCEncodingForMethodDecl(Method, SelTypes);
 852   return GetSelector(Builder, Method->getSelector(), SelTypes, false);
 853 }
 854
 855 llvm::Constant *CGObjCGNU::GetEHType(QualType T) {
 856   if (!CGM.getLangOptions().CPlusPlus) {
 857       if (T->isObjCIdType()
 858           || T->isObjCQualifiedIdType()) {
 859         // With the old ABI, there was only one kind of catchall, which broke
 860         // foreign exceptions.  With the new ABI, we use __objc_id_typeinfo as
 861         // a pointer indicating object catchalls, and NULL to indicate real
 862         // catchalls
 863         if (CGM.getLangOptions().ObjCNonFragileABI) {
 864           return MakeConstantString("@id");
 865         } else {
 866           return 0;
 867         }
 868       }
 869
 870       // All other types should be Objective-C interface pointer types.
 871       const ObjCObjectPointerType *OPT =
 872         T->getAs<ObjCObjectPointerType>();
 873       assert(OPT && "Invalid @catch type.");
 874       const ObjCInterfaceDecl *IDecl =
 875         OPT->getObjectType()->getInterface();
 876       assert(IDecl && "Invalid @catch type.");
 877       return MakeConstantString(IDecl->getIdentifier()->getName());
 878   }
 879   // For Objective-C++, we want to provide the ability to catch both C++ and
 880   // Objective-C objects in the same function.
 881
 882   // There's a particular fixed type info for 'id'.
 883   if (T->isObjCIdType() ||
 884       T->isObjCQualifiedIdType()) {
 885     llvm::Constant *IDEHType =
 886       CGM.getModule().getGlobalVariable("__objc_id_type_info");
 887     if (!IDEHType)
 888       IDEHType =
 889         new llvm::GlobalVariable(CGM.getModule(), PtrToInt8Ty,
 890                                  false,
 891                                  llvm::GlobalValue::ExternalLinkage,
 892                                  0, "__objc_id_type_info");
 893     return llvm::ConstantExpr::getBitCast(IDEHType, PtrToInt8Ty);
 894   }
 895
 896   const ObjCObjectPointerType *PT =
 897     T->getAs<ObjCObjectPointerType>();
 898   assert(PT && "Invalid @catch type.");
 899   const ObjCInterfaceType *IT = PT->getInterfaceType();
 900   assert(IT && "Invalid @catch type.");
 901   std::string className = IT->getDecl()->getIdentifier()->getName();
 902
 903   std::string typeinfoName = "__objc_eh_typeinfo_" + className;
 904
 905   // Return the existing typeinfo if it exists
 906   llvm::Constant *typeinfo = TheModule.getGlobalVariable(typeinfoName);
 907   if (typeinfo) return typeinfo;
 908
 909   // Otherwise create it.
 910
 911   // vtable for gnustep::libobjc::__objc_class_type_info
 912   // It's quite ugly hard-coding this.  Ideally we'd generate it using the host
 913   // platform's name mangling.
 914   const char *vtableName = "_ZTVN7gnustep7libobjc22__objc_class_type_infoE";
 915   llvm::Constant *Vtable = TheModule.getGlobalVariable(vtableName);
 916   if (!Vtable) {
 917     Vtable = new llvm::GlobalVariable(TheModule, PtrToInt8Ty, true,
 918             llvm::GlobalValue::ExternalLinkage, 0, vtableName);
 919   }
 920   llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2);
 921   Vtable = llvm::ConstantExpr::getGetElementPtr(Vtable, &Two, 1);
 922   Vtable = llvm::ConstantExpr::getBitCast(Vtable, PtrToInt8Ty);
 923
 924   llvm::Constant *typeName =
 925     ExportUniqueString(className, "__objc_eh_typename_");
 926
 927   std::vector<llvm::Constant*> fields;
 928   fields.push_back(Vtable);
 929   fields.push_back(typeName);
 930   llvm::Constant *TI =
 931       MakeGlobal(llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty,
 932               NULL), fields, "__objc_eh_typeinfo_" + className,
 933           llvm::GlobalValue::LinkOnceODRLinkage);
 934   return llvm::ConstantExpr::getBitCast(TI, PtrToInt8Ty);
 935 }
 936
 937 /// Generate an NSConstantString object.
 938 llvm::Constant *CGObjCGNU::GenerateConstantString(const StringLiteral *SL) {
 939
 940   std::string Str = SL->getString().str();
 941
 942   // Look for an existing one
 943   llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
 944   if (old != ObjCStrings.end())
 945     return old->getValue();
 946
 947   std::vector<llvm::Constant*> Ivars;
 948   Ivars.push_back(NULLPtr);
 949   Ivars.push_back(MakeConstantString(Str));
 950   Ivars.push_back(llvm::ConstantInt::get(IntTy, Str.size()));
 951   llvm::Constant *ObjCStr = MakeGlobal(
 952     llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy, NULL),
 953     Ivars, ".objc_str");
 954   ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty);
 955   ObjCStrings[Str] = ObjCStr;
 956   ConstantStrings.push_back(ObjCStr);
 957   return ObjCStr;
 958 }
 959
 960 ///Generates a message send where the super is the receiver.  This is a message
 961 ///send to self with special delivery semantics indicating which class's method
 962 ///should be called.
 963 RValue
 964 CGObjCGNU::GenerateMessageSendSuper(CodeGenFunction &CGF,
 965                                     ReturnValueSlot Return,
 966                                     QualType ResultType,
 967                                     Selector Sel,
 968                                     const ObjCInterfaceDecl *Class,
 969                                     bool isCategoryImpl,
 970                                     llvm::Value *Receiver,
 971                                     bool IsClassMessage,
 972                                     const CallArgList &CallArgs,
 973                                     const ObjCMethodDecl *Method) {
 974   CGBuilderTy &Builder = CGF.Builder;
 975   if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly) {
 976     if (Sel == RetainSel || Sel == AutoreleaseSel) {
 977       return RValue::get(EnforceType(Builder, Receiver,
 978                   CGM.getTypes().ConvertType(ResultType)));
 979     }
 980     if (Sel == ReleaseSel) {
 981       return RValue::get(0);
 982     }
 983   }
 984
 985   llvm::Value *cmd = GetSelector(Builder, Sel);
 986
 987
 988   CallArgList ActualArgs;
 989
 990   ActualArgs.add(RValue::get(EnforceType(Builder, Receiver, IdTy)), ASTIdTy);
 991   ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
 992   ActualArgs.addFrom(CallArgs);
 993
 994   CodeGenTypes &Types = CGM.getTypes();
 995   const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs,
 996                                                        FunctionType::ExtInfo());
 997
 998   llvm::Value *ReceiverClass = 0;
 999   if (isCategoryImpl) {
1000     llvm::Constant *classLookupFunction = 0;
1001     if (IsClassMessage)  {
1002       llvm::Type *ArgTys[] = { PtrTy };
1003       classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
1004             IdTy, ArgTys, true), "objc_get_meta_class");
1005     } else {
1006       llvm::Type *ArgTys[] = { PtrTy };
1007       classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
1008             IdTy, ArgTys, true), "objc_get_class");
1009     }
1010     ReceiverClass = Builder.CreateCall(classLookupFunction,
1011         MakeConstantString(Class->getNameAsString()));
1012   } else {
1013     // Set up global aliases for the metaclass or class pointer if they do not
1014     // already exist.  These will are forward-references which will be set to
1015     // pointers to the class and metaclass structure created for the runtime
1016     // load function.  To send a message to super, we look up the value of the
1017     // super_class pointer from either the class or metaclass structure.
1018     if (IsClassMessage)  {
1019       if (!MetaClassPtrAlias) {
1020         MetaClassPtrAlias = new llvm::GlobalAlias(IdTy,
1021             llvm::GlobalValue::InternalLinkage, ".objc_metaclass_ref" +
1022             Class->getNameAsString(), NULL, &TheModule);
1023       }
1024       ReceiverClass = MetaClassPtrAlias;
1025     } else {
1026       if (!ClassPtrAlias) {
1027         ClassPtrAlias = new llvm::GlobalAlias(IdTy,
1028             llvm::GlobalValue::InternalLinkage, ".objc_class_ref" +
1029             Class->getNameAsString(), NULL, &TheModule);
1030       }
1031       ReceiverClass = ClassPtrAlias;
1032     }
1033   }
1034   // Cast the pointer to a simplified version of the class structure
1035   ReceiverClass = Builder.CreateBitCast(ReceiverClass,
1036       llvm::PointerType::getUnqual(
1037         llvm::StructType::get(IdTy, IdTy, NULL)));
1038   // Get the superclass pointer
1039   ReceiverClass = Builder.CreateStructGEP(ReceiverClass, 1);
1040   // Load the superclass pointer
1041   ReceiverClass = Builder.CreateLoad(ReceiverClass);
1042   // Construct the structure used to look up the IMP
1043   llvm::StructType *ObjCSuperTy = llvm::StructType::get(
1044       Receiver->getType(), IdTy, NULL);
1045   llvm::Value *ObjCSuper = Builder.CreateAlloca(ObjCSuperTy);
1046
1047   Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0));
1048   Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1));
1049
1050   ObjCSuper = EnforceType(Builder, ObjCSuper, PtrToObjCSuperTy);
1051   const llvm::FunctionType *impType =
1052     Types.GetFunctionType(FnInfo, Method ? Method->isVariadic() : false);
1053
1054   // Get the IMP
1055   llvm::Value *imp = LookupIMPSuper(CGF, ObjCSuper, cmd);
1056   imp = EnforceType(Builder, imp, llvm::PointerType::getUnqual(impType));
1057
1058   llvm::Value *impMD[] = {
1059       llvm::MDString::get(VMContext, Sel.getAsString()),
1060       llvm::MDString::get(VMContext, Class->getSuperClass()->getNameAsString()),
1061       llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), IsClassMessage)
1062    };
1063   llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
1064
1065   llvm::Instruction *call;
1066   RValue msgRet = CGF.EmitCall(FnInfo, imp, Return, ActualArgs,
1067       0, &call);
1068   call->setMetadata(msgSendMDKind, node);
1069   return msgRet;
1070 }
1071
1072 /// Generate code for a message send expression.
1073 RValue
1074 CGObjCGNU::GenerateMessageSend(CodeGenFunction &CGF,
1075                                ReturnValueSlot Return,
1076                                QualType ResultType,
1077                                Selector Sel,
1078                                llvm::Value *Receiver,
1079                                const CallArgList &CallArgs,
1080                                const ObjCInterfaceDecl *Class,
1081                                const ObjCMethodDecl *Method) {
1082   CGBuilderTy &Builder = CGF.Builder;
1083
1084   // Strip out message sends to retain / release in GC mode
1085   if (CGM.getLangOptions().getGCMode() == LangOptions::GCOnly) {
1086     if (Sel == RetainSel || Sel == AutoreleaseSel) {
1087       return RValue::get(EnforceType(Builder, Receiver,
1088                   CGM.getTypes().ConvertType(ResultType)));
1089     }
1090     if (Sel == ReleaseSel) {
1091       return RValue::get(0);
1092     }
1093   }
1094
1095   // If the return type is something that goes in an integer register, the
1096   // runtime will handle 0 returns.  For other cases, we fill in the 0 value
1097   // ourselves.
1098   //
1099   // The language spec says the result of this kind of message send is
1100   // undefined, but lots of people seem to have forgotten to read that
1101   // paragraph and insist on sending messages to nil that have structure
1102   // returns.  With GCC, this generates a random return value (whatever happens
1103   // to be on the stack / in those registers at the time) on most platforms,
1104   // and generates an illegal instruction trap on SPARC.  With LLVM it corrupts
1105   // the stack.
1106   bool isPointerSizedReturn = (ResultType->isAnyPointerType() ||
1107       ResultType->isIntegralOrEnumerationType() || ResultType->isVoidType());
1108
1109   llvm::BasicBlock *startBB = 0;
1110   llvm::BasicBlock *messageBB = 0;
1111   llvm::BasicBlock *continueBB = 0;
1112
1113   if (!isPointerSizedReturn) {
1114     startBB = Builder.GetInsertBlock();
1115     messageBB = CGF.createBasicBlock("msgSend");
1116     continueBB = CGF.createBasicBlock("continue");
1117
1118     llvm::Value *isNil = Builder.CreateICmpEQ(Receiver,
1119             llvm::Constant::getNullValue(Receiver->getType()));
1120     Builder.CreateCondBr(isNil, continueBB, messageBB);
1121     CGF.EmitBlock(messageBB);
1122   }
1123
1124   IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
1125   llvm::Value *cmd;
1126   if (Method)
1127     cmd = GetSelector(Builder, Method);
1128   else
1129     cmd = GetSelector(Builder, Sel);
1130   cmd = EnforceType(Builder, cmd, SelectorTy);
1131   Receiver = EnforceType(Builder, Receiver, IdTy);
1132
1133   llvm::Value *impMD[] = {
1134         llvm::MDString::get(VMContext, Sel.getAsString()),
1135         llvm::MDString::get(VMContext, Class ? Class->getNameAsString() :""),
1136         llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), Class!=0)
1137    };
1138   llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
1139
1140   // Get the IMP to call
1141   llvm::Value *imp = LookupIMP(CGF, Receiver, cmd, node);
1142
1143   CallArgList ActualArgs;
1144   ActualArgs.add(RValue::get(Receiver), ASTIdTy);
1145   ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
1146   ActualArgs.addFrom(CallArgs);
1147
1148   CodeGenTypes &Types = CGM.getTypes();
1149   const CGFunctionInfo &FnInfo = Types.getFunctionInfo(ResultType, ActualArgs,
1150                                                        FunctionType::ExtInfo());
1151   const llvm::FunctionType *impType =
1152     Types.GetFunctionType(FnInfo, Method ? Method->isVariadic() : false);
1153   imp = EnforceType(Builder, imp, llvm::PointerType::getUnqual(impType));
1154
1155
1156   // For sender-aware dispatch, we pass the sender as the third argument to a
1157   // lookup function.  When sending messages from C code, the sender is nil.
1158   // objc_msg_lookup_sender(id *receiver, SEL selector, id sender);
1159   llvm::Instruction *call;
1160   RValue msgRet = CGF.EmitCall(FnInfo, imp, Return, ActualArgs,
1161       0, &call);
1162   call->setMetadata(msgSendMDKind, node);
1163
1164
1165   if (!isPointerSizedReturn) {
1166     messageBB = CGF.Builder.GetInsertBlock();
1167     CGF.Builder.CreateBr(continueBB);
1168     CGF.EmitBlock(continueBB);
1169     if (msgRet.isScalar()) {
1170       llvm::Value *v = msgRet.getScalarVal();
1171       llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2);
1172       phi->addIncoming(v, messageBB);
1173       phi->addIncoming(llvm::Constant::getNullValue(v->getType()), startBB);
1174       msgRet = RValue::get(phi);
1175     } else if (msgRet.isAggregate()) {
1176       llvm::Value *v = msgRet.getAggregateAddr();
1177       llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2);
1178       const llvm::PointerType *RetTy = cast<llvm::PointerType>(v->getType());
1179       llvm::AllocaInst *NullVal =
1180           CGF.CreateTempAlloca(RetTy->getElementType(), "null");
1181       CGF.InitTempAlloca(NullVal,
1182           llvm::Constant::getNullValue(RetTy->getElementType()));
1183       phi->addIncoming(v, messageBB);
1184       phi->addIncoming(NullVal, startBB);
1185       msgRet = RValue::getAggregate(phi);
1186     } else /* isComplex() */ {
1187       std::pair<llvm::Value*,llvm::Value*> v = msgRet.getComplexVal();
1188       llvm::PHINode *phi = Builder.CreatePHI(v.first->getType(), 2);
1189       phi->addIncoming(v.first, messageBB);
1190       phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()),
1191           startBB);
1192       llvm::PHINode *phi2 = Builder.CreatePHI(v.second->getType(), 2);
1193       phi2->addIncoming(v.second, messageBB);
1194       phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()),
1195           startBB);
1196       msgRet = RValue::getComplex(phi, phi2);
1197     }
1198   }
1199   return msgRet;
1200 }
1201
1202 /// Generates a MethodList.  Used in construction of a objc_class and
1203 /// objc_category structures.
1204 llvm::Constant *CGObjCGNU::GenerateMethodList(const llvm::StringRef &ClassName,
1205                                               const llvm::StringRef &CategoryName,
1206     const llvm::SmallVectorImpl<Selector> &MethodSels,
1207     const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes,
1208     bool isClassMethodList) {
1209   if (MethodSels.empty())
1210     return NULLPtr;
1211   // Get the method structure type.
1212   llvm::StructType *ObjCMethodTy = llvm::StructType::get(
1213     PtrToInt8Ty, // Really a selector, but the runtime creates it us.
1214     PtrToInt8Ty, // Method types
1215     IMPTy, //Method pointer
1216     NULL);
1217   std::vector<llvm::Constant*> Methods;
1218   std::vector<llvm::Constant*> Elements;
1219   for (unsigned int i = 0, e = MethodTypes.size(); i < e; ++i) {
1220     Elements.clear();
1221     llvm::Constant *Method =
1222       TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName,
1223                                                 MethodSels[i],
1224                                                 isClassMethodList));
1225     assert(Method && "Can't generate metadata for method that doesn't exist");
1226     llvm::Constant *C = MakeConstantString(MethodSels[i].getAsString());
1227     Elements.push_back(C);
1228     Elements.push_back(MethodTypes[i]);
1229     Method = llvm::ConstantExpr::getBitCast(Method,
1230         IMPTy);
1231     Elements.push_back(Method);
1232     Methods.push_back(llvm::ConstantStruct::get(ObjCMethodTy, Elements));
1233   }
1234
1235   // Array of method structures
1236   llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodTy,
1237                                                             Methods.size());
1238   llvm::Constant *MethodArray = llvm::ConstantArray::get(ObjCMethodArrayTy,
1239                                                          Methods);
1240
1241   // Structure containing list pointer, array and array count
1242   llvm::StructType *ObjCMethodListTy =
1243     llvm::StructType::createNamed(VMContext, "");
1244   llvm::Type *NextPtrTy = llvm::PointerType::getUnqual(ObjCMethodListTy);
1245   ObjCMethodListTy->setBody(
1246       NextPtrTy,
1247       IntTy,
1248       ObjCMethodArrayTy,
1249       NULL);
1250
1251   Methods.clear();
1252   Methods.push_back(llvm::ConstantPointerNull::get(
1253         llvm::PointerType::getUnqual(ObjCMethodListTy)));
1254   Methods.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
1255         MethodTypes.size()));
1256   Methods.push_back(MethodArray);
1257
1258   // Create an instance of the structure
1259   return MakeGlobal(ObjCMethodListTy, Methods, ".objc_method_list");
1260 }
1261
1262 /// Generates an IvarList.  Used in construction of a objc_class.
1263 llvm::Constant *CGObjCGNU::GenerateIvarList(
1264     const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
1265     const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
1266     const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets) {
1267   if (IvarNames.size() == 0)
1268     return NULLPtr;
1269   // Get the method structure type.
1270   llvm::StructType *ObjCIvarTy = llvm::StructType::get(
1271     PtrToInt8Ty,
1272     PtrToInt8Ty,
1273     IntTy,
1274     NULL);
1275   std::vector<llvm::Constant*> Ivars;
1276   std::vector<llvm::Constant*> Elements;
1277   for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
1278     Elements.clear();
1279     Elements.push_back(IvarNames[i]);
1280     Elements.push_back(IvarTypes[i]);
1281     Elements.push_back(IvarOffsets[i]);
1282     Ivars.push_back(llvm::ConstantStruct::get(ObjCIvarTy, Elements));
1283   }
1284
1285   // Array of method structures
1286   llvm::ArrayType *ObjCIvarArrayTy = llvm::ArrayType::get(ObjCIvarTy,
1287       IvarNames.size());
1288
1289
1290   Elements.clear();
1291   Elements.push_back(llvm::ConstantInt::get(IntTy, (int)IvarNames.size()));
1292   Elements.push_back(llvm::ConstantArray::get(ObjCIvarArrayTy, Ivars));
1293   // Structure containing array and array count
1294   llvm::StructType *ObjCIvarListTy = llvm::StructType::get(IntTy,
1295     ObjCIvarArrayTy,
1296     NULL);
1297
1298   // Create an instance of the structure
1299   return MakeGlobal(ObjCIvarListTy, Elements, ".objc_ivar_list");
1300 }
1301
1302 /// Generate a class structure
1303 llvm::Constant *CGObjCGNU::GenerateClassStructure(
1304     llvm::Constant *MetaClass,
1305     llvm::Constant *SuperClass,
1306     unsigned info,
1307     const char *Name,
1308     llvm::Constant *Version,
1309     llvm::Constant *InstanceSize,
1310     llvm::Constant *IVars,
1311     llvm::Constant *Methods,
1312     llvm::Constant *Protocols,
1313     llvm::Constant *IvarOffsets,
1314     llvm::Constant *Properties,
1315     bool isMeta) {
1316   // Set up the class structure
1317   // Note:  Several of these are char*s when they should be ids.  This is
1318   // because the runtime performs this translation on load.
1319   //
1320   // Fields marked New ABI are part of the GNUstep runtime.  We emit them
1321   // anyway; the classes will still work with the GNU runtime, they will just
1322   // be ignored.
1323   llvm::StructType *ClassTy = llvm::StructType::get(
1324       PtrToInt8Ty,        // class_pointer
1325       PtrToInt8Ty,        // super_class
1326       PtrToInt8Ty,        // name
1327       LongTy,             // version
1328       LongTy,             // info
1329       LongTy,             // instance_size
1330       IVars->getType(),   // ivars
1331       Methods->getType(), // methods
1332       // These are all filled in by the runtime, so we pretend
1333       PtrTy,              // dtable
1334       PtrTy,              // subclass_list
1335       PtrTy,              // sibling_class
1336       PtrTy,              // protocols
1337       PtrTy,              // gc_object_type
1338       // New ABI:
1339       LongTy,                 // abi_version
1340       IvarOffsets->getType(), // ivar_offsets
1341       Properties->getType(),  // properties
1342       NULL);
1343   llvm::Constant *Zero = llvm::ConstantInt::get(LongTy, 0);
1344   // Fill in the structure
1345   std::vector<llvm::Constant*> Elements;
1346   Elements.push_back(llvm::ConstantExpr::getBitCast(MetaClass, PtrToInt8Ty));
1347   Elements.push_back(SuperClass);
1348   Elements.push_back(MakeConstantString(Name, ".class_name"));
1349   Elements.push_back(Zero);
1350   Elements.push_back(llvm::ConstantInt::get(LongTy, info));
1351   if (isMeta) {
1352     llvm::TargetData td(&TheModule);
1353     Elements.push_back(
1354         llvm::ConstantInt::get(LongTy,
1355                                td.getTypeSizeInBits(ClassTy) /
1356                                  CGM.getContext().getCharWidth()));
1357   } else
1358     Elements.push_back(InstanceSize);
1359   Elements.push_back(IVars);
1360   Elements.push_back(Methods);
1361   Elements.push_back(NULLPtr);
1362   Elements.push_back(NULLPtr);
1363   Elements.push_back(NULLPtr);
1364   Elements.push_back(llvm::ConstantExpr::getBitCast(Protocols, PtrTy));
1365   Elements.push_back(NULLPtr);
1366   Elements.push_back(Zero);
1367   Elements.push_back(IvarOffsets);
1368   Elements.push_back(Properties);
1369   // Create an instance of the structure
1370   // This is now an externally visible symbol, so that we can speed up class
1371   // messages in the next ABI.
1372   return MakeGlobal(ClassTy, Elements, (isMeta ? "_OBJC_METACLASS_":
1373       "_OBJC_CLASS_") + std::string(Name), llvm::GlobalValue::ExternalLinkage);
1374 }
1375
1376 llvm::Constant *CGObjCGNU::GenerateProtocolMethodList(
1377     const llvm::SmallVectorImpl<llvm::Constant *>  &MethodNames,
1378     const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes) {
1379   // Get the method structure type.
1380   llvm::StructType *ObjCMethodDescTy = llvm::StructType::get(
1381     PtrToInt8Ty, // Really a selector, but the runtime does the casting for us.
1382     PtrToInt8Ty,
1383     NULL);
1384   std::vector<llvm::Constant*> Methods;
1385   std::vector<llvm::Constant*> Elements;
1386   for (unsigned int i = 0, e = MethodTypes.size() ; i < e ; i++) {
1387     Elements.clear();
1388     Elements.push_back(MethodNames[i]);
1389     Elements.push_back(MethodTypes[i]);
1390     Methods.push_back(llvm::ConstantStruct::get(ObjCMethodDescTy, Elements));
1391   }
1392   llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodDescTy,
1393       MethodNames.size());
1394   llvm::Constant *Array = llvm::ConstantArray::get(ObjCMethodArrayTy,
1395                                                    Methods);
1396   llvm::StructType *ObjCMethodDescListTy = llvm::StructType::get(
1397       IntTy, ObjCMethodArrayTy, NULL);
1398   Methods.clear();
1399   Methods.push_back(llvm::ConstantInt::get(IntTy, MethodNames.size()));
1400   Methods.push_back(Array);
1401   return MakeGlobal(ObjCMethodDescListTy, Methods, ".objc_method_list");
1402 }
1403
1404 // Create the protocol list structure used in classes, categories and so on
1405 llvm::Constant *CGObjCGNU::GenerateProtocolList(
1406     const llvm::SmallVectorImpl<std::string> &Protocols) {
1407   llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
1408       Protocols.size());
1409   llvm::StructType *ProtocolListTy = llvm::StructType::get(
1410       PtrTy, //Should be a recurisve pointer, but it's always NULL here.
1411       SizeTy,
1412       ProtocolArrayTy,
1413       NULL);
1414   std::vector<llvm::Constant*> Elements;
1415   for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end();
1416       iter != endIter ; iter++) {
1417     llvm::Constant *protocol = 0;
1418     llvm::StringMap<llvm::Constant*>::iterator value =
1419       ExistingProtocols.find(*iter);
1420     if (value == ExistingProtocols.end()) {
1421       protocol = GenerateEmptyProtocol(*iter);
1422     } else {
1423       protocol = value->getValue();
1424     }
1425     llvm::Constant *Ptr = llvm::ConstantExpr::getBitCast(protocol,
1426                                                            PtrToInt8Ty);
1427     Elements.push_back(Ptr);
1428   }
1429   llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
1430       Elements);
1431   Elements.clear();
1432   Elements.push_back(NULLPtr);
1433   Elements.push_back(llvm::ConstantInt::get(LongTy, Protocols.size()));
1434   Elements.push_back(ProtocolArray);
1435   return MakeGlobal(ProtocolListTy, Elements, ".objc_protocol_list");
1436 }
1437
1438 llvm::Value *CGObjCGNU::GenerateProtocolRef(CGBuilderTy &Builder,
1439                                             const ObjCProtocolDecl *PD) {
1440   llvm::Value *protocol = ExistingProtocols[PD->getNameAsString()];
1441   const llvm::Type *T =
1442     CGM.getTypes().ConvertType(CGM.getContext().getObjCProtoType());
1443   return Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
1444 }
1445
1446 llvm::Constant *CGObjCGNU::GenerateEmptyProtocol(
1447   const std::string &ProtocolName) {
1448   llvm::SmallVector<std::string, 0> EmptyStringVector;
1449   llvm::SmallVector<llvm::Constant*, 0> EmptyConstantVector;
1450
1451   llvm::Constant *ProtocolList = GenerateProtocolList(EmptyStringVector);
1452   llvm::Constant *MethodList =
1453     GenerateProtocolMethodList(EmptyConstantVector, EmptyConstantVector);
1454   // Protocols are objects containing lists of the methods implemented and
1455   // protocols adopted.
1456   llvm::StructType *ProtocolTy = llvm::StructType::get(IdTy,
1457       PtrToInt8Ty,
1458       ProtocolList->getType(),
1459       MethodList->getType(),
1460       MethodList->getType(),
1461       MethodList->getType(),
1462       MethodList->getType(),
1463       NULL);
1464   std::vector<llvm::Constant*> Elements;
1465   // The isa pointer must be set to a magic number so the runtime knows it's
1466   // the correct layout.
1467   Elements.push_back(llvm::ConstantExpr::getIntToPtr(
1468         llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
1469           ProtocolVersion), IdTy));
1470   Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
1471   Elements.push_back(ProtocolList);
1472   Elements.push_back(MethodList);
1473   Elements.push_back(MethodList);
1474   Elements.push_back(MethodList);
1475   Elements.push_back(MethodList);
1476   return MakeGlobal(ProtocolTy, Elements, ".objc_protocol");
1477 }
1478
1479 void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) {
1480   ASTContext &Context = CGM.getContext();
1481   std::string ProtocolName = PD->getNameAsString();
1482   llvm::SmallVector<std::string, 16> Protocols;
1483   for (ObjCProtocolDecl::protocol_iterator PI = PD->protocol_begin(),
1484        E = PD->protocol_end(); PI != E; ++PI)
1485     Protocols.push_back((*PI)->getNameAsString());
1486   llvm::SmallVector<llvm::Constant*, 16> InstanceMethodNames;
1487   llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
1488   llvm::SmallVector<llvm::Constant*, 16> OptionalInstanceMethodNames;
1489   llvm::SmallVector<llvm::Constant*, 16> OptionalInstanceMethodTypes;
1490   for (ObjCProtocolDecl::instmeth_iterator iter = PD->instmeth_begin(),
1491        E = PD->instmeth_end(); iter != E; iter++) {
1492     std::string TypeStr;
1493     Context.getObjCEncodingForMethodDecl(*iter, TypeStr);
1494     if ((*iter)->getImplementationControl() == ObjCMethodDecl::Optional) {
1495       InstanceMethodNames.push_back(
1496           MakeConstantString((*iter)->getSelector().getAsString()));
1497       InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1498     } else {
1499       OptionalInstanceMethodNames.push_back(
1500           MakeConstantString((*iter)->getSelector().getAsString()));
1501       OptionalInstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1502     }
1503   }
1504   // Collect information about class methods:
1505   llvm::SmallVector<llvm::Constant*, 16> ClassMethodNames;
1506   llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
1507   llvm::SmallVector<llvm::Constant*, 16> OptionalClassMethodNames;
1508   llvm::SmallVector<llvm::Constant*, 16> OptionalClassMethodTypes;
1509   for (ObjCProtocolDecl::classmeth_iterator
1510          iter = PD->classmeth_begin(), endIter = PD->classmeth_end();
1511        iter != endIter ; iter++) {
1512     std::string TypeStr;
1513     Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
1514     if ((*iter)->getImplementationControl() == ObjCMethodDecl::Optional) {
1515       ClassMethodNames.push_back(
1516           MakeConstantString((*iter)->getSelector().getAsString()));
1517       ClassMethodTypes.push_back(MakeConstantString(TypeStr));
1518     } else {
1519       OptionalClassMethodNames.push_back(
1520           MakeConstantString((*iter)->getSelector().getAsString()));
1521       OptionalClassMethodTypes.push_back(MakeConstantString(TypeStr));
1522     }
1523   }
1524
1525   llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
1526   llvm::Constant *InstanceMethodList =
1527     GenerateProtocolMethodList(InstanceMethodNames, InstanceMethodTypes);
1528   llvm::Constant *ClassMethodList =
1529     GenerateProtocolMethodList(ClassMethodNames, ClassMethodTypes);
1530   llvm::Constant *OptionalInstanceMethodList =
1531     GenerateProtocolMethodList(OptionalInstanceMethodNames,
1532             OptionalInstanceMethodTypes);
1533   llvm::Constant *OptionalClassMethodList =
1534     GenerateProtocolMethodList(OptionalClassMethodNames,
1535             OptionalClassMethodTypes);
1536
1537   // Property metadata: name, attributes, isSynthesized, setter name, setter
1538   // types, getter name, getter types.
1539   // The isSynthesized value is always set to 0 in a protocol.  It exists to
1540   // simplify the runtime library by allowing it to use the same data
1541   // structures for protocol metadata everywhere.
1542   llvm::StructType *PropertyMetadataTy = llvm::StructType::get(
1543           PtrToInt8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty,
1544           PtrToInt8Ty, NULL);
1545   std::vector<llvm::Constant*> Properties;
1546   std::vector<llvm::Constant*> OptionalProperties;
1547
1548   // Add all of the property methods need adding to the method list and to the
1549   // property metadata list.
1550   for (ObjCContainerDecl::prop_iterator
1551          iter = PD->prop_begin(), endIter = PD->prop_end();
1552        iter != endIter ; iter++) {
1553     std::vector<llvm::Constant*> Fields;
1554     ObjCPropertyDecl *property = (*iter);
1555
1556     Fields.push_back(MakeConstantString(property->getNameAsString()));
1557     Fields.push_back(llvm::ConstantInt::get(Int8Ty,
1558                 property->getPropertyAttributes()));
1559     Fields.push_back(llvm::ConstantInt::get(Int8Ty, 0));
1560     if (ObjCMethodDecl *getter = property->getGetterMethodDecl()) {
1561       std::string TypeStr;
1562       Context.getObjCEncodingForMethodDecl(getter,TypeStr);
1563       llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1564       InstanceMethodTypes.push_back(TypeEncoding);
1565       Fields.push_back(MakeConstantString(getter->getSelector().getAsString()));
1566       Fields.push_back(TypeEncoding);
1567     } else {
1568       Fields.push_back(NULLPtr);
1569       Fields.push_back(NULLPtr);
1570     }
1571     if (ObjCMethodDecl *setter = property->getSetterMethodDecl()) {
1572       std::string TypeStr;
1573       Context.getObjCEncodingForMethodDecl(setter,TypeStr);
1574       llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1575       InstanceMethodTypes.push_back(TypeEncoding);
1576       Fields.push_back(MakeConstantString(setter->getSelector().getAsString()));
1577       Fields.push_back(TypeEncoding);
1578     } else {
1579       Fields.push_back(NULLPtr);
1580       Fields.push_back(NULLPtr);
1581     }
1582     if (property->getPropertyImplementation() == ObjCPropertyDecl::Optional) {
1583       OptionalProperties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1584     } else {
1585       Properties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1586     }
1587   }
1588   llvm::Constant *PropertyArray = llvm::ConstantArray::get(
1589       llvm::ArrayType::get(PropertyMetadataTy, Properties.size()), Properties);
1590   llvm::Constant* PropertyListInitFields[] =
1591     {llvm::ConstantInt::get(IntTy, Properties.size()), NULLPtr, PropertyArray};
1592
1593   llvm::Constant *PropertyListInit =
1594       llvm::ConstantStruct::getAnon(PropertyListInitFields);
1595   llvm::Constant *PropertyList = new llvm::GlobalVariable(TheModule,
1596       PropertyListInit->getType(), false, llvm::GlobalValue::InternalLinkage,
1597       PropertyListInit, ".objc_property_list");
1598
1599   llvm::Constant *OptionalPropertyArray =
1600       llvm::ConstantArray::get(llvm::ArrayType::get(PropertyMetadataTy,
1601           OptionalProperties.size()) , OptionalProperties);
1602   llvm::Constant* OptionalPropertyListInitFields[] = {
1603       llvm::ConstantInt::get(IntTy, OptionalProperties.size()), NULLPtr,
1604       OptionalPropertyArray };
1605
1606   llvm::Constant *OptionalPropertyListInit =
1607       llvm::ConstantStruct::getAnon(OptionalPropertyListInitFields);
1608   llvm::Constant *OptionalPropertyList = new llvm::GlobalVariable(TheModule,
1609           OptionalPropertyListInit->getType(), false,
1610           llvm::GlobalValue::InternalLinkage, OptionalPropertyListInit,
1611           ".objc_property_list");
1612
1613   // Protocols are objects containing lists of the methods implemented and
1614   // protocols adopted.
1615   llvm::StructType *ProtocolTy = llvm::StructType::get(IdTy,
1616       PtrToInt8Ty,
1617       ProtocolList->getType(),
1618       InstanceMethodList->getType(),
1619       ClassMethodList->getType(),
1620       OptionalInstanceMethodList->getType(),
1621       OptionalClassMethodList->getType(),
1622       PropertyList->getType(),
1623       OptionalPropertyList->getType(),
1624       NULL);
1625   std::vector<llvm::Constant*> Elements;
1626   // The isa pointer must be set to a magic number so the runtime knows it's
1627   // the correct layout.
1628   Elements.push_back(llvm::ConstantExpr::getIntToPtr(
1629         llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
1630           ProtocolVersion), IdTy));
1631   Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
1632   Elements.push_back(ProtocolList);
1633   Elements.push_back(InstanceMethodList);
1634   Elements.push_back(ClassMethodList);
1635   Elements.push_back(OptionalInstanceMethodList);
1636   Elements.push_back(OptionalClassMethodList);
1637   Elements.push_back(PropertyList);
1638   Elements.push_back(OptionalPropertyList);
1639   ExistingProtocols[ProtocolName] =
1640     llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolTy, Elements,
1641           ".objc_protocol"), IdTy);
1642 }
1643 void CGObjCGNU::GenerateProtocolHolderCategory(void) {
1644   // Collect information about instance methods
1645   llvm::SmallVector<Selector, 1> MethodSels;
1646   llvm::SmallVector<llvm::Constant*, 1> MethodTypes;
1647
1648   std::vector<llvm::Constant*> Elements;
1649   const std::string ClassName = "__ObjC_Protocol_Holder_Ugly_Hack";
1650   const std::string CategoryName = "AnotherHack";
1651   Elements.push_back(MakeConstantString(CategoryName));
1652   Elements.push_back(MakeConstantString(ClassName));
1653   // Instance method list
1654   Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1655           ClassName, CategoryName, MethodSels, MethodTypes, false), PtrTy));
1656   // Class method list
1657   Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1658           ClassName, CategoryName, MethodSels, MethodTypes, true), PtrTy));
1659   // Protocol list
1660   llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrTy,
1661       ExistingProtocols.size());
1662   llvm::StructType *ProtocolListTy = llvm::StructType::get(
1663       PtrTy, //Should be a recurisve pointer, but it's always NULL here.
1664       SizeTy,
1665       ProtocolArrayTy,
1666       NULL);
1667   std::vector<llvm::Constant*> ProtocolElements;
1668   for (llvm::StringMapIterator<llvm::Constant*> iter =
1669        ExistingProtocols.begin(), endIter = ExistingProtocols.end();
1670        iter != endIter ; iter++) {
1671     llvm::Constant *Ptr = llvm::ConstantExpr::getBitCast(iter->getValue(),
1672             PtrTy);
1673     ProtocolElements.push_back(Ptr);
1674   }
1675   llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
1676       ProtocolElements);
1677   ProtocolElements.clear();
1678   ProtocolElements.push_back(NULLPtr);
1679   ProtocolElements.push_back(llvm::ConstantInt::get(LongTy,
1680               ExistingProtocols.size()));
1681   ProtocolElements.push_back(ProtocolArray);
1682   Elements.push_back(llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolListTy,
1683                   ProtocolElements, ".objc_protocol_list"), PtrTy));
1684   Categories.push_back(llvm::ConstantExpr::getBitCast(
1685         MakeGlobal(llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty,
1686             PtrTy, PtrTy, PtrTy, NULL), Elements), PtrTy));
1687 }
1688
1689 void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
1690   std::string ClassName = OCD->getClassInterface()->getNameAsString();
1691   std::string CategoryName = OCD->getNameAsString();
1692   // Collect information about instance methods
1693   llvm::SmallVector<Selector, 16> InstanceMethodSels;
1694   llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
1695   for (ObjCCategoryImplDecl::instmeth_iterator
1696          iter = OCD->instmeth_begin(), endIter = OCD->instmeth_end();
1697        iter != endIter ; iter++) {
1698     InstanceMethodSels.push_back((*iter)->getSelector());
1699     std::string TypeStr;
1700     CGM.getContext().getObjCEncodingForMethodDecl(*iter,TypeStr);
1701     InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1702   }
1703
1704   // Collect information about class methods
1705   llvm::SmallVector<Selector, 16> ClassMethodSels;
1706   llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
1707   for (ObjCCategoryImplDecl::classmeth_iterator
1708          iter = OCD->classmeth_begin(), endIter = OCD->classmeth_end();
1709        iter != endIter ; iter++) {
1710     ClassMethodSels.push_back((*iter)->getSelector());
1711     std::string TypeStr;
1712     CGM.getContext().getObjCEncodingForMethodDecl(*iter,TypeStr);
1713     ClassMethodTypes.push_back(MakeConstantString(TypeStr));
1714   }
1715
1716   // Collect the names of referenced protocols
1717   llvm::SmallVector<std::string, 16> Protocols;
1718   const ObjCCategoryDecl *CatDecl = OCD->getCategoryDecl();
1719   const ObjCList<ObjCProtocolDecl> &Protos = CatDecl->getReferencedProtocols();
1720   for (ObjCList<ObjCProtocolDecl>::iterator I = Protos.begin(),
1721        E = Protos.end(); I != E; ++I)
1722     Protocols.push_back((*I)->getNameAsString());
1723
1724   std::vector<llvm::Constant*> Elements;
1725   Elements.push_back(MakeConstantString(CategoryName));
1726   Elements.push_back(MakeConstantString(ClassName));
1727   // Instance method list
1728   Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1729           ClassName, CategoryName, InstanceMethodSels, InstanceMethodTypes,
1730           false), PtrTy));
1731   // Class method list
1732   Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
1733           ClassName, CategoryName, ClassMethodSels, ClassMethodTypes, true),
1734         PtrTy));
1735   // Protocol list
1736   Elements.push_back(llvm::ConstantExpr::getBitCast(
1737         GenerateProtocolList(Protocols), PtrTy));
1738   Categories.push_back(llvm::ConstantExpr::getBitCast(
1739         MakeGlobal(llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty,
1740             PtrTy, PtrTy, PtrTy, NULL), Elements), PtrTy));
1741 }
1742
1743 llvm::Constant *CGObjCGNU::GeneratePropertyList(const ObjCImplementationDecl *OID,
1744         llvm::SmallVectorImpl<Selector> &InstanceMethodSels,
1745         llvm::SmallVectorImpl<llvm::Constant*> &InstanceMethodTypes) {
1746   ASTContext &Context = CGM.getContext();
1747   //
1748   // Property metadata: name, attributes, isSynthesized, setter name, setter
1749   // types, getter name, getter types.
1750   llvm::StructType *PropertyMetadataTy = llvm::StructType::get(
1751           PtrToInt8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty,
1752           PtrToInt8Ty, NULL);
1753   std::vector<llvm::Constant*> Properties;
1754
1755
1756   // Add all of the property methods need adding to the method list and to the
1757   // property metadata list.
1758   for (ObjCImplDecl::propimpl_iterator
1759          iter = OID->propimpl_begin(), endIter = OID->propimpl_end();
1760        iter != endIter ; iter++) {
1761     std::vector<llvm::Constant*> Fields;
1762     ObjCPropertyDecl *property = (*iter)->getPropertyDecl();
1763     ObjCPropertyImplDecl *propertyImpl = *iter;
1764     bool isSynthesized = (propertyImpl->getPropertyImplementation() ==
1765         ObjCPropertyImplDecl::Synthesize);
1766
1767     Fields.push_back(MakeConstantString(property->getNameAsString()));
1768     Fields.push_back(llvm::ConstantInt::get(Int8Ty,
1769                 property->getPropertyAttributes()));
1770     Fields.push_back(llvm::ConstantInt::get(Int8Ty, isSynthesized));
1771     if (ObjCMethodDecl *getter = property->getGetterMethodDecl()) {
1772       std::string TypeStr;
1773       Context.getObjCEncodingForMethodDecl(getter,TypeStr);
1774       llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1775       if (isSynthesized) {
1776         InstanceMethodTypes.push_back(TypeEncoding);
1777         InstanceMethodSels.push_back(getter->getSelector());
1778       }
1779       Fields.push_back(MakeConstantString(getter->getSelector().getAsString()));
1780       Fields.push_back(TypeEncoding);
1781     } else {
1782       Fields.push_back(NULLPtr);
1783       Fields.push_back(NULLPtr);
1784     }
1785     if (ObjCMethodDecl *setter = property->getSetterMethodDecl()) {
1786       std::string TypeStr;
1787       Context.getObjCEncodingForMethodDecl(setter,TypeStr);
1788       llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
1789       if (isSynthesized) {
1790         InstanceMethodTypes.push_back(TypeEncoding);
1791         InstanceMethodSels.push_back(setter->getSelector());
1792       }
1793       Fields.push_back(MakeConstantString(setter->getSelector().getAsString()));
1794       Fields.push_back(TypeEncoding);
1795     } else {
1796       Fields.push_back(NULLPtr);
1797       Fields.push_back(NULLPtr);
1798     }
1799     Properties.push_back(llvm::ConstantStruct::get(PropertyMetadataTy, Fields));
1800   }
1801   llvm::ArrayType *PropertyArrayTy =
1802       llvm::ArrayType::get(PropertyMetadataTy, Properties.size());
1803   llvm::Constant *PropertyArray = llvm::ConstantArray::get(PropertyArrayTy,
1804           Properties);
1805   llvm::Constant* PropertyListInitFields[] =
1806     {llvm::ConstantInt::get(IntTy, Properties.size()), NULLPtr, PropertyArray};
1807
1808   llvm::Constant *PropertyListInit =
1809       llvm::ConstantStruct::getAnon(PropertyListInitFields);
1810   return new llvm::GlobalVariable(TheModule, PropertyListInit->getType(), false,
1811           llvm::GlobalValue::InternalLinkage, PropertyListInit,
1812           ".objc_property_list");
1813 }
1814
1815 void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) {
1816   ASTContext &Context = CGM.getContext();
1817
1818   // Get the superclass name.
1819   const ObjCInterfaceDecl * SuperClassDecl =
1820     OID->getClassInterface()->getSuperClass();
1821   std::string SuperClassName;
1822   if (SuperClassDecl) {
1823     SuperClassName = SuperClassDecl->getNameAsString();
1824     EmitClassRef(SuperClassName);
1825   }
1826
1827   // Get the class name
1828   ObjCInterfaceDecl *ClassDecl =
1829     const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
1830   std::string ClassName = ClassDecl->getNameAsString();
1831   // Emit the symbol that is used to generate linker errors if this class is
1832   // referenced in other modules but not declared.
1833   std::string classSymbolName = "__objc_class_name_" + ClassName;
1834   if (llvm::GlobalVariable *symbol =
1835       TheModule.getGlobalVariable(classSymbolName)) {
1836     symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0));
1837   } else {
1838     new llvm::GlobalVariable(TheModule, LongTy, false,
1839     llvm::GlobalValue::ExternalLinkage, llvm::ConstantInt::get(LongTy, 0),
1840     classSymbolName);
1841   }
1842
1843   // Get the size of instances.
1844   int instanceSize =
1845     Context.getASTObjCImplementationLayout(OID).getSize().getQuantity();
1846
1847   // Collect information about instance variables.
1848   llvm::SmallVector<llvm::Constant*, 16> IvarNames;
1849   llvm::SmallVector<llvm::Constant*, 16> IvarTypes;
1850   llvm::SmallVector<llvm::Constant*, 16> IvarOffsets;
1851
1852   std::vector<llvm::Constant*> IvarOffsetValues;
1853
1854   int superInstanceSize = !SuperClassDecl ? 0 :
1855     Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
1856   // For non-fragile ivars, set the instance size to 0 - {the size of just this
1857   // class}.  The runtime will then set this to the correct value on load.
1858   if (CGM.getContext().getLangOptions().ObjCNonFragileABI) {
1859     instanceSize = 0 - (instanceSize - superInstanceSize);
1860   }
1861
1862   // Collect declared and synthesized ivars.
1863   llvm::SmallVector<ObjCIvarDecl*, 16> OIvars;
1864   CGM.getContext().ShallowCollectObjCIvars(ClassDecl, OIvars);
1865
1866   for (unsigned i = 0, e = OIvars.size(); i != e; ++i) {
1867       ObjCIvarDecl *IVD = OIvars[i];
1868       // Store the name
1869       IvarNames.push_back(MakeConstantString(IVD->getNameAsString()));
1870       // Get the type encoding for this ivar
1871       std::string TypeStr;
1872       Context.getObjCEncodingForType(IVD->getType(), TypeStr);
1873       IvarTypes.push_back(MakeConstantString(TypeStr));
1874       // Get the offset
1875       uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
1876       uint64_t Offset = BaseOffset;
1877       if (CGM.getContext().getLangOptions().ObjCNonFragileABI) {
1878         Offset = BaseOffset - superInstanceSize;
1879       }
1880       llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
1881       // Create the direct offset value
1882       std::string OffsetName = "__objc_ivar_offset_value_" + ClassName +"." +
1883           IVD->getNameAsString();
1884       llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);
1885       if (OffsetVar) {
1886         OffsetVar->setInitializer(OffsetValue);
1887         // If this is the real definition, change its linkage type so that
1888         // different modules will use this one, rather than their private
1889         // copy.
1890         OffsetVar->setLinkage(llvm::GlobalValue::ExternalLinkage);
1891       } else
1892         OffsetVar = new llvm::GlobalVariable(TheModule, IntTy,
1893           false, llvm::GlobalValue::ExternalLinkage,
1894           OffsetValue,
1895           "__objc_ivar_offset_value_" + ClassName +"." +
1896           IVD->getNameAsString());
1897       IvarOffsets.push_back(OffsetValue);
1898       IvarOffsetValues.push_back(OffsetVar);
1899   }
1900   llvm::GlobalVariable *IvarOffsetArray =
1901     MakeGlobalArray(PtrToIntTy, IvarOffsetValues, ".ivar.offsets");
1902
1903
1904   // Collect information about instance methods
1905   llvm::SmallVector<Selector, 16> InstanceMethodSels;
1906   llvm::SmallVector<llvm::Constant*, 16> InstanceMethodTypes;
1907   for (ObjCImplementationDecl::instmeth_iterator
1908          iter = OID->instmeth_begin(), endIter = OID->instmeth_end();
1909        iter != endIter ; iter++) {
1910     InstanceMethodSels.push_back((*iter)->getSelector());
1911     std::string TypeStr;
1912     Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
1913     InstanceMethodTypes.push_back(MakeConstantString(TypeStr));
1914   }
1915
1916   llvm::Constant *Properties = GeneratePropertyList(OID, InstanceMethodSels,
1917           InstanceMethodTypes);
1918
1919
1920   // Collect information about class methods
1921   llvm::SmallVector<Selector, 16> ClassMethodSels;
1922   llvm::SmallVector<llvm::Constant*, 16> ClassMethodTypes;
1923   for (ObjCImplementationDecl::classmeth_iterator
1924          iter = OID->classmeth_begin(), endIter = OID->classmeth_end();
1925        iter != endIter ; iter++) {
1926     ClassMethodSels.push_back((*iter)->getSelector());
1927     std::string TypeStr;
1928     Context.getObjCEncodingForMethodDecl((*iter),TypeStr);
1929     ClassMethodTypes.push_back(MakeConstantString(TypeStr));
1930   }
1931   // Collect the names of referenced protocols
1932   llvm::SmallVector<std::string, 16> Protocols;
1933   const ObjCList<ObjCProtocolDecl> &Protos =ClassDecl->getReferencedProtocols();
1934   for (ObjCList<ObjCProtocolDecl>::iterator I = Protos.begin(),
1935        E = Protos.end(); I != E; ++I)
1936     Protocols.push_back((*I)->getNameAsString());
1937
1938
1939
1940   // Get the superclass pointer.
1941   llvm::Constant *SuperClass;
1942   if (!SuperClassName.empty()) {
1943     SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
1944   } else {
1945     SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty);
1946   }
1947   // Empty vector used to construct empty method lists
1948   llvm::SmallVector<llvm::Constant*, 1>  empty;
1949   // Generate the method and instance variable lists
1950   llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
1951       InstanceMethodSels, InstanceMethodTypes, false);
1952   llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
1953       ClassMethodSels, ClassMethodTypes, true);
1954   llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
1955       IvarOffsets);
1956   // Irrespective of whether we are compiling for a fragile or non-fragile ABI,
1957   // we emit a symbol containing the offset for each ivar in the class.  This
1958   // allows code compiled for the non-Fragile ABI to inherit from code compiled
1959   // for the legacy ABI, without causing problems.  The converse is also
1960   // possible, but causes all ivar accesses to be fragile.
1961
1962   // Offset pointer for getting at the correct field in the ivar list when
1963   // setting up the alias.  These are: The base address for the global, the
1964   // ivar array (second field), the ivar in this list (set for each ivar), and
1965   // the offset (third field in ivar structure)
1966   const llvm::Type *IndexTy = llvm::Type::getInt32Ty(VMContext);
1967   llvm::Constant *offsetPointerIndexes[] = {Zeros[0],
1968       llvm::ConstantInt::get(IndexTy, 1), 0,
1969       llvm::ConstantInt::get(IndexTy, 2) };
1970
1971
1972   for (unsigned i = 0, e = OIvars.size(); i != e; ++i) {
1973       ObjCIvarDecl *IVD = OIvars[i];
1974       const std::string Name = "__objc_ivar_offset_" + ClassName + '.'
1975           + IVD->getNameAsString();
1976       offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, i);
1977       // Get the correct ivar field
1978       llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr(
1979               IvarList, offsetPointerIndexes, 4);
1980       // Get the existing variable, if one exists.
1981       llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name);
1982       if (offset) {
1983           offset->setInitializer(offsetValue);
1984           // If this is the real definition, change its linkage type so that
1985           // different modules will use this one, rather than their private
1986           // copy.
1987           offset->setLinkage(llvm::GlobalValue::ExternalLinkage);
1988       } else {
1989           // Add a new alias if there isn't one already.
1990           offset = new llvm::GlobalVariable(TheModule, offsetValue->getType(),
1991                   false, llvm::GlobalValue::ExternalLinkage, offsetValue, Name);
1992       }
1993   }
1994   //Generate metaclass for class methods
1995   llvm::Constant *MetaClassStruct = GenerateClassStructure(NULLPtr,
1996       NULLPtr, 0x12L, ClassName.c_str(), 0, Zeros[0], GenerateIvarList(
1997         empty, empty, empty), ClassMethodList, NULLPtr, NULLPtr, NULLPtr, true);
1998
1999   // Generate the class structure
2000   llvm::Constant *ClassStruct =
2001     GenerateClassStructure(MetaClassStruct, SuperClass, 0x11L,
2002                            ClassName.c_str(), 0,
2003       llvm::ConstantInt::get(LongTy, instanceSize), IvarList,
2004       MethodList, GenerateProtocolList(Protocols), IvarOffsetArray,
2005       Properties);
2006
2007   // Resolve the class aliases, if they exist.
2008   if (ClassPtrAlias) {
2009     ClassPtrAlias->replaceAllUsesWith(
2010         llvm::ConstantExpr::getBitCast(ClassStruct, IdTy));
2011     ClassPtrAlias->eraseFromParent();
2012     ClassPtrAlias = 0;
2013   }
2014   if (MetaClassPtrAlias) {
2015     MetaClassPtrAlias->replaceAllUsesWith(
2016         llvm::ConstantExpr::getBitCast(MetaClassStruct, IdTy));
2017     MetaClassPtrAlias->eraseFromParent();
2018     MetaClassPtrAlias = 0;
2019   }
2020
2021   // Add class structure to list to be added to the symtab later
2022   ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty);
2023   Classes.push_back(ClassStruct);
2024 }
2025
2026
2027 llvm::Function *CGObjCGNU::ModuleInitFunction() {
2028   // Only emit an ObjC load function if no Objective-C stuff has been called
2029   if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
2030       ExistingProtocols.empty() && SelectorTable.empty())
2031     return NULL;
2032
2033   // Add all referenced protocols to a category.
2034   GenerateProtocolHolderCategory();
2035
2036   const llvm::StructType *SelStructTy = dyn_cast<llvm::StructType>(
2037           SelectorTy->getElementType());
2038   llvm::Type *SelStructPtrTy = SelectorTy;
2039   if (SelStructTy == 0) {
2040     SelStructTy = llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, NULL);
2041     SelStructPtrTy = llvm::PointerType::getUnqual(SelStructTy);
2042   }
2043
2044   std::vector<llvm::Constant*> Elements;
2045   llvm::Constant *Statics = NULLPtr;
2046   // Generate statics list:
2047   if (ConstantStrings.size()) {
2048     llvm::ArrayType *StaticsArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
2049         ConstantStrings.size() + 1);
2050     ConstantStrings.push_back(NULLPtr);
2051
2052     llvm::StringRef StringClass = CGM.getLangOptions().ObjCConstantStringClass;
2053
2054     if (StringClass.empty()) StringClass = "NXConstantString";
2055
2056     Elements.push_back(MakeConstantString(StringClass,
2057                 ".objc_static_class_name"));
2058     Elements.push_back(llvm::ConstantArray::get(StaticsArrayTy,
2059        ConstantStrings));
2060     llvm::StructType *StaticsListTy =
2061       llvm::StructType::get(PtrToInt8Ty, StaticsArrayTy, NULL);
2062     llvm::Type *StaticsListPtrTy =
2063       llvm::PointerType::getUnqual(StaticsListTy);
2064     Statics = MakeGlobal(StaticsListTy, Elements, ".objc_statics");
2065     llvm::ArrayType *StaticsListArrayTy =
2066       llvm::ArrayType::get(StaticsListPtrTy, 2);
2067     Elements.clear();
2068     Elements.push_back(Statics);
2069     Elements.push_back(llvm::Constant::getNullValue(StaticsListPtrTy));
2070     Statics = MakeGlobal(StaticsListArrayTy, Elements, ".objc_statics_ptr");
2071     Statics = llvm::ConstantExpr::getBitCast(Statics, PtrTy);
2072   }
2073   // Array of classes, categories, and constant objects
2074   llvm::ArrayType *ClassListTy = llvm::ArrayType::get(PtrToInt8Ty,
2075       Classes.size() + Categories.size()  + 2);
2076   llvm::StructType *SymTabTy = llvm::StructType::get(LongTy, SelStructPtrTy,
2077                                                      llvm::Type::getInt16Ty(VMContext),
2078                                                      llvm::Type::getInt16Ty(VMContext),
2079                                                      ClassListTy, NULL);
2080
2081   Elements.clear();
2082   // Pointer to an array of selectors used in this module.
2083   std::vector<llvm::Constant*> Selectors;
2084   std::vector<llvm::GlobalAlias*> SelectorAliases;
2085   for (SelectorMap::iterator iter = SelectorTable.begin(),
2086       iterEnd = SelectorTable.end(); iter != iterEnd ; ++iter) {
2087
2088     std::string SelNameStr = iter->first.getAsString();
2089     llvm::Constant *SelName = ExportUniqueString(SelNameStr, ".objc_sel_name");
2090
2091     llvm::SmallVectorImpl<TypedSelector> &Types = iter->second;
2092     for (llvm::SmallVectorImpl<TypedSelector>::iterator i = Types.begin(),
2093         e = Types.end() ; i!=e ; i++) {
2094
2095       llvm::Constant *SelectorTypeEncoding = NULLPtr;
2096       if (!i->first.empty())
2097         SelectorTypeEncoding = MakeConstantString(i->first, ".objc_sel_types");
2098
2099       Elements.push_back(SelName);
2100       Elements.push_back(SelectorTypeEncoding);
2101       Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
2102       Elements.clear();
2103
2104       // Store the selector alias for later replacement
2105       SelectorAliases.push_back(i->second);
2106     }
2107   }
2108   unsigned SelectorCount = Selectors.size();
2109   // NULL-terminate the selector list.  This should not actually be required,
2110   // because the selector list has a length field.  Unfortunately, the GCC
2111   // runtime decides to ignore the length field and expects a NULL terminator,
2112   // and GCC cooperates with this by always setting the length to 0.
2113   Elements.push_back(NULLPtr);
2114   Elements.push_back(NULLPtr);
2115   Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
2116   Elements.clear();
2117
2118   // Number of static selectors
2119   Elements.push_back(llvm::ConstantInt::get(LongTy, SelectorCount));
2120   llvm::Constant *SelectorList = MakeGlobalArray(SelStructTy, Selectors,
2121           ".objc_selector_list");
2122   Elements.push_back(llvm::ConstantExpr::getBitCast(SelectorList,
2123     SelStructPtrTy));
2124
2125   // Now that all of the static selectors exist, create pointers to them.
2126   for (unsigned int i=0 ; i<SelectorCount ; i++) {
2127
2128     llvm::Constant *Idxs[] = {Zeros[0],
2129       llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), i), Zeros[0]};
2130     // FIXME: We're generating redundant loads and stores here!
2131     llvm::Constant *SelPtr = llvm::ConstantExpr::getGetElementPtr(SelectorList,
2132         Idxs, 2);
2133     // If selectors are defined as an opaque type, cast the pointer to this
2134     // type.
2135     SelPtr = llvm::ConstantExpr::getBitCast(SelPtr, SelectorTy);
2136     SelectorAliases[i]->replaceAllUsesWith(SelPtr);
2137     SelectorAliases[i]->eraseFromParent();
2138   }
2139
2140   // Number of classes defined.
2141   Elements.push_back(llvm::ConstantInt::get(llvm::Type::getInt16Ty(VMContext),
2142         Classes.size()));
2143   // Number of categories defined
2144   Elements.push_back(llvm::ConstantInt::get(llvm::Type::getInt16Ty(VMContext),
2145         Categories.size()));
2146   // Create an array of classes, then categories, then static object instances
2147   Classes.insert(Classes.end(), Categories.begin(), Categories.end());
2148   //  NULL-terminated list of static object instances (mainly constant strings)
2149   Classes.push_back(Statics);
2150   Classes.push_back(NULLPtr);
2151   llvm::Constant *ClassList = llvm::ConstantArray::get(ClassListTy, Classes);
2152   Elements.push_back(ClassList);
2153   // Construct the symbol table
2154   llvm::Constant *SymTab= MakeGlobal(SymTabTy, Elements);
2155
2156   // The symbol table is contained in a module which has some version-checking
2157   // constants
2158   llvm::StructType * ModuleTy = llvm::StructType::get(LongTy, LongTy,
2159       PtrToInt8Ty, llvm::PointerType::getUnqual(SymTabTy),
2160       (RuntimeVersion >= 10) ? IntTy : NULL, NULL);
2161   Elements.clear();
2162   // Runtime version, used for ABI compatibility checking.
2163   Elements.push_back(llvm::ConstantInt::get(LongTy, RuntimeVersion));
2164   // sizeof(ModuleTy)
2165   llvm::TargetData td(&TheModule);
2166   Elements.push_back(
2167     llvm::ConstantInt::get(LongTy,
2168                            td.getTypeSizeInBits(ModuleTy) /
2169                              CGM.getContext().getCharWidth()));
2170
2171   // The path to the source file where this module was declared
2172   SourceManager &SM = CGM.getContext().getSourceManager();
2173   const FileEntry *mainFile = SM.getFileEntryForID(SM.getMainFileID());
2174   std::string path =
2175     std::string(mainFile->getDir()->getName()) + '/' + mainFile->getName();
2176   Elements.push_back(MakeConstantString(path, ".objc_source_file_name"));
2177   Elements.push_back(SymTab);
2178
2179   if (RuntimeVersion >= 10)
2180     switch (CGM.getLangOptions().getGCMode()) {
2181       case LangOptions::GCOnly:
2182         Elements.push_back(llvm::ConstantInt::get(IntTy, 2));
2183         break;
2184       case LangOptions::NonGC:
2185         if (CGM.getLangOptions().ObjCAutoRefCount)
2186           Elements.push_back(llvm::ConstantInt::get(IntTy, 1));
2187         else
2188           Elements.push_back(llvm::ConstantInt::get(IntTy, 0));
2189         break;
2190       case LangOptions::HybridGC:
2191           Elements.push_back(llvm::ConstantInt::get(IntTy, 1));
2192         break;
2193     }
2194
2195   llvm::Value *Module = MakeGlobal(ModuleTy, Elements);
2196
2197   // Create the load function calling the runtime entry point with the module
2198   // structure
2199   llvm::Function * LoadFunction = llvm::Function::Create(
2200       llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
2201       llvm::GlobalValue::InternalLinkage, ".objc_load_function",
2202       &TheModule);
2203   llvm::BasicBlock *EntryBB =
2204       llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
2205   CGBuilderTy Builder(VMContext);
2206   Builder.SetInsertPoint(EntryBB);
2207
2208   llvm::Type *ArgTys[] = { llvm::PointerType::getUnqual(ModuleTy) };
2209   llvm::FunctionType *FT =
2210     llvm::FunctionType::get(Builder.getVoidTy(), ArgTys, true);
2211   llvm::Value *Register = CGM.CreateRuntimeFunction(FT, "__objc_exec_class");
2212   Builder.CreateCall(Register, Module);
2213   Builder.CreateRetVoid();
2214
2215   return LoadFunction;
2216 }
2217
2218 llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD,
2219                                           const ObjCContainerDecl *CD) {
2220   const ObjCCategoryImplDecl *OCD =
2221     dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext());
2222   llvm::StringRef CategoryName = OCD ? OCD->getName() : "";
2223   llvm::StringRef ClassName = CD->getName();
2224   Selector MethodName = OMD->getSelector();
2225   bool isClassMethod = !OMD->isInstanceMethod();
2226
2227   CodeGenTypes &Types = CGM.getTypes();
2228   const llvm::FunctionType *MethodTy =
2229     Types.GetFunctionType(Types.getFunctionInfo(OMD), OMD->isVariadic());
2230   std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName,
2231       MethodName, isClassMethod);
2232
2233   llvm::Function *Method
2234     = llvm::Function::Create(MethodTy,
2235                              llvm::GlobalValue::InternalLinkage,
2236                              FunctionName,
2237                              &TheModule);
2238   return Method;
2239 }
2240
2241 llvm::Constant *CGObjCGNU::GetPropertyGetFunction() {
2242   return GetPropertyFn;
2243 }
2244
2245 llvm::Constant *CGObjCGNU::GetPropertySetFunction() {
2246   return SetPropertyFn;
2247 }
2248
2249 llvm::Constant *CGObjCGNU::GetGetStructFunction() {
2250   return GetStructPropertyFn;
2251 }
2252 llvm::Constant *CGObjCGNU::GetSetStructFunction() {
2253   return SetStructPropertyFn;
2254 }
2255
2256 llvm::Constant *CGObjCGNU::EnumerationMutationFunction() {
2257   return EnumerationMutationFn;
2258 }
2259
2260 void CGObjCGNU::EmitSynchronizedStmt(CodeGenFunction &CGF,
2261                                      const ObjCAtSynchronizedStmt &S) {
2262   EmitAtSynchronizedStmt(CGF, S, SyncEnterFn, SyncExitFn);
2263 }
2264
2265
2266 void CGObjCGNU::EmitTryStmt(CodeGenFunction &CGF,
2267                             const ObjCAtTryStmt &S) {
2268   // Unlike the Apple non-fragile runtimes, which also uses
2269   // unwind-based zero cost exceptions, the GNU Objective C runtime's
2270   // EH support isn't a veneer over C++ EH.  Instead, exception
2271   // objects are created by __objc_exception_throw and destroyed by
2272   // the personality function; this avoids the need for bracketing
2273   // catch handlers with calls to __blah_begin_catch/__blah_end_catch
2274   // (or even _Unwind_DeleteException), but probably doesn't
2275   // interoperate very well with foreign exceptions.
2276   //
2277   // In Objective-C++ mode, we actually emit something equivalent to the C++
2278   // exception handler.
2279   EmitTryCatchStmt(CGF, S, EnterCatchFn, ExitCatchFn, ExceptionReThrowFn);
2280   return ;
2281 }
2282
2283 void CGObjCGNU::EmitThrowStmt(CodeGenFunction &CGF,
2284                               const ObjCAtThrowStmt &S) {
2285   llvm::Value *ExceptionAsObject;
2286
2287   if (const Expr *ThrowExpr = S.getThrowExpr()) {
2288     llvm::Value *Exception = CGF.EmitScalarExpr(ThrowExpr);
2289     ExceptionAsObject = Exception;
2290   } else {
2291     assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
2292            "Unexpected rethrow outside @catch block.");
2293     ExceptionAsObject = CGF.ObjCEHValueStack.back();
2294   }
2295   ExceptionAsObject =
2296       CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy, "tmp");
2297
2298   // Note: This may have to be an invoke, if we want to support constructs like:
2299   // @try {
2300   //  @throw(obj);
2301   // }
2302   // @catch(id) ...
2303   //
2304   // This is effectively turning @throw into an incredibly-expensive goto, but
2305   // it may happen as a result of inlining followed by missed optimizations, or
2306   // as a result of stupidity.
2307   llvm::BasicBlock *UnwindBB = CGF.getInvokeDest();
2308   if (!UnwindBB) {
2309     CGF.Builder.CreateCall(ExceptionThrowFn, ExceptionAsObject);
2310     CGF.Builder.CreateUnreachable();
2311   } else {
2312     CGF.Builder.CreateInvoke(ExceptionThrowFn, UnwindBB, UnwindBB,
2313                              ExceptionAsObject);
2314   }
2315   // Clear the insertion point to indicate we are in unreachable code.
2316   CGF.Builder.ClearInsertionPoint();
2317 }
2318
2319 llvm::Value * CGObjCGNU::EmitObjCWeakRead(CodeGenFunction &CGF,
2320                                           llvm::Value *AddrWeakObj) {
2321   CGBuilderTy B = CGF.Builder;
2322   AddrWeakObj = EnforceType(B, AddrWeakObj, PtrToIdTy);
2323   return B.CreateCall(WeakReadFn, AddrWeakObj);
2324 }
2325
2326 void CGObjCGNU::EmitObjCWeakAssign(CodeGenFunction &CGF,
2327                                    llvm::Value *src, llvm::Value *dst) {
2328   CGBuilderTy B = CGF.Builder;
2329   src = EnforceType(B, src, IdTy);
2330   dst = EnforceType(B, dst, PtrToIdTy);
2331   B.CreateCall2(WeakAssignFn, src, dst);
2332 }
2333
2334 void CGObjCGNU::EmitObjCGlobalAssign(CodeGenFunction &CGF,
2335                                      llvm::Value *src, llvm::Value *dst,
2336                                      bool threadlocal) {
2337   CGBuilderTy B = CGF.Builder;
2338   src = EnforceType(B, src, IdTy);
2339   dst = EnforceType(B, dst, PtrToIdTy);
2340   if (!threadlocal)
2341     B.CreateCall2(GlobalAssignFn, src, dst);
2342   else
2343     // FIXME. Add threadloca assign API
2344     assert(false && "EmitObjCGlobalAssign - Threal Local API NYI");
2345 }
2346
2347 void CGObjCGNU::EmitObjCIvarAssign(CodeGenFunction &CGF,
2348                                    llvm::Value *src, llvm::Value *dst,
2349                                    llvm::Value *ivarOffset) {
2350   CGBuilderTy B = CGF.Builder;
2351   src = EnforceType(B, src, IdTy);
2352   dst = EnforceType(B, dst, IdTy);
2353   B.CreateCall3(IvarAssignFn, src, dst, ivarOffset);
2354 }
2355
2356 void CGObjCGNU::EmitObjCStrongCastAssign(CodeGenFunction &CGF,
2357                                          llvm::Value *src, llvm::Value *dst) {
2358   CGBuilderTy B = CGF.Builder;
2359   src = EnforceType(B, src, IdTy);
2360   dst = EnforceType(B, dst, PtrToIdTy);
2361   B.CreateCall2(StrongCastAssignFn, src, dst);
2362 }
2363
2364 void CGObjCGNU::EmitGCMemmoveCollectable(CodeGenFunction &CGF,
2365                                          llvm::Value *DestPtr,
2366                                          llvm::Value *SrcPtr,
2367                                          llvm::Value *Size) {
2368   CGBuilderTy B = CGF.Builder;
2369   DestPtr = EnforceType(B, DestPtr, PtrTy);
2370   SrcPtr = EnforceType(B, SrcPtr, PtrTy);
2371
2372   B.CreateCall3(MemMoveFn, DestPtr, SrcPtr, Size);
2373 }
2374
2375 llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable(
2376                               const ObjCInterfaceDecl *ID,
2377                               const ObjCIvarDecl *Ivar) {
2378   const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
2379     + '.' + Ivar->getNameAsString();
2380   // Emit the variable and initialize it with what we think the correct value
2381   // is.  This allows code compiled with non-fragile ivars to work correctly
2382   // when linked against code which isn't (most of the time).
2383   llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
2384   if (!IvarOffsetPointer) {
2385     // This will cause a run-time crash if we accidentally use it.  A value of
2386     // 0 would seem more sensible, but will silently overwrite the isa pointer
2387     // causing a great deal of confusion.
2388     uint64_t Offset = -1;
2389     // We can't call ComputeIvarBaseOffset() here if we have the
2390     // implementation, because it will create an invalid ASTRecordLayout object
2391     // that we are then stuck with forever, so we only initialize the ivar
2392     // offset variable with a guess if we only have the interface.  The
2393     // initializer will be reset later anyway, when we are generating the class
2394     // description.
2395     if (!CGM.getContext().getObjCImplementation(
2396               const_cast<ObjCInterfaceDecl *>(ID)))
2397       Offset = ComputeIvarBaseOffset(CGM, ID, Ivar);
2398
2399     llvm::ConstantInt *OffsetGuess =
2400       llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Offset, "ivar");
2401     // Don't emit the guess in non-PIC code because the linker will not be able
2402     // to replace it with the real version for a library.  In non-PIC code you
2403     // must compile with the fragile ABI if you want to use ivars from a
2404     // GCC-compiled class.
2405     if (CGM.getLangOptions().PICLevel) {
2406       llvm::GlobalVariable *IvarOffsetGV = new llvm::GlobalVariable(TheModule,
2407             llvm::Type::getInt32Ty(VMContext), false,
2408             llvm::GlobalValue::PrivateLinkage, OffsetGuess, Name+".guess");
2409       IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
2410             IvarOffsetGV->getType(), false, llvm::GlobalValue::LinkOnceAnyLinkage,
2411             IvarOffsetGV, Name);
2412     } else {
2413       IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
2414               llvm::Type::getInt32PtrTy(VMContext), false,
2415               llvm::GlobalValue::ExternalLinkage, 0, Name);
2416     }
2417   }
2418   return IvarOffsetPointer;
2419 }
2420
2421 LValue CGObjCGNU::EmitObjCValueForIvar(CodeGenFunction &CGF,
2422                                        QualType ObjectTy,
2423                                        llvm::Value *BaseValue,
2424                                        const ObjCIvarDecl *Ivar,
2425                                        unsigned CVRQualifiers) {
2426   const ObjCInterfaceDecl *ID =
2427     ObjectTy->getAs<ObjCObjectType>()->getInterface();
2428   return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
2429                                   EmitIvarOffset(CGF, ID, Ivar));
2430 }
2431
2432 static const ObjCInterfaceDecl *FindIvarInterface(ASTContext &Context,
2433                                                   const ObjCInterfaceDecl *OID,
2434                                                   const ObjCIvarDecl *OIVD) {
2435   llvm::SmallVector<ObjCIvarDecl*, 16> Ivars;
2436   Context.ShallowCollectObjCIvars(OID, Ivars);
2437   for (unsigned k = 0, e = Ivars.size(); k != e; ++k) {
2438     if (OIVD == Ivars[k])
2439       return OID;
2440   }
2441
2442   // Otherwise check in the super class.
2443   if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
2444     return FindIvarInterface(Context, Super, OIVD);
2445
2446   return 0;
2447 }
2448
2449 llvm::Value *CGObjCGNU::EmitIvarOffset(CodeGenFunction &CGF,
2450                          const ObjCInterfaceDecl *Interface,
2451                          const ObjCIvarDecl *Ivar) {
2452   if (CGM.getLangOptions().ObjCNonFragileABI) {
2453     Interface = FindIvarInterface(CGM.getContext(), Interface, Ivar);
2454     if (RuntimeVersion < 10)
2455       return CGF.Builder.CreateZExtOrBitCast(
2456           CGF.Builder.CreateLoad(CGF.Builder.CreateLoad(
2457                   ObjCIvarOffsetVariable(Interface, Ivar), false, "ivar")),
2458           PtrDiffTy);
2459     std::string name = "__objc_ivar_offset_value_" +
2460       Interface->getNameAsString() +"." + Ivar->getNameAsString();
2461     llvm::Value *Offset = TheModule.getGlobalVariable(name);
2462     if (!Offset)
2463       Offset = new llvm::GlobalVariable(TheModule, IntTy,
2464           false, llvm::GlobalValue::CommonLinkage,
2465           0, name);
2466     return CGF.Builder.CreateLoad(Offset);
2467   }
2468   uint64_t Offset = ComputeIvarBaseOffset(CGF.CGM, Interface, Ivar);
2469   return llvm::ConstantInt::get(PtrDiffTy, Offset, "ivar");
2470 }
2471
2472 CGObjCRuntime *
2473 clang::CodeGen::CreateGNUObjCRuntime(CodeGenModule &CGM) {
2474   if (CGM.getLangOptions().ObjCNonFragileABI)
2475     return new CGObjCGNUstep(CGM);
2476   return new CGObjCGCC(CGM);
2477 }