Home | History | Annotate | Download | only in CodeGen
      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        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   llvm::StructType *ObjCSuperTy;
    115   /// struct objc_super*.  The type of the argument to the superclass message
    116   /// lookup functions.
    117   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   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   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   llvm::IntegerType *SizeTy;
    157   /// LLVM type for C ptrdiff_t.  Mainly used in property accessor functions.
    158   llvm::IntegerType *PtrDiffTy;
    159   /// LLVM type for C int*.  Used for GCC-ABI-compatible non-fragile instance
    160   /// variables.
    161   llvm::PointerType *PtrToIntTy;
    162   /// LLVM type for Objective-C BOOL type.
    163   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(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(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(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, 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   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   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       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   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   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   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   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 }
   2478