Revert "Add Clang support code."

This reverts commit 89032d4bebd561140118ded45d11f66e7bf2133f.

3 files changed, 0 insertions, 1188 deletions

diff --git a/Clang/CGObjC.cpp b/Clang/CGObjC.cpp
deleted file mode 100644
index 9bf53d9..0000000
--- a/Clang/CGObjC.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-//===---- CGBuiltin.cpp - Emit LLVM Code for builtins ---------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This contains code to emit Objective-C code as LLVM code.
-//
-//===----------------------------------------------------------------------===//
-
-#include "CGObjCRuntime.h"
-#include "CodeGenFunction.h"
-#include "CodeGenModule.h"
-#include "clang/AST/ExprObjC.h"
-#include "llvm/Constant.h"
-#include "llvm/Function.h"
-
-using namespace clang;
-using namespace CodeGen;
-
-/// Emits an instance of NSConstantString representing the object.
-llvm::Value *CodeGenFunction::EmitObjCStringLiteral(const ObjCStringLiteral *E){
-  return CGM.getObjCRuntime()->GenerateConstantString(
-      E->getString()->getStrData(), E->getString()->getByteLength());
-}
-
-/// Emit a selector.
-llvm::Value *CodeGenFunction::EmitObjCSelectorExpr(const ObjCSelectorExpr *E) {
-  // Untyped selector.
-  // Note that this implementation allows for non-constant strings to be passed
-  // as arguments to @selector().  Currently, the only thing preventing this
-  // behaviour is the type checking in the front end.
-  return CGM.getObjCRuntime()->GetSelector(Builder, E->getSelector());
-}
-
-
-
-llvm::Value *CodeGenFunction::EmitObjCMessageExpr(const ObjCMessageExpr *E) {
-  // Only the lookup mechanism and first two arguments of the method
-  // implementation vary between runtimes.  We can get the receiver and
-  // arguments in generic code.
-  
-  CGObjCRuntime *Runtime = CGM.getObjCRuntime();
-  const Expr *ReceiverExpr = E->getReceiver();
-  bool isSuperMessage = false;
-  // Find the receiver
-  llvm::Value *Receiver;
-  if (!ReceiverExpr) {
-    const char * classname = E->getClassName()->getName();
-    if (!strcmp(classname, "super")) {
-      classname = E->getMethodDecl()->getClassInterface()->getName();
-    }
-    llvm::Value *ClassName = CGM.GetAddrOfConstantString(classname);
-    ClassName = Builder.CreateStructGEP(ClassName, 0);
-    Receiver = Runtime->LookupClass(Builder, ClassName);
-  } else if (isa<PreDefinedExpr>(E->getReceiver())) {
-    assert(cast<PreDefinedExpr>(E->getReceiver())->getIdentType() == 
-           PreDefinedExpr::ObjCSuper);
-    isSuperMessage = true;
-    Receiver = LoadObjCSelf();
-  } else {
-   Receiver = EmitScalarExpr(E->getReceiver());
-  }
-
-  // Process the arguments
-  unsigned ArgC = E->getNumArgs();
-  llvm::SmallVector<llvm::Value*, 16> Args;
-  for (unsigned i = 0; i != ArgC; ++i) {
-    const Expr *ArgExpr = E->getArg(i);
-    QualType ArgTy = ArgExpr->getType();
-    if (!hasAggregateLLVMType(ArgTy)) {
-      // Scalar argument is passed by-value.
-      Args.push_back(EmitScalarExpr(ArgExpr));
-    } else if (ArgTy->isAnyComplexType()) {
-      // Make a temporary alloca to pass the argument.
-      llvm::Value *DestMem = CreateTempAlloca(ConvertType(ArgTy));
-      EmitComplexExprIntoAddr(ArgExpr, DestMem, false);
-      Args.push_back(DestMem);
-    } else {
-      llvm::Value *DestMem = CreateTempAlloca(ConvertType(ArgTy));
-      EmitAggExpr(ArgExpr, DestMem, false);
-      Args.push_back(DestMem);
-    }
-  }
-
-  if (isSuperMessage) {
-    // super is only valid in an Objective-C method
-    const ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(CurFuncDecl);
-    const char *SuperClass =
-      OMD->getClassInterface()->getSuperClass()->getName();
-    return Runtime->GenerateMessageSendSuper(Builder, ConvertType(E->getType()),
-                                             Receiver, SuperClass,
-                                             Receiver, E->getSelector(),
-                                             &Args[0], Args.size());
-  }
-  return Runtime->GenerateMessageSend(Builder, ConvertType(E->getType()),
-                                      LoadObjCSelf(),
-                                      Receiver, E->getSelector(),
-                                      &Args[0], Args.size());
-}
-
-/// Generate an Objective-C method.  An Objective-C method is a C function with
-/// its pointer, name, and types registered in the class struture.  
-void CodeGenFunction::GenerateObjCMethod(const ObjCMethodDecl *OMD) {
-
-  llvm::SmallVector<const llvm::Type *, 16> ParamTypes;
-  for (unsigned i=0 ; i<OMD->param_size() ; i++) {
-    const llvm::Type *Ty = ConvertType(OMD->getParamDecl(i)->getType());
-    if (Ty->isFirstClassType())
-      ParamTypes.push_back(Ty);
-    else
-      ParamTypes.push_back(llvm::PointerType::getUnqual(Ty));
-  }
-  std::string CategoryName = "";
-  if (ObjCCategoryImplDecl *OCD =
-      dyn_cast<ObjCCategoryImplDecl>(OMD->getMethodContext())) {
-    CategoryName = OCD->getName();
-  }
-  const llvm::Type *ReturnTy = 
-    CGM.getTypes().ConvertReturnType(OMD->getResultType());
-  CurFn = CGM.getObjCRuntime()->MethodPreamble(
-                                          OMD->getClassInterface()->getName(),
-                                              CategoryName,
-                                              OMD->getSelector().getName(),
-                                              ReturnTy,
-                                              llvm::PointerType::getUnqual(
-                                              llvm::Type::Int32Ty),
-                                              ParamTypes.begin(),
-                                              OMD->param_size(),
-                                              !OMD->isInstance(),
-                                              OMD->isVariadic());
-  llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", CurFn);
-  
-  // Create a marker to make it easy to insert allocas into the entryblock
-  // later.  Don't create this with the builder, because we don't want it
-  // folded.
-  llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty);
-  AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt",
-                                         EntryBB);
-
-  FnRetTy = OMD->getResultType();
-  CurFuncDecl = OMD;
-
-  Builder.SetInsertPoint(EntryBB);
-  
-  // Emit allocs for param decls.  Give the LLVM Argument nodes names.
-  llvm::Function::arg_iterator AI = CurFn->arg_begin();
-  
-  if (hasAggregateLLVMType(OMD->getResultType())) {
-    ++AI;
-  }
-  // Add implicit parameters to the decl map.
-  // TODO: Add something to AST to let the runtime specify the names and types
-  // of these.
-
-  llvm::Value *&SelfEntry = LocalDeclMap[OMD->getSelfDecl()];
-  const llvm::Type *IPTy = AI->getType();
-  llvm::Value *DeclPtr = new llvm::AllocaInst(IPTy, 0, AI->getName() +
-      ".addr", AllocaInsertPt);
-  // Store the initial value into the alloca.
-  Builder.CreateStore(AI, DeclPtr);
-  SelfEntry = DeclPtr;
-  ++AI;
-  llvm::Value *&CmdEntry = LocalDeclMap[OMD->getCmdDecl()];
-  IPTy = AI->getType();
-  DeclPtr = new llvm::AllocaInst(IPTy, 0, AI->getName() +
-      ".addr", AllocaInsertPt);
-  // Store the initial value into the alloca.
-  Builder.CreateStore(AI, DeclPtr);
-  CmdEntry = DeclPtr;
-
-  for (unsigned i = 0, e = OMD->getNumParams(); i != e; ++i, ++AI) {
-    assert(AI != CurFn->arg_end() && "Argument mismatch!");
-    EmitParmDecl(*OMD->getParamDecl(i), AI);
-  }
-  
-  GenerateFunction(OMD->getBody());
-}
-
-llvm::Value *CodeGenFunction::LoadObjCSelf(void)
-{
-  if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(CurFuncDecl)) {
-    ValueDecl *Decl = OMD->getSelfDecl();
-    llvm::Value *SelfPtr = LocalDeclMap[&(*(Decl))];
-    return Builder.CreateLoad(SelfPtr, "self");
-  }
-  return NULL;
-}
-
-CGObjCRuntime::~CGObjCRuntime() {}
diff --git a/Clang/CGObjCGNU.cpp b/Clang/CGObjCGNU.cpp
deleted file mode 100644
index 57c021f..0000000
--- a/Clang/CGObjCGNU.cpp
+++ /dev/null
@@ -1,869 +0,0 @@
-//===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This provides Objective-C code generation targetting the GNU runtime.  The
-// class in this file generates structures used by the GNU Objective-C runtime
-// library.  These structures are defined in objc/objc.h and objc/objc-api.h in
-// the GNU runtime distribution.
-//
-//===----------------------------------------------------------------------===//
-
-#include "CGObjCRuntime.h"
-#include "CodeGenModule.h"
-#include "clang/AST/ASTContext.h"
-#include "llvm/Module.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/IRBuilder.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringMap.h"
-#include <map>
-using namespace clang;
-using llvm::dyn_cast;
-
-// The version of the runtime that this class targets.  Must match the version
-// in the runtime.
-static const int RuntimeVersion = 8;
-static const int ProtocolVersion = 2;
-
-namespace {
-class CGObjCGNU : public CodeGen::CGObjCRuntime {
-private:
-  CodeGen::CodeGenModule &CGM;
-  llvm::Module &TheModule;
-  const llvm::StructType *SelStructTy;
-  const llvm::Type *SelectorTy;
-  const llvm::Type *PtrToInt8Ty;
-  const llvm::Type *IMPTy;
-  const llvm::Type *IdTy;
-  const llvm::Type *IntTy;
-  const llvm::Type *PtrTy;
-  const llvm::Type *LongTy;
-  const llvm::Type *PtrToIntTy;
-  std::vector<llvm::Constant*> Classes;
-  std::vector<llvm::Constant*> Categories;
-  std::vector<llvm::Constant*> ConstantStrings;
-  llvm::Function *LoadFunction;
-  llvm::StringMap<llvm::Constant*> ExistingProtocols;
-  typedef std::pair<std::string, std::string> TypedSelector;
-  std::map<TypedSelector, llvm::GlobalAlias*> TypedSelectors;
-  llvm::StringMap<llvm::GlobalAlias*> UntypedSelectors;
-  // Some zeros used for GEPs in lots of places.
-  llvm::Constant *Zeros[2];
-  llvm::Constant *NULLPtr;
-private:
-  llvm::Constant *GenerateIvarList(
-      const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
-      const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
-      const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets);
-  llvm::Constant *GenerateMethodList(const std::string &ClassName,
-      const std::string &CategoryName,
-      const llvm::SmallVectorImpl<Selector>  &MethodSels, 
-      const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes, 
-      bool isClassMethodList);
-  llvm::Constant *GenerateProtocolList(
-      const llvm::SmallVectorImpl<std::string> &Protocols);
-  llvm::Constant *GenerateClassStructure(
-      llvm::Constant *MetaClass,
-      llvm::Constant *SuperClass,
-      unsigned info,
-      const char *Name,
-      llvm::Constant *Version,
-      llvm::Constant *InstanceSize,
-      llvm::Constant *IVars,
-      llvm::Constant *Methods,
-      llvm::Constant *Protocols);
-  llvm::Constant *GenerateProtocolMethodList(
-      const llvm::SmallVectorImpl<llvm::Constant *>  &MethodNames,
-      const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes);
-  llvm::Constant *MakeConstantString(const std::string &Str, const std::string
-      &Name="");
-  llvm::Constant *MakeGlobal(const llvm::StructType *Ty,
-      std::vector<llvm::Constant*> &V, const std::string &Name="");
-  llvm::Constant *MakeGlobal(const llvm::ArrayType *Ty,
-      std::vector<llvm::Constant*> &V, const std::string &Name="");
-public:
-  CGObjCGNU(CodeGen::CodeGenModule &cgm);
-  virtual llvm::Constant *GenerateConstantString(const char *String, 
-      const size_t length);
-  virtual llvm::Value *GenerateMessageSend(llvm::IRBuilder &Builder,
-                                           const llvm::Type *ReturnTy,
-                                           llvm::Value *Sender,
-                                           llvm::Value *Receiver,
-                                           Selector Sel,
-                                           llvm::Value** ArgV,
-                                           unsigned ArgC);
-  virtual llvm::Value *GenerateMessageSendSuper(llvm::IRBuilder &Builder,
-                                                const llvm::Type *ReturnTy,
-                                                llvm::Value *Sender,
-                                                const char *SuperClassName,
-                                                llvm::Value *Receiver,
-                                                Selector Sel,
-                                                llvm::Value** ArgV,
-                                                unsigned ArgC);
-  virtual llvm::Value *LookupClass(llvm::IRBuilder &Builder,
-                                   llvm::Value *ClassName);
-  virtual llvm::Value *GetSelector(llvm::IRBuilder &Builder, Selector Sel);
-  
-  virtual llvm::Function *MethodPreamble(
-                                         const std::string &ClassName,
-                                         const std::string &CategoryName,
-                                         const std::string &MethodName,
-                                         const llvm::Type *ReturnTy,
-                                         const llvm::Type *SelfTy,
-                                         const llvm::Type **ArgTy,
-                                         unsigned ArgC,
-                                         bool isClassMethod,
-                                         bool isVarArg);
-  virtual void GenerateCategory(const char *ClassName, const char *CategoryName,
-           const llvm::SmallVectorImpl<Selector>  &InstanceMethodSels,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
-           const llvm::SmallVectorImpl<Selector>  &ClassMethodSels,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes,
-           const llvm::SmallVectorImpl<std::string> &Protocols);
-  virtual void GenerateClass(
-           const char *ClassName,
-           const char *SuperClassName,
-           const int instanceSize,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets,
-           const llvm::SmallVectorImpl<Selector>  &InstanceMethodSels,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
-           const llvm::SmallVectorImpl<Selector>  &ClassMethodSels,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes,
-           const llvm::SmallVectorImpl<std::string> &Protocols);
-  virtual llvm::Value *GenerateProtocolRef(llvm::IRBuilder &Builder, const char
-      *ProtocolName);
-  virtual void GenerateProtocol(const char *ProtocolName,
-      const llvm::SmallVectorImpl<std::string> &Protocols,
-      const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodNames,
-      const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
-      const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodNames,
-      const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes);
-  virtual llvm::Function *ModuleInitFunction();
-};
-} // end anonymous namespace
-
-
-
-static std::string SymbolNameForClass(const std::string &ClassName) {
-  return ".objc_class_" + ClassName;
-}
-
-static std::string SymbolNameForMethod(const std::string &ClassName, const
-  std::string &CategoryName, const std::string &MethodName, bool isClassMethod)
-{
-  return "._objc_method_" + ClassName +"("+CategoryName+")"+
-            (isClassMethod ? "+" : "-") + MethodName;
-}
-
-CGObjCGNU::CGObjCGNU(CodeGen::CodeGenModule &cgm)
-  : CGM(cgm), TheModule(CGM.getModule()) {
-  IntTy = CGM.getTypes().ConvertType(CGM.getContext().IntTy);
-  LongTy = CGM.getTypes().ConvertType(CGM.getContext().LongTy);
-    
-  Zeros[0] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
-  Zeros[1] = Zeros[0];
-  NULLPtr = llvm::ConstantPointerNull::get(
-    llvm::PointerType::getUnqual(llvm::Type::Int8Ty));
-  // C string type.  Used in lots of places.
-  PtrToInt8Ty = 
-    llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
-  // Get the selector Type.
-  SelStructTy = llvm::StructType::get(
-      PtrToInt8Ty,
-      PtrToInt8Ty,
-      NULL);
-  SelectorTy = llvm::PointerType::getUnqual(SelStructTy);
-  PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
-  PtrTy = PtrToInt8Ty;
- 
-  // Object type
-  llvm::PATypeHolder OpaqueObjTy = llvm::OpaqueType::get();
-  llvm::Type *OpaqueIdTy = llvm::PointerType::getUnqual(OpaqueObjTy);
-  IdTy = llvm::StructType::get(OpaqueIdTy, NULL);
-  llvm::cast<llvm::OpaqueType>(OpaqueObjTy.get())->refineAbstractTypeTo(IdTy);
-  IdTy = llvm::cast<llvm::StructType>(OpaqueObjTy.get());
-  IdTy = llvm::PointerType::getUnqual(IdTy);
- 
-  // IMP type
-  std::vector<const llvm::Type*> IMPArgs;
-  IMPArgs.push_back(IdTy);
-  IMPArgs.push_back(SelectorTy);
-  IMPTy = llvm::FunctionType::get(IdTy, IMPArgs, true);
-}
-// This has to perform the lookup every time, since posing and related
-// techniques can modify the name -> class mapping.
-llvm::Value *CGObjCGNU::LookupClass(llvm::IRBuilder &Builder,
-    llvm::Value *ClassName) {
-  llvm::Constant *ClassLookupFn =
-    TheModule.getOrInsertFunction("objc_lookup_class", IdTy, PtrToInt8Ty,
-        NULL);
-  return Builder.CreateCall(ClassLookupFn, ClassName);
-}
-
-/// GetSelector - Return the pointer to the unique'd string for this selector.
-llvm::Value *CGObjCGNU::GetSelector(llvm::IRBuilder &Builder, Selector Sel) {
-  // FIXME: uniquing on the string is wasteful, unique on Sel instead!
-  llvm::GlobalAlias *&US = UntypedSelectors[Sel.getName()];
-  if (US == 0)
-    US = new llvm::GlobalAlias(llvm::PointerType::getUnqual(SelectorTy),
-                               llvm::GlobalValue::InternalLinkage,
-                               ".objc_untyped_selector_alias",
-                               NULL, &TheModule);
-  
-  return Builder.CreateLoad(US);
-  
-}
-
-llvm::Constant *CGObjCGNU::MakeConstantString(const std::string &Str,
-                                              const std::string &Name) {
-  llvm::Constant * ConstStr = llvm::ConstantArray::get(Str);
-  ConstStr = new llvm::GlobalVariable(ConstStr->getType(), true, 
-                               llvm::GlobalValue::InternalLinkage,
-                               ConstStr, Name, &TheModule);
-  return llvm::ConstantExpr::getGetElementPtr(ConstStr, Zeros, 2);
-}
-llvm::Constant *CGObjCGNU::MakeGlobal(const llvm::StructType *Ty,
-    std::vector<llvm::Constant*> &V, const std::string &Name) {
-  llvm::Constant *C = llvm::ConstantStruct::get(Ty, V);
-  return new llvm::GlobalVariable(Ty, false,
-      llvm::GlobalValue::InternalLinkage, C, Name, &TheModule);
-}
-llvm::Constant *CGObjCGNU::MakeGlobal(const llvm::ArrayType *Ty,
-    std::vector<llvm::Constant*> &V, const std::string &Name) {
-  llvm::Constant *C = llvm::ConstantArray::get(Ty, V);
-  return new llvm::GlobalVariable(Ty, false,
-      llvm::GlobalValue::InternalLinkage, C, Name, &TheModule);
-}
-
-/// Generate an NSConstantString object.
-//TODO: In case there are any crazy people still using the GNU runtime without
-//an OpenStep implementation, this should let them select their own class for
-//constant strings.
-llvm::Constant *CGObjCGNU::GenerateConstantString(const char *String, const
-    size_t length) {
-  std::string Str(String, String +length);
-  std::vector<llvm::Constant*> Ivars;
-  Ivars.push_back(NULLPtr);
-  Ivars.push_back(MakeConstantString(Str));
-  Ivars.push_back(llvm::ConstantInt::get(IntTy, length));
-  llvm::Constant *ObjCStr = MakeGlobal(
-    llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy, NULL),
-    Ivars, ".objc_str");
-  ConstantStrings.push_back(
-      llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty));
-  return ObjCStr;
-}
-
-///Generates a message send where the super is the receiver.  This is a message
-///send to self with special delivery semantics indicating which class's method
-///should be called.
-llvm::Value *CGObjCGNU::GenerateMessageSendSuper(llvm::IRBuilder &Builder,
-                                                 const llvm::Type *ReturnTy,
-                                                 llvm::Value *Sender,
-                                                 const char *SuperClassName,
-                                                 llvm::Value *Receiver,
-                                                 Selector Sel,
-                                                 llvm::Value** ArgV,
-                                                 unsigned ArgC) {
-  // TODO: This should be cached, not looked up every time.
-  llvm::Value *ReceiverClass = LookupClass(Builder,
-      MakeConstantString(SuperClassName));
-  llvm::Value *cmd = GetSelector(Builder, Sel);
-  std::vector<const llvm::Type*> impArgTypes;
-  impArgTypes.push_back(Receiver->getType());
-  impArgTypes.push_back(SelectorTy);
-  
-  // Avoid an explicit cast on the IMP by getting a version that has the right
-  // return type.
-  llvm::FunctionType *impType = llvm::FunctionType::get(ReturnTy, impArgTypes,
-                                                        true);
-  // Construct the structure used to look up the IMP
-  llvm::StructType *ObjCSuperTy = llvm::StructType::get(Receiver->getType(),
-      IdTy, NULL);
-  llvm::Value *ObjCSuper = Builder.CreateAlloca(ObjCSuperTy);
-  // FIXME: volatility
-  Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0));
-  Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1));
-
-  // Get the IMP
-  llvm::Constant *lookupFunction = 
-     TheModule.getOrInsertFunction("objc_msg_lookup_super",
-                                   llvm::PointerType::getUnqual(impType),
-                                   llvm::PointerType::getUnqual(ObjCSuperTy),
-                                   SelectorTy, NULL);
-  llvm::Value *lookupArgs[] = {ObjCSuper, cmd};
-  llvm::Value *imp = Builder.CreateCall(lookupFunction, lookupArgs,
-      lookupArgs+2);
-
-  // Call the method
-  llvm::SmallVector<llvm::Value*, 8> callArgs;
-  callArgs.push_back(Receiver);
-  callArgs.push_back(cmd);
-  callArgs.insert(callArgs.end(), ArgV, ArgV+ArgC);
-  return Builder.CreateCall(imp, callArgs.begin(), callArgs.end());
-}
-
-/// Generate code for a message send expression.  
-llvm::Value *CGObjCGNU::GenerateMessageSend(llvm::IRBuilder &Builder,
-                                            const llvm::Type *ReturnTy,
-                                            llvm::Value *Sender,
-                                            llvm::Value *Receiver,
-                                            Selector Sel,
-                                            llvm::Value** ArgV,
-                                            unsigned ArgC) {
-  llvm::Value *cmd = GetSelector(Builder, Sel);
-
-  // Look up the method implementation.
-  std::vector<const llvm::Type*> impArgTypes;
-  const llvm::Type *RetTy;
-  //TODO: Revisit this when LLVM supports aggregate return types.
-  if (ReturnTy->isSingleValueType() && ReturnTy != llvm::Type::VoidTy) {
-    RetTy = ReturnTy;
-  } else {
-    // For struct returns allocate the space in the caller and pass it up to
-    // the sender.
-    RetTy = llvm::Type::VoidTy;
-    impArgTypes.push_back(llvm::PointerType::getUnqual(ReturnTy));
-  }
-  impArgTypes.push_back(Receiver->getType());
-  impArgTypes.push_back(SelectorTy);
-  
-  // Avoid an explicit cast on the IMP by getting a version that has the right
-  // return type.
-  llvm::FunctionType *impType = llvm::FunctionType::get(RetTy, impArgTypes,
-                                                        true);
-  
-  llvm::Constant *lookupFunction = 
-     TheModule.getOrInsertFunction("objc_msg_lookup",
-                                   llvm::PointerType::getUnqual(impType),
-                                   Receiver->getType(), SelectorTy, NULL);
-  llvm::Value *imp = Builder.CreateCall2(lookupFunction, Receiver, cmd);
-
-  // Call the method.
-  llvm::SmallVector<llvm::Value*, 16> Args;
-  if (!ReturnTy->isSingleValueType()) {
-    llvm::Value *Return = Builder.CreateAlloca(ReturnTy);
-    Args.push_back(Return);
-  }
-  Args.push_back(Receiver);
-  Args.push_back(cmd);
-  Args.insert(Args.end(), ArgV, ArgV+ArgC);
-  if (!ReturnTy->isSingleValueType()) {
-    Builder.CreateCall(imp, Args.begin(), Args.end());
-    return Args[0];
-  }
-  return Builder.CreateCall(imp, Args.begin(), Args.end());
-}
-
-/// Generates a MethodList.  Used in construction of a objc_class and 
-/// objc_category structures.
-llvm::Constant *CGObjCGNU::GenerateMethodList(const std::string &ClassName,
-                                              const std::string &CategoryName, 
-    const llvm::SmallVectorImpl<Selector> &MethodSels, 
-    const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes, 
-    bool isClassMethodList) {
-  // Get the method structure type.  
-  llvm::StructType *ObjCMethodTy = llvm::StructType::get(
-    PtrToInt8Ty, // Really a selector, but the runtime creates it us.
-    PtrToInt8Ty, // Method types
-    llvm::PointerType::getUnqual(IMPTy), //Method pointer
-    NULL);
-  std::vector<llvm::Constant*> Methods;
-  std::vector<llvm::Constant*> Elements;
-  for (unsigned int i = 0, e = MethodTypes.size(); i < e; ++i) {
-    Elements.clear();
-    llvm::Constant *C = CGM.GetAddrOfConstantString(MethodSels[i].getName());
-    Elements.push_back(llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2));
-    Elements.push_back(
-          llvm::ConstantExpr::getGetElementPtr(MethodTypes[i], Zeros, 2));
-    llvm::Constant *Method =
-      TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName,
-                                                MethodSels[i].getName(),
-                                                isClassMethodList));
-    Method = llvm::ConstantExpr::getBitCast(Method,
-        llvm::PointerType::getUnqual(IMPTy));
-    Elements.push_back(Method);
-    Methods.push_back(llvm::ConstantStruct::get(ObjCMethodTy, Elements));
-  }
-
-  // Array of method structures
-  llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodTy,
-                                                            MethodSels.size());
-  llvm::Constant *MethodArray = llvm::ConstantArray::get(ObjCMethodArrayTy,
-                                                         Methods);
-
-  // Structure containing list pointer, array and array count
-  llvm::SmallVector<const llvm::Type*, 16> ObjCMethodListFields;
-  llvm::PATypeHolder OpaqueNextTy = llvm::OpaqueType::get();
-  llvm::Type *NextPtrTy = llvm::PointerType::getUnqual(OpaqueNextTy);
-  llvm::StructType *ObjCMethodListTy = llvm::StructType::get(NextPtrTy, 
-      IntTy, 
-      ObjCMethodArrayTy,
-      NULL);
-  // Refine next pointer type to concrete type
-  llvm::cast<llvm::OpaqueType>(
-      OpaqueNextTy.get())->refineAbstractTypeTo(ObjCMethodListTy);
-  ObjCMethodListTy = llvm::cast<llvm::StructType>(OpaqueNextTy.get());
-
-  Methods.clear();
-  Methods.push_back(llvm::ConstantPointerNull::get(
-        llvm::PointerType::getUnqual(ObjCMethodListTy)));
-  Methods.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty,
-        MethodTypes.size()));
-  Methods.push_back(MethodArray);
-  
-  // Create an instance of the structure
-  return MakeGlobal(ObjCMethodListTy, Methods, ".objc_method_list");
-}
-
-/// Generates an IvarList.  Used in construction of a objc_class.
-llvm::Constant *CGObjCGNU::GenerateIvarList(
-    const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets) {
-  // Get the method structure type.  
-  llvm::StructType *ObjCIvarTy = llvm::StructType::get(
-    PtrToInt8Ty,
-    PtrToInt8Ty,
-    IntTy,
-    NULL);
-  std::vector<llvm::Constant*> Ivars;
-  std::vector<llvm::Constant*> Elements;
-  for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
-    Elements.clear();
-    Elements.push_back( llvm::ConstantExpr::getGetElementPtr(IvarNames[i],
-          Zeros, 2));
-    Elements.push_back( llvm::ConstantExpr::getGetElementPtr(IvarTypes[i],
-          Zeros, 2));
-    Elements.push_back(IvarOffsets[i]);
-    Ivars.push_back(llvm::ConstantStruct::get(ObjCIvarTy, Elements));
-  }
-
-  // Array of method structures
-  llvm::ArrayType *ObjCIvarArrayTy = llvm::ArrayType::get(ObjCIvarTy,
-      IvarNames.size());
-
-  
-  Elements.clear();
-  Elements.push_back(llvm::ConstantInt::get(
-        llvm::cast<llvm::IntegerType>(IntTy), (int)IvarNames.size()));
-  Elements.push_back(llvm::ConstantArray::get(ObjCIvarArrayTy, Ivars));
-  // Structure containing array and array count
-  llvm::StructType *ObjCIvarListTy = llvm::StructType::get(IntTy,
-    ObjCIvarArrayTy,
-    NULL);
-
-  // Create an instance of the structure
-  return MakeGlobal(ObjCIvarListTy, Elements, ".objc_ivar_list");
-}
-
-/// Generate a class structure
-llvm::Constant *CGObjCGNU::GenerateClassStructure(
-    llvm::Constant *MetaClass,
-    llvm::Constant *SuperClass,
-    unsigned info,
-    const char *Name,
-    llvm::Constant *Version,
-    llvm::Constant *InstanceSize,
-    llvm::Constant *IVars,
-    llvm::Constant *Methods,
-    llvm::Constant *Protocols) {
-  // Set up the class structure
-  // Note:  Several of these are char*s when they should be ids.  This is
-  // because the runtime performs this translation on load.
-  llvm::StructType *ClassTy = llvm::StructType::get(
-      PtrToInt8Ty,        // class_pointer
-      PtrToInt8Ty,        // super_class
-      PtrToInt8Ty,        // name
-      LongTy,             // version
-      LongTy,             // info
-      LongTy,             // instance_size
-      IVars->getType(),   // ivars
-      Methods->getType(), // methods
-      // These are all filled in by the runtime, so we pretend 
-      PtrTy,              // dtable
-      PtrTy,              // subclass_list
-      PtrTy,              // sibling_class
-      PtrTy,              // protocols
-      PtrTy,              // gc_object_type
-      NULL);
-  llvm::Constant *Zero = llvm::ConstantInt::get(LongTy, 0);
-  llvm::Constant *NullP =
-    llvm::ConstantPointerNull::get(llvm::cast<llvm::PointerType>(PtrTy));
-  // Fill in the structure
-  std::vector<llvm::Constant*> Elements;
-  Elements.push_back(llvm::ConstantExpr::getBitCast(MetaClass, PtrToInt8Ty));
-  Elements.push_back(SuperClass);
-  Elements.push_back(MakeConstantString(Name, ".class_name"));
-  Elements.push_back(Zero);
-  Elements.push_back(llvm::ConstantInt::get(LongTy, info));
-  Elements.push_back(InstanceSize);
-  Elements.push_back(IVars);
-  Elements.push_back(Methods);
-  Elements.push_back(NullP);
-  Elements.push_back(NullP);
-  Elements.push_back(NullP);
-  Elements.push_back(llvm::ConstantExpr::getBitCast(Protocols, PtrTy));
-  Elements.push_back(NullP);
-  // Create an instance of the structure
-  return MakeGlobal(ClassTy, Elements, SymbolNameForClass(Name));
-}
-
-llvm::Constant *CGObjCGNU::GenerateProtocolMethodList(
-    const llvm::SmallVectorImpl<llvm::Constant *>  &MethodNames,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &MethodTypes) {
-  // Get the method structure type.  
-  llvm::StructType *ObjCMethodDescTy = llvm::StructType::get(
-    PtrToInt8Ty, // Really a selector, but the runtime does the casting for us.
-    PtrToInt8Ty,
-    NULL);
-  std::vector<llvm::Constant*> Methods;
-  std::vector<llvm::Constant*> Elements;
-  for (unsigned int i = 0, e = MethodTypes.size() ; i < e ; i++) {
-    Elements.clear();
-    Elements.push_back( llvm::ConstantExpr::getGetElementPtr(MethodNames[i],
-          Zeros, 2)); 
-    Elements.push_back(
-          llvm::ConstantExpr::getGetElementPtr(MethodTypes[i], Zeros, 2));
-    Methods.push_back(llvm::ConstantStruct::get(ObjCMethodDescTy, Elements));
-  }
-  llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodDescTy,
-      MethodNames.size());
-  llvm::Constant *Array = llvm::ConstantArray::get(ObjCMethodArrayTy, Methods);
-  llvm::StructType *ObjCMethodDescListTy = llvm::StructType::get(
-      IntTy, ObjCMethodArrayTy, NULL);
-  Methods.clear();
-  Methods.push_back(llvm::ConstantInt::get(IntTy, MethodNames.size()));
-  Methods.push_back(Array);
-  return MakeGlobal(ObjCMethodDescListTy, Methods, ".objc_method_list");
-}
-// Create the protocol list structure used in classes, categories and so on
-llvm::Constant *CGObjCGNU::GenerateProtocolList(
-    const llvm::SmallVectorImpl<std::string> &Protocols) {
-  llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
-      Protocols.size());
-  llvm::StructType *ProtocolListTy = llvm::StructType::get(
-      PtrTy, //Should be a recurisve pointer, but it's always NULL here.
-      LongTy,//FIXME: Should be size_t
-      ProtocolArrayTy,
-      NULL);
-  std::vector<llvm::Constant*> Elements; 
-  for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end();
-      iter != endIter ; iter++) {
-    llvm::Constant *Ptr =
-      llvm::ConstantExpr::getBitCast(ExistingProtocols[*iter], PtrToInt8Ty);
-    Elements.push_back(Ptr);
-  }
-  llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
-      Elements);
-  Elements.clear();
-  Elements.push_back(NULLPtr);
-  Elements.push_back(llvm::ConstantInt::get(
-        llvm::cast<llvm::IntegerType>(LongTy), Protocols.size()));
-  Elements.push_back(ProtocolArray);
-  return MakeGlobal(ProtocolListTy, Elements, ".objc_protocol_list");
-}
-
-llvm::Value *CGObjCGNU::GenerateProtocolRef(llvm::IRBuilder &Builder, const
-    char *ProtocolName) {
-  return ExistingProtocols[ProtocolName];
-}
-
-void CGObjCGNU::GenerateProtocol(const char *ProtocolName,
-    const llvm::SmallVectorImpl<std::string> &Protocols,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodNames,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodNames,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes) {
-
-  llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
-  llvm::Constant *InstanceMethodList =
-    GenerateProtocolMethodList(InstanceMethodNames, InstanceMethodTypes);
-  llvm::Constant *ClassMethodList =
-    GenerateProtocolMethodList(ClassMethodNames, ClassMethodTypes);
-  // Protocols are objects containing lists of the methods implemented and
-  // protocols adopted.
-  llvm::StructType *ProtocolTy = llvm::StructType::get(IdTy,
-      PtrToInt8Ty,
-      ProtocolList->getType(),
-      InstanceMethodList->getType(),
-      ClassMethodList->getType(),
-      NULL);
-  std::vector<llvm::Constant*> Elements; 
-  // The isa pointer must be set to a magic number so the runtime knows it's
-  // the correct layout.
-  Elements.push_back(llvm::ConstantExpr::getIntToPtr(
-        llvm::ConstantInt::get(llvm::Type::Int32Ty, ProtocolVersion), IdTy));
-  Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
-  Elements.push_back(ProtocolList);
-  Elements.push_back(InstanceMethodList);
-  Elements.push_back(ClassMethodList);
-  ExistingProtocols[ProtocolName] = 
-    llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolTy, Elements,
-          ".objc_protocol"), IdTy);
-}
-
-void CGObjCGNU::GenerateCategory(
-           const char *ClassName,
-           const char *CategoryName,
-           const llvm::SmallVectorImpl<Selector>  &InstanceMethodSels,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
-           const llvm::SmallVectorImpl<Selector>  &ClassMethodSels,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes,
-           const llvm::SmallVectorImpl<std::string> &Protocols) {
-  std::vector<llvm::Constant*> Elements;
-  Elements.push_back(MakeConstantString(CategoryName));
-  Elements.push_back(MakeConstantString(ClassName));
-  // Instance method list 
-  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
-          ClassName, CategoryName, InstanceMethodSels, InstanceMethodTypes,
-          false), PtrTy));
-  // Class method list
-  Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
-          ClassName, CategoryName, ClassMethodSels, ClassMethodTypes, true),
-        PtrTy));
-  // Protocol list
-  Elements.push_back(llvm::ConstantExpr::getBitCast(
-        GenerateProtocolList(Protocols), PtrTy));
-  Categories.push_back(llvm::ConstantExpr::getBitCast(
-        MakeGlobal(llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, PtrTy,
-            PtrTy, PtrTy, NULL), Elements), PtrTy));
-}
-void CGObjCGNU::GenerateClass(
-           const char *ClassName,
-           const char *SuperClassName,
-           const int instanceSize,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets,
-           const llvm::SmallVectorImpl<Selector>  &InstanceMethodSels,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
-           const llvm::SmallVectorImpl<Selector>  &ClassMethodSels,
-           const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes,
-           const llvm::SmallVectorImpl<std::string> &Protocols) {
-  // Get the superclass pointer.
-  llvm::Constant *SuperClass;
-  if (SuperClassName) {
-    SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
-  } else {
-    SuperClass = llvm::ConstantPointerNull::get(
-        llvm::cast<llvm::PointerType>(PtrToInt8Ty));
-  }
-  // Empty vector used to construct empty method lists
-  llvm::SmallVector<llvm::Constant*, 1>  empty;
-  // Generate the method and instance variable lists
-  llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
-      InstanceMethodSels, InstanceMethodTypes, false);
-  llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
-      ClassMethodSels, ClassMethodTypes, true);
-  llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
-      IvarOffsets);
-  //Generate metaclass for class methods
-  llvm::Constant *MetaClassStruct = GenerateClassStructure(NULLPtr,
-      NULLPtr, 0x2L, /*name*/"", 0, Zeros[0], GenerateIvarList(
-        empty, empty, empty), ClassMethodList, NULLPtr);
-  // Generate the class structure
-  llvm::Constant *ClassStruct = GenerateClassStructure(MetaClassStruct,
-      SuperClass, 0x1L, ClassName, 0,
-      llvm::ConstantInt::get(llvm::Type::Int32Ty, instanceSize), IvarList,
-      MethodList, GenerateProtocolList(Protocols));
-  // Add class structure to list to be added to the symtab later
-  ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty);
-  Classes.push_back(ClassStruct);
-}
-
-llvm::Function *CGObjCGNU::ModuleInitFunction() { 
-  // Only emit an ObjC load function if no Objective-C stuff has been called
-  if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
-      ExistingProtocols.empty() && TypedSelectors.empty() &&
-      UntypedSelectors.empty())
-    return NULL;
-
-  // Name the ObjC types to make the IR a bit easier to read
-  TheModule.addTypeName(".objc_selector", SelectorTy);
-  TheModule.addTypeName(".objc_id", IdTy);
-  TheModule.addTypeName(".objc_imp", IMPTy);
-
-  std::vector<llvm::Constant*> Elements;
-  // Generate statics list:
-  llvm::ArrayType *StaticsArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
-      ConstantStrings.size() + 1);
-  ConstantStrings.push_back(NULLPtr);
-  Elements.push_back(MakeConstantString("NSConstantString",
-        ".objc_static_class_name"));
-  Elements.push_back(llvm::ConstantArray::get(StaticsArrayTy, ConstantStrings));
-  llvm::StructType *StaticsListTy = 
-    llvm::StructType::get(PtrToInt8Ty, StaticsArrayTy, NULL);
-  llvm::Type *StaticsListPtrTy = llvm::PointerType::getUnqual(StaticsListTy);
-  llvm::Constant *Statics = 
-    MakeGlobal(StaticsListTy, Elements, ".objc_statics");
-  llvm::ArrayType *StaticsListArrayTy =
-    llvm::ArrayType::get(StaticsListPtrTy, 2);
-  Elements.clear();
-  Elements.push_back(Statics);
-  Elements.push_back(llvm::Constant::getNullValue(StaticsListPtrTy));
-  Statics = MakeGlobal(StaticsListArrayTy, Elements, ".objc_statics_ptr");
-  Statics = llvm::ConstantExpr::getBitCast(Statics, PtrTy);
-  // Array of classes, categories, and constant objects
-  llvm::ArrayType *ClassListTy = llvm::ArrayType::get(PtrToInt8Ty,
-      Classes.size() + Categories.size()  + 2);
-  llvm::StructType *SymTabTy = llvm::StructType::get(LongTy, SelectorTy,
-                                                     llvm::Type::Int16Ty,
-                                                     llvm::Type::Int16Ty,
-                                                     ClassListTy, NULL);
-
-  Elements.clear();
-  // Pointer to an array of selectors used in this module.
-  std::vector<llvm::Constant*> Selectors;
-  for (std::map<TypedSelector, llvm::GlobalAlias*>::iterator
-     iter = TypedSelectors.begin(), iterEnd = TypedSelectors.end();
-     iter != iterEnd ; ++iter) {
-    Elements.push_back(MakeConstantString(iter->first.first, ".objc_sel_name"));
-    Elements.push_back(MakeConstantString(iter->first.second,
-                                          ".objc_sel_types"));
-    Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
-    Elements.clear();
-  }
-  for (llvm::StringMap<llvm::GlobalAlias*>::iterator
-      iter = UntypedSelectors.begin(), iterEnd = UntypedSelectors.end();
-      iter != iterEnd; ++iter) {
-    Elements.push_back(
-        MakeConstantString(iter->getKeyData(), ".objc_sel_name"));
-    Elements.push_back(NULLPtr);
-    Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
-    Elements.clear();
-  }
-  Elements.push_back(NULLPtr);
-  Elements.push_back(NULLPtr);
-  Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
-  Elements.clear();
-  // Number of static selectors
-  Elements.push_back(llvm::ConstantInt::get(LongTy, Selectors.size() ));
-  llvm::Constant *SelectorList = MakeGlobal(
-          llvm::ArrayType::get(SelStructTy, Selectors.size()), Selectors,
-          ".objc_selector_list");
-  Elements.push_back(llvm::ConstantExpr::getBitCast(SelectorList, SelectorTy));
-
-  // Now that all of the static selectors exist, create pointers to them.
-  int index = 0;
-  for (std::map<TypedSelector, llvm::GlobalAlias*>::iterator
-     iter=TypedSelectors.begin(), iterEnd =TypedSelectors.end();
-     iter != iterEnd; ++iter) {
-    llvm::Constant *Idxs[] = {Zeros[0],
-      llvm::ConstantInt::get(llvm::Type::Int32Ty, index++), Zeros[0]};
-    llvm::GlobalVariable *SelPtr = new llvm::GlobalVariable(SelectorTy, true,
-        llvm::GlobalValue::InternalLinkage,
-        llvm::ConstantExpr::getGetElementPtr(SelectorList, Idxs, 2),
-        ".objc_sel_ptr", &TheModule);
-    (*iter).second->setAliasee(SelPtr);
-  }
-  for (llvm::StringMap<llvm::GlobalAlias*>::iterator
-      iter=UntypedSelectors.begin(), iterEnd = UntypedSelectors.end();
-      iter != iterEnd; iter++) {
-    llvm::Constant *Idxs[] = {Zeros[0],
-      llvm::ConstantInt::get(llvm::Type::Int32Ty, index++), Zeros[0]};
-    llvm::GlobalVariable *SelPtr = new llvm::GlobalVariable(SelectorTy, true,
-        llvm::GlobalValue::InternalLinkage,
-        llvm::ConstantExpr::getGetElementPtr(SelectorList, Idxs, 2),
-        ".objc_sel_ptr", &TheModule);
-    (*iter).second->setAliasee(SelPtr);
-  }
-  // Number of classes defined.
-  Elements.push_back(llvm::ConstantInt::get(llvm::Type::Int16Ty, 
-        Classes.size()));
-  // Number of categories defined
-  Elements.push_back(llvm::ConstantInt::get(llvm::Type::Int16Ty, 
-        Categories.size()));
-  // Create an array of classes, then categories, then static object instances
-  Classes.insert(Classes.end(), Categories.begin(), Categories.end());
-  //  NULL-terminated list of static object instances (mainly constant strings)
-  Classes.push_back(Statics);
-  Classes.push_back(NULLPtr);
-  llvm::Constant *ClassList = llvm::ConstantArray::get(ClassListTy, Classes);
-  Elements.push_back(ClassList);
-  // Construct the symbol table 
-  llvm::Constant *SymTab= MakeGlobal(SymTabTy, Elements);
-
-  // The symbol table is contained in a module which has some version-checking
-  // constants
-  llvm::StructType * ModuleTy = llvm::StructType::get(LongTy, LongTy,
-      PtrToInt8Ty, llvm::PointerType::getUnqual(SymTabTy), NULL);
-  Elements.clear();
-  // Runtime version used for compatibility checking.
-  Elements.push_back(llvm::ConstantInt::get(LongTy, RuntimeVersion));
-  //FIXME: Should be sizeof(ModuleTy)
-  Elements.push_back(llvm::ConstantInt::get(LongTy, 16));
-  //FIXME: Should be the path to the file where this module was declared
-  Elements.push_back(NULLPtr);
-  Elements.push_back(SymTab);
-  llvm::Value *Module = MakeGlobal(ModuleTy, Elements);
-
-  // Create the load function calling the runtime entry point with the module
-  // structure
-  std::vector<const llvm::Type*> VoidArgs;
-  llvm::Function * LoadFunction = llvm::Function::Create(
-      llvm::FunctionType::get(llvm::Type::VoidTy, VoidArgs, false),
-      llvm::GlobalValue::InternalLinkage, ".objc_load_function",
-      &TheModule);
-  llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", LoadFunction);
-  llvm::IRBuilder Builder;
-  Builder.SetInsertPoint(EntryBB);
-  llvm::Value *Register = TheModule.getOrInsertFunction("__objc_exec_class",
-      llvm::Type::VoidTy, llvm::PointerType::getUnqual(ModuleTy), NULL);
-  Builder.CreateCall(Register, Module);
-  Builder.CreateRetVoid();
-  return LoadFunction;
-}
-llvm::Function *CGObjCGNU::MethodPreamble(
-                                         const std::string &ClassName,
-                                         const std::string &CategoryName,
-                                         const std::string &MethodName,
-                                         const llvm::Type *ReturnTy,
-                                         const llvm::Type *SelfTy,
-                                         const llvm::Type **ArgTy,
-                                         unsigned ArgC,
-                                         bool isClassMethod,
-                                         bool isVarArg) {
-  std::vector<const llvm::Type*> Args;
-  if (!ReturnTy->isSingleValueType() && ReturnTy != llvm::Type::VoidTy) {
-    Args.push_back(llvm::PointerType::getUnqual(ReturnTy));
-    ReturnTy = llvm::Type::VoidTy;
-  }
-  Args.push_back(SelfTy);
-  Args.push_back(SelectorTy);
-  Args.insert(Args.end(), ArgTy, ArgTy+ArgC);
-
-  llvm::FunctionType *MethodTy = llvm::FunctionType::get(ReturnTy,
-      Args,
-      isVarArg);
-  std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName,
-      MethodName, isClassMethod);
-
-  llvm::Function *Method = llvm::Function::Create(MethodTy,
-      llvm::GlobalValue::InternalLinkage,
-      FunctionName,
-      &TheModule);
-  llvm::Function::arg_iterator AI = Method->arg_begin();
-  // Name the struct return argument.
-  // FIXME: This is probably the wrong test.
-  if (!ReturnTy->isFirstClassType() && ReturnTy != llvm::Type::VoidTy) {
-    AI->setName("agg.result");
-    ++AI;
-  }
-  AI->setName("self");
-  ++AI;
-  AI->setName("_cmd");
-  return Method;
-}
-
-CodeGen::CGObjCRuntime *CodeGen::CreateObjCRuntime(CodeGen::CodeGenModule &CGM){
-  return new CGObjCGNU(CGM);
-}
diff --git a/Clang/CGObjCRuntime.h b/Clang/CGObjCRuntime.h
deleted file mode 100644
index a5d88c3..0000000
--- a/Clang/CGObjCRuntime.h
+++ /dev/null
@@ -1,126 +0,0 @@
-//===----- CGObjCRuntime.h - Emit LLVM Code from ASTs for a Module --------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This provides an abstract class for Objective-C code generation.  Concrete
-// subclasses of this implement code generation for specific Objective-C
-// runtime libraries.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef CLANG_CODEGEN_OBCJRUNTIME_H
-#define CLANG_CODEGEN_OBCJRUNTIME_H
-#include "llvm/ADT/SmallVector.h"
-#include <string>
-
-namespace llvm {
-  class IRBuilder;
-  class Constant;
-  class Type;
-  class Value;
-  class Module;
-  class Function;
-}
-
-namespace clang {
-  class Selector;
-  
-namespace CodeGen {
-  class CodeGenModule;
-
-//FIXME Several methods should be pure virtual but aren't to avoid the
-//partially-implemented subclass breaking.
-
-/// Implements runtime-specific code generation functions.
-class CGObjCRuntime {
-public:
-  virtual ~CGObjCRuntime();
-  
-  /// Generate an Objective-C message send operation
-  virtual llvm::Value *GenerateMessageSend(llvm::IRBuilder &Builder,
-                                           const llvm::Type *ReturnTy,
-                                           llvm::Value *Sender,
-                                           llvm::Value *Receiver,
-                                           Selector Sel,
-                                           llvm::Value** ArgV,
-                                           unsigned ArgC) =0;
-  /// Generate the function required to register all Objective-C components in
-  /// this compilation unit with the runtime library.
-  virtual llvm::Function *ModuleInitFunction() =0;
-  /// Get a selector for the specified name and type values
-  virtual llvm::Value *GetSelector(llvm::IRBuilder &Builder, Selector Sel) = 0;
-  /// Generate a constant string object
-  virtual llvm::Constant *GenerateConstantString(const char *String,
-                                                 const size_t Length) = 0;
-  /// Generate a category.  A category contains a list of methods (and
-  /// accompanying metadata) and a list of protocols.
-  virtual void GenerateCategory(const char *ClassName, const char *CategoryName,
-             const llvm::SmallVectorImpl<Selector>  &InstanceMethodSels,
-             const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
-             const llvm::SmallVectorImpl<Selector>  &ClassMethodSels,
-             const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes,
-             const llvm::SmallVectorImpl<std::string> &Protocols) =0;
-  /// Generate a class stucture for this class.
-  virtual void GenerateClass(
-             const char *ClassName,
-             const char *SuperClassName,
-             const int instanceSize,
-             const llvm::SmallVectorImpl<llvm::Constant *>  &IvarNames,
-             const llvm::SmallVectorImpl<llvm::Constant *>  &IvarTypes,
-             const llvm::SmallVectorImpl<llvm::Constant *>  &IvarOffsets,
-             const llvm::SmallVectorImpl<Selector>  &InstanceMethodSels,
-             const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
-             const llvm::SmallVectorImpl<Selector>  &ClassMethodSels,
-             const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes,
-             const llvm::SmallVectorImpl<std::string> &Protocols) =0;
-  /// Generate a reference to the named protocol.
-  virtual llvm::Value *GenerateProtocolRef(llvm::IRBuilder &Builder, const char
-      *ProtocolName) =0;
-  virtual llvm::Value *GenerateMessageSendSuper(llvm::IRBuilder &Builder,
-                                                const llvm::Type *ReturnTy,
-                                                llvm::Value *Sender,
-                                                const char *SuperClassName,
-                                                llvm::Value *Receiver,
-                                                Selector Sel,
-                                                llvm::Value** ArgV,
-                                                unsigned ArgC) = 0;
-  /// Generate the named protocol.  Protocols contain method metadata but no 
-  /// implementations. 
-  virtual void GenerateProtocol(const char *ProtocolName,
-    const llvm::SmallVectorImpl<std::string> &Protocols,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodNames,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &InstanceMethodTypes,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodNames,
-    const llvm::SmallVectorImpl<llvm::Constant *>  &ClassMethodTypes) =0;
-  /// Generate a function preamble for a method with the specified types
-  virtual llvm::Function *MethodPreamble(
-                                         const std::string &ClassName,
-                                         const std::string &CategoryName,
-                                         const std::string &MethodName,
-                                         const llvm::Type *ReturnTy,
-                                         const llvm::Type *SelfTy,
-                                         const llvm::Type **ArgTy,
-                                         unsigned ArgC,
-                                         bool isClassMethod,
-                                         bool isVarArg) = 0;
-  /// Look up the class for the specified name
-  virtual llvm::Value *LookupClass(llvm::IRBuilder &Builder, llvm::Value
-      *ClassName) =0;
-  /// If instance variable addresses are determined at runtime then this should
-  /// return true, otherwise instance variables will be accessed directly from
-  /// the structure.  If this returns true then @defs is invalid for this
-  /// runtime and a warning should be generated.
-  virtual bool LateBoundIVars() { return false; }
-};
-
-/// Creates an instance of an Objective-C runtime class.  
-//TODO: This should include some way of selecting which runtime to target.
-CGObjCRuntime *CreateObjCRuntime(CodeGenModule &CGM);
-}
-}
-#endif