Delete the driver's HostInfo class. This abstraction just never really

did anything. The two big pieces of functionality it tried to provide
was to cache the ToolChain objects for each target, and to figure out
the exact target based on the flag set coming in to an invocation.
However, it had a lot of flaws even with those goals:
 - Neither of these have anything to do with the host, or its info.
 - The HostInfo class was setup as a full blown class *hierarchy* with
   a separate implementation for each "host" OS. This required
   dispatching just to create the objects in the first place.
 - The hierarchy claimed to represent the host, when in fact it was
   based on the target OS.
 - Each leaf in the hierarchy was responsible for implementing the flag
   processing and caching, resulting in a *lot* of copy-paste code and
   quite a few bugs.
 - The caching was consistently done based on architecture alone, even
   though *any* aspect of the targeted triple might change the behavior
   of the configured toolchain.
 - Flag processing was already being done in the Driver proper,
   separating the flag handling even more than it already is.

Instead of this, we can simply have the dispatch logic in the Driver
which previously created a HostInfo object create the ToolChain objects.
Adding caching in the Driver layer is a tiny amount of code. Finally,
pulling the flag processing into the Driver puts it where it belongs and
consolidates it in one location.

The result is that two functions, and maybe 100 lines of new code
replace over 10 classes and 800 lines of code. Woot.

This also paves the way to introduce more detailed ToolChain objects for
various OSes without threading through a new HostInfo type as well, and
the accompanying boiler plate. That, of course, was the yak I started to
shave that began this entire refactoring escapade. Wheee!

llvm-svn: 148950

4 files changed, 119 insertions, 725 deletions

diff --git a/clang/lib/Driver/CMakeLists.txt b/clang/lib/Driver/CMakeLists.txt
index 21667e0ee9c..a798e207503 100644
--- a/clang/lib/Driver/CMakeLists.txt
+++ b/clang/lib/Driver/CMakeLists.txt
@@ -9,7 +9,6 @@ add_clang_library(clangDriver
   Compilation.cpp
   Driver.cpp
   DriverOptions.cpp
-  HostInfo.cpp
   Job.cpp
   Option.cpp
   OptTable.cpp
diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
index f44fe279b02..69dba47be26 100644
--- a/clang/lib/Driver/Driver.cpp
+++ b/clang/lib/Driver/Driver.cpp
@@ -18,7 +18,6 @@
 #include "clang/Driver/ArgList.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/DriverDiagnostic.h"
-#include "clang/Driver/HostInfo.h"
 #include "clang/Driver/Job.h"
 #include "clang/Driver/OptTable.h"
 #include "clang/Driver/Option.h"
@@ -40,6 +39,7 @@
 #include "llvm/Support/Program.h"
 
 #include "InputInfo.h"
+#include "ToolChains.h"
 
 #include <map>
 
@@ -91,7 +91,11 @@ Driver::Driver(StringRef ClangExecutable,
 
 Driver::~Driver() {
   delete Opts;
-  delete Host;
+
+  for (llvm::StringMap<ToolChain *>::iterator I = ToolChains.begin(),
+                                              E = ToolChains.end();
+       I != E; ++I)
+    delete I->second;
 }
 
 InputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgList) {
@@ -236,18 +240,6 @@ DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {
   return DAL;
 }
 
-/// \brief Compute target triple from args.
-///
-/// This routine provides the logic to compute a target triple from various
-/// args passed to the driver and the default triple string.
-static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple,
-                                        const ArgList &Args) {
-  if (const Arg *A = Args.getLastArg(options::OPT_target))
-    DefaultTargetTriple = A->getValue(Args);
-
-  return llvm::Triple(llvm::Triple::normalize(DefaultTargetTriple));
-}
-
 Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
   llvm::PrettyStackTraceString CrashInfo("Compilation construction");
 
@@ -329,15 +321,11 @@ Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
   if (Args->hasArg(options::OPT_nostdlib))
     UseStdLib = false;
 
-  // Compute the target triple based on the args, and build a Host out of it.
-  // FIXME: Yes, this makes no sense. HostInfo has little to do with the host.
-  Host = GetHostInfo(computeTargetTriple(DefaultTargetTriple, *Args));
-
   // Perform the default argument translations.
   DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args);
 
   // Owned by the host.
-  const ToolChain &TC = *Host->CreateToolChain(*Args);
+  const ToolChain &TC = getToolChain(*Args);
 
   // The compilation takes ownership of Args.
   Compilation *C = new Compilation(*this, TC, Args, TranslatedArgs);
@@ -1328,9 +1316,8 @@ void Driver::BuildJobsForAction(Compilation &C,
   if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
     const ToolChain *TC = &C.getDefaultToolChain();
 
-    std::string Arch;
     if (BAA->getArchName())
-      TC = Host->CreateToolChain(C.getArgs(), BAA->getArchName());
+      TC = &getToolChain(C.getArgs(), BAA->getArchName());
 
     BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(),
                        AtTopLevel, LinkingOutput, Result);
@@ -1584,39 +1571,118 @@ std::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix)
   return P.str();
 }
 
-const HostInfo *Driver::GetHostInfo(const llvm::Triple &Triple) const {
-  llvm::PrettyStackTraceString CrashInfo("Constructing host");
-
-  // TCE is an osless target
-  if (Triple.getArchName() == "tce")
-    return createTCEHostInfo(*this, Triple);
-
-  switch (Triple.getOS()) {
-  case llvm::Triple::AuroraUX:
-    return createAuroraUXHostInfo(*this, Triple);
-  case llvm::Triple::Darwin:
-  case llvm::Triple::MacOSX:
-  case llvm::Triple::IOS:
-    return createDarwinHostInfo(*this, Triple);
-  case llvm::Triple::DragonFly:
-    return createDragonFlyHostInfo(*this, Triple);
-  case llvm::Triple::OpenBSD:
-    return createOpenBSDHostInfo(*this, Triple);
-  case llvm::Triple::NetBSD:
-    return createNetBSDHostInfo(*this, Triple);
-  case llvm::Triple::FreeBSD:
-    return createFreeBSDHostInfo(*this, Triple);
-  case llvm::Triple::Minix:
-    return createMinixHostInfo(*this, Triple);
-  case llvm::Triple::Linux:
-    return createLinuxHostInfo(*this, Triple);
-  case llvm::Triple::Win32:
-    return createWindowsHostInfo(*this, Triple);
-  case llvm::Triple::MinGW32:
-    return createMinGWHostInfo(*this, Triple);
-  default:
-    return createUnknownHostInfo(*this, Triple);
+/// \brief Compute target triple from args.
+///
+/// This routine provides the logic to compute a target triple from various
+/// args passed to the driver and the default triple string.
+static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple,
+                                        const ArgList &Args,
+                                        StringRef DarwinArchName) {
+  if (const Arg *A = Args.getLastArg(options::OPT_target))
+    DefaultTargetTriple = A->getValue(Args);
+
+  llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
+
+  // Handle Darwin-specific options available here.
+  if (Target.isOSDarwin()) {
+    // If an explict Darwin arch name is given, that trumps all.
+    if (!DarwinArchName.empty()) {
+      Target.setArch(
+        llvm::Triple::getArchTypeForDarwinArchName(DarwinArchName));
+      return Target;
+    }
+
+    // Handle the Darwin '-arch' flag.
+    if (Arg *A = Args.getLastArg(options::OPT_arch)) {
+      llvm::Triple::ArchType DarwinArch
+        = llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args));
+      if (DarwinArch != llvm::Triple::UnknownArch)
+        Target.setArch(DarwinArch);
+    }
+  }
+
+  // Skip further flag support on OSes which don't support '-m32' or '-m64'.
+  if (Target.getArchName() == "tce" ||
+      Target.getOS() == llvm::Triple::AuroraUX ||
+      Target.getOS() == llvm::Triple::Minix)
+    return Target;
+
+  // Handle pseudo-target flags '-m32' and '-m64'.
+  // FIXME: Should this information be in llvm::Triple?
+  if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
+    if (A->getOption().matches(options::OPT_m32)) {
+      if (Target.getArch() == llvm::Triple::x86_64)
+        Target.setArch(llvm::Triple::x86);
+      if (Target.getArch() == llvm::Triple::ppc64)
+        Target.setArch(llvm::Triple::ppc);
+    } else {
+      if (Target.getArch() == llvm::Triple::x86)
+        Target.setArch(llvm::Triple::x86_64);
+      if (Target.getArch() == llvm::Triple::ppc)
+        Target.setArch(llvm::Triple::ppc64);
+    }
+  }
+
+  return Target;
+}
+
+const ToolChain &Driver::getToolChain(const ArgList &Args,
+                                      StringRef DarwinArchName) const {
+  llvm::Triple Target = computeTargetTriple(DefaultTargetTriple, Args,
+                                            DarwinArchName);
+
+  ToolChain *&TC = ToolChains[Target.str()];
+  if (!TC) {
+    switch (Target.getOS()) {
+    case llvm::Triple::AuroraUX:
+      TC = new toolchains::AuroraUX(*this, Target);
+      break;
+    case llvm::Triple::Darwin:
+    case llvm::Triple::MacOSX:
+    case llvm::Triple::IOS:
+      if (Target.getArch() == llvm::Triple::x86 ||
+          Target.getArch() == llvm::Triple::x86_64 ||
+          Target.getArch() == llvm::Triple::arm ||
+          Target.getArch() == llvm::Triple::thumb)
+        TC = new toolchains::DarwinClang(*this, Target);
+      else
+        TC = new toolchains::Darwin_Generic_GCC(*this, Target);
+      break;
+    case llvm::Triple::DragonFly:
+      TC = new toolchains::DragonFly(*this, Target);
+      break;
+    case llvm::Triple::OpenBSD:
+      TC = new toolchains::OpenBSD(*this, Target);
+      break;
+    case llvm::Triple::NetBSD:
+      TC = new toolchains::NetBSD(*this, Target, Target);
+      break;
+    case llvm::Triple::FreeBSD:
+      TC = new toolchains::FreeBSD(*this, Target);
+      break;
+    case llvm::Triple::Minix:
+      TC = new toolchains::Minix(*this, Target);
+      break;
+    case llvm::Triple::Linux:
+      TC = new toolchains::Linux(*this, Target);
+      break;
+    case llvm::Triple::Win32:
+      TC = new toolchains::Windows(*this, Target);
+      break;
+    case llvm::Triple::MinGW32:
+      // FIXME: We need a MinGW toolchain. Fallthrough for now.
+    default:
+      // TCE is an OSless target
+      if (Target.getArchName() == "tce") {
+        TC = new toolchains::TCEToolChain(*this, Target);
+        break;
+      }
+
+      TC = new toolchains::Generic_GCC(*this, Target);
+      break;
+    }
   }
+  return *TC;
 }
 
 bool Driver::ShouldUseClangCompiler(const Compilation &C, const JobAction &JA,
diff --git a/clang/lib/Driver/HostInfo.cpp b/clang/lib/Driver/HostInfo.cpp
deleted file mode 100644
index 386e1df08ed..00000000000
--- a/clang/lib/Driver/HostInfo.cpp
+++ /dev/null
@@ -1,670 +0,0 @@
-//===--- HostInfo.cpp - Host specific information -------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "clang/Driver/HostInfo.h"
-
-#include "clang/Driver/Arg.h"
-#include "clang/Driver/ArgList.h"
-#include "clang/Driver/Driver.h"
-#include "clang/Driver/DriverDiagnostic.h"
-#include "clang/Driver/Option.h"
-#include "clang/Driver/Options.h"
-
-#include "llvm/ADT/StringMap.h"
-#include "llvm/Support/Compiler.h"
-
-#include "ToolChains.h"
-
-#include <cassert>
-
-using namespace clang::driver;
-
-HostInfo::HostInfo(const Driver &D, const llvm::Triple &_Triple)
-  : TheDriver(D), Triple(_Triple) {
-}
-
-HostInfo::~HostInfo() {
-}
-
-namespace {
-
-// Darwin Host Info
-
-/// DarwinHostInfo - Darwin host information implementation.
-class DarwinHostInfo : public HostInfo {
-  /// Cache of tool chains we have created.
-  mutable llvm::DenseMap<unsigned, ToolChain*> ToolChains;
-
-public:
-  DarwinHostInfo(const Driver &D, const llvm::Triple &Triple);
-  ~DarwinHostInfo();
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args,
-                                     const char *ArchName) const;
-};
-
-DarwinHostInfo::DarwinHostInfo(const Driver &D, const llvm::Triple& Triple)
-  : HostInfo(D, Triple) {
-}
-
-DarwinHostInfo::~DarwinHostInfo() {
-  for (llvm::DenseMap<unsigned, ToolChain*>::iterator
-         it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
-    delete it->second;
-}
-
-ToolChain *DarwinHostInfo::CreateToolChain(const ArgList &Args,
-                                           const char *ArchName) const {
-  llvm::Triple::ArchType Arch;
-
-  if (!ArchName) {
-    // If we aren't looking for a specific arch, infer the default architecture
-    // based on -arch and -m32/-m64 command line options.
-    if (Arg *A = Args.getLastArg(options::OPT_arch)) {
-      // The gcc driver behavior with multiple -arch flags wasn't consistent for
-      // things which rely on a default architecture. We just use the last -arch
-      // to find the default tool chain (assuming it is valid).
-      Arch = llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args));
-
-      // If it was invalid just use the host, we will reject this command line
-      // later.
-      if (Arch == llvm::Triple::UnknownArch)
-        Arch = getTriple().getArch();
-    } else {
-      // Otherwise default to the arch of the host.
-      Arch = getTriple().getArch();
-    }
-
-    // Honor -m32 and -m64 when finding the default tool chain.
-    //
-    // FIXME: Should this information be in llvm::Triple?
-    if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
-      if (A->getOption().matches(options::OPT_m32)) {
-        if (Arch == llvm::Triple::x86_64)
-          Arch = llvm::Triple::x86;
-        if (Arch == llvm::Triple::ppc64)
-          Arch = llvm::Triple::ppc;
-      } else {
-        if (Arch == llvm::Triple::x86)
-          Arch = llvm::Triple::x86_64;
-        if (Arch == llvm::Triple::ppc)
-          Arch = llvm::Triple::ppc64;
-      }
-    }
-  } else
-    Arch = llvm::Triple::getArchTypeForDarwinArchName(ArchName);
-
-  assert(Arch != llvm::Triple::UnknownArch && "Unexpected arch!");
-  ToolChain *&TC = ToolChains[Arch];
-  if (!TC) {
-    llvm::Triple TCTriple(getTriple());
-    TCTriple.setArch(Arch);
-
-    // If we recognized the arch, match it to the toolchains we support.
-    if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64 ||
-        Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
-      TC = new toolchains::DarwinClang(getDriver(), TCTriple);
-    } else
-      TC = new toolchains::Darwin_Generic_GCC(getDriver(), TCTriple);
-  }
-
-  return TC;
-}
-
-// TCE Host Info
-
-/// TCEHostInfo - TCE host information implementation (see http://tce.cs.tut.fi)
-class TCEHostInfo : public HostInfo {
-
-public:
-  TCEHostInfo(const Driver &D, const llvm::Triple &Triple);
-  ~TCEHostInfo() {}
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args, 
-                                     const char *ArchName) const;
-};
-
-TCEHostInfo::TCEHostInfo(const Driver &D, const llvm::Triple& Triple)
-  : HostInfo(D, Triple) {
-}
-
-ToolChain *TCEHostInfo::CreateToolChain(const ArgList &Args, 
-                                        const char *ArchName) const {
-  llvm::Triple TCTriple(getTriple());
-//  TCTriple.setArchName(ArchName);
-  return new toolchains::TCEToolChain(getDriver(), TCTriple);
-}
-
-
-// Unknown Host Info
-
-/// UnknownHostInfo - Generic host information to use for unknown hosts.
-class UnknownHostInfo : public HostInfo {
-  /// Cache of tool chains we have created.
-  mutable llvm::StringMap<ToolChain*> ToolChains;
-
-public:
-  UnknownHostInfo(const Driver &D, const llvm::Triple& Triple);
-  ~UnknownHostInfo();
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args,
-                                     const char *ArchName) const;
-};
-
-UnknownHostInfo::UnknownHostInfo(const Driver &D, const llvm::Triple& Triple)
-  : HostInfo(D, Triple) {
-}
-
-UnknownHostInfo::~UnknownHostInfo() {
-  for (llvm::StringMap<ToolChain*>::iterator
-         it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
-    delete it->second;
-}
-
-ToolChain *UnknownHostInfo::CreateToolChain(const ArgList &Args,
-                                            const char *ArchName) const {
-  assert(!ArchName &&
-         "Unexpected arch name on platform without driver support.");
-
-  // Automatically handle some instances of -m32/-m64 we know about.
-  std::string Arch = getArchName();
-  ArchName = Arch.c_str();
-  if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
-    if (Triple.getArch() == llvm::Triple::x86 ||
-        Triple.getArch() == llvm::Triple::x86_64) {
-      ArchName =
-        (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
-    } else if (Triple.getArch() == llvm::Triple::ppc ||
-               Triple.getArch() == llvm::Triple::ppc64) {
-      ArchName =
-        (A->getOption().matches(options::OPT_m32)) ? "powerpc" : "powerpc64";
-    }
-  }
-
-  ToolChain *&TC = ToolChains[ArchName];
-  if (!TC) {
-    llvm::Triple TCTriple(getTriple());
-    TCTriple.setArchName(ArchName);
-
-    TC = new toolchains::Generic_GCC(getDriver(), TCTriple);
-  }
-
-  return TC;
-}
-
-// OpenBSD Host Info
-
-/// OpenBSDHostInfo -  OpenBSD host information implementation.
-class OpenBSDHostInfo : public HostInfo {
-  /// Cache of tool chains we have created.
-  mutable llvm::StringMap<ToolChain*> ToolChains;
-
-public:
-  OpenBSDHostInfo(const Driver &D, const llvm::Triple& Triple)
-    : HostInfo(D, Triple) {}
-  ~OpenBSDHostInfo();
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args,
-                                     const char *ArchName) const;
-};
-
-OpenBSDHostInfo::~OpenBSDHostInfo() {
-  for (llvm::StringMap<ToolChain*>::iterator
-         it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
-    delete it->second;
-}
-
-ToolChain *OpenBSDHostInfo::CreateToolChain(const ArgList &Args,
-                                            const char *ArchName) const {
-  assert(!ArchName &&
-         "Unexpected arch name on platform without driver driver support.");
-
-  std::string Arch = getArchName();
-  ArchName = Arch.c_str();
-
-  ToolChain *&TC = ToolChains[ArchName];
-  if (!TC) {
-    llvm::Triple TCTriple(getTriple());
-    TCTriple.setArchName(ArchName);
-
-    TC = new toolchains::OpenBSD(getDriver(), TCTriple);
-  }
-
-  return TC;
-}
-
-// AuroraUX Host Info
-
-/// AuroraUXHostInfo - AuroraUX host information implementation.
-class AuroraUXHostInfo : public HostInfo {
-  /// Cache of tool chains we have created.
-  mutable llvm::StringMap<ToolChain*> ToolChains;
-
-public:
-  AuroraUXHostInfo(const Driver &D, const llvm::Triple& Triple)
-    : HostInfo(D, Triple) {}
-  ~AuroraUXHostInfo();
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args,
-                                     const char *ArchName) const;
-};
-
-AuroraUXHostInfo::~AuroraUXHostInfo() {
-  for (llvm::StringMap<ToolChain*>::iterator
-         it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
-    delete it->second;
-}
-
-ToolChain *AuroraUXHostInfo::CreateToolChain(const ArgList &Args,
-                                             const char *ArchName) const {
-  assert(!ArchName &&
-         "Unexpected arch name on platform without driver driver support.");
-
-  ToolChain *&TC = ToolChains[getArchName()];
-
-  if (!TC) {
-    llvm::Triple TCTriple(getTriple());
-    TCTriple.setArchName(getArchName());
-
-    TC = new toolchains::AuroraUX(getDriver(), TCTriple);
-  }
-
-  return TC;
-}
-
-// FreeBSD Host Info
-
-/// FreeBSDHostInfo -  FreeBSD host information implementation.
-class FreeBSDHostInfo : public HostInfo {
-  /// Cache of tool chains we have created.
-  mutable llvm::StringMap<ToolChain*> ToolChains;
-
-public:
-  FreeBSDHostInfo(const Driver &D, const llvm::Triple& Triple)
-    : HostInfo(D, Triple) {}
-  ~FreeBSDHostInfo();
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args,
-                                     const char *ArchName) const;
-};
-
-FreeBSDHostInfo::~FreeBSDHostInfo() {
-  for (llvm::StringMap<ToolChain*>::iterator
-         it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
-    delete it->second;
-}
-
-ToolChain *FreeBSDHostInfo::CreateToolChain(const ArgList &Args,
-                                            const char *ArchName) const {
-  assert(!ArchName &&
-         "Unexpected arch name on platform without driver driver support.");
-
-  // Automatically handle some instances of -m32/-m64 we know about.
-  std::string Arch = getArchName();
-  ArchName = Arch.c_str();
-  if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
-    if (Triple.getArch() == llvm::Triple::x86 ||
-        Triple.getArch() == llvm::Triple::x86_64) {
-      ArchName =
-        (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
-    } else if (Triple.getArch() == llvm::Triple::ppc ||
-               Triple.getArch() == llvm::Triple::ppc64) {
-      ArchName =
-        (A->getOption().matches(options::OPT_m32)) ? "powerpc" : "powerpc64";
-    }
-  }
-
-  ToolChain *&TC = ToolChains[ArchName];
-  if (!TC) {
-    llvm::Triple TCTriple(getTriple());
-    TCTriple.setArchName(ArchName);
-
-    TC = new toolchains::FreeBSD(getDriver(), TCTriple);
-  }
-
-  return TC;
-}
-
-// NetBSD Host Info
-
-/// NetBSDHostInfo -  NetBSD host information implementation.
-class NetBSDHostInfo : public HostInfo {
-  /// Cache of tool chains we have created.
-  mutable llvm::StringMap<ToolChain*> ToolChains;
-
-public:
-  NetBSDHostInfo(const Driver &D, const llvm::Triple& Triple)
-    : HostInfo(D, Triple) {}
-  ~NetBSDHostInfo();
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args,
-                                     const char *ArchName) const;
-};
-
-NetBSDHostInfo::~NetBSDHostInfo() {
-  for (llvm::StringMap<ToolChain*>::iterator
-         it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
-    delete it->second;
-}
-
-ToolChain *NetBSDHostInfo::CreateToolChain(const ArgList &Args,
-                                            const char *ArchName) const {
-  assert(!ArchName &&
-         "Unexpected arch name on platform without driver driver support.");
-
-  // Automatically handle some instances of -m32/-m64 we know about.
-  std::string Arch = getArchName();
-  ArchName = Arch.c_str();
-  if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
-    if (Triple.getArch() == llvm::Triple::x86 ||
-        Triple.getArch() == llvm::Triple::x86_64) {
-      ArchName =
-        (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
-    } else if (Triple.getArch() == llvm::Triple::ppc ||
-               Triple.getArch() == llvm::Triple::ppc64) {
-      ArchName =
-        (A->getOption().matches(options::OPT_m32)) ? "powerpc" : "powerpc64";
-    }
-  }
-  llvm::Triple TargetTriple(getTriple());
-  TargetTriple.setArchName(ArchName);
-
-  ToolChain *TC;
-
-  // XXX Cache toolchain even if -m32 is used
-  if (Arch == ArchName) {
-    TC = ToolChains[ArchName];
-    if (TC)
-      return TC;
-  }
-
-  TC = new toolchains::NetBSD(getDriver(), TargetTriple, getTriple());
-
-  return TC;
-}
-
-// Minix Host Info
-
-/// MinixHostInfo -  Minix host information implementation.
-class MinixHostInfo : public HostInfo {
-  /// Cache of tool chains we have created.
-  mutable llvm::StringMap<ToolChain*> ToolChains;
-
-public:
-  MinixHostInfo(const Driver &D, const llvm::Triple& Triple)
-    : HostInfo(D, Triple) {}
-  ~MinixHostInfo();
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args,
-                                     const char *ArchName) const;
-};
-
-MinixHostInfo::~MinixHostInfo() {
-  for (llvm::StringMap<ToolChain*>::iterator
-         it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it){
-    delete it->second;
-  }
-}
-
-ToolChain *MinixHostInfo::CreateToolChain(const ArgList &Args,
-                                            const char *ArchName) const {
-  assert(!ArchName &&
-         "Unexpected arch name on platform without driver driver support.");
-
-  std::string Arch = getArchName();
-  ArchName = Arch.c_str();
-
-  ToolChain *&TC = ToolChains[ArchName];
-  if (!TC) {
-    llvm::Triple TCTriple(getTriple());
-    TCTriple.setArchName(ArchName);
-
-    TC = new toolchains::Minix(getDriver(), TCTriple);
-  }
-
-  return TC;
-}
-
-// DragonFly Host Info
-
-/// DragonFlyHostInfo -  DragonFly host information implementation.
-class DragonFlyHostInfo : public HostInfo {
-  /// Cache of tool chains we have created.
-  mutable llvm::StringMap<ToolChain*> ToolChains;
-
-public:
-  DragonFlyHostInfo(const Driver &D, const llvm::Triple& Triple)
-    : HostInfo(D, Triple) {}
-  ~DragonFlyHostInfo();
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args,
-                                     const char *ArchName) const;
-};
-
-DragonFlyHostInfo::~DragonFlyHostInfo() {
-  for (llvm::StringMap<ToolChain*>::iterator
-         it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
-    delete it->second;
-}
-
-ToolChain *DragonFlyHostInfo::CreateToolChain(const ArgList &Args,
-                                              const char *ArchName) const {
-  assert(!ArchName &&
-         "Unexpected arch name on platform without driver driver support.");
-
-  ToolChain *&TC = ToolChains[getArchName()];
-
-  if (!TC) {
-    llvm::Triple TCTriple(getTriple());
-    TCTriple.setArchName(getArchName());
-
-    TC = new toolchains::DragonFly(getDriver(), TCTriple);
-  }
-
-  return TC;
-}
-
-// Linux Host Info
-
-/// LinuxHostInfo -  Linux host information implementation.
-class LinuxHostInfo : public HostInfo {
-  /// Cache of tool chains we have created.
-  mutable llvm::StringMap<ToolChain*> ToolChains;
-
-public:
-  LinuxHostInfo(const Driver &D, const llvm::Triple& Triple)
-    : HostInfo(D, Triple) {}
-  ~LinuxHostInfo();
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args,
-                                     const char *ArchName) const;
-};
-
-LinuxHostInfo::~LinuxHostInfo() {
-  for (llvm::StringMap<ToolChain*>::iterator
-         it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
-    delete it->second;
-}
-
-ToolChain *LinuxHostInfo::CreateToolChain(const ArgList &Args,
-                                          const char *ArchName) const {
-
-  assert(!ArchName &&
-         "Unexpected arch name on platform without driver driver support.");
-
-  // Automatically handle some instances of -m32/-m64 we know about.
-  std::string Arch = getArchName();
-  ArchName = Arch.c_str();
-  if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
-    if (Triple.getArch() == llvm::Triple::x86 ||
-        Triple.getArch() == llvm::Triple::x86_64) {
-      ArchName =
-        (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
-    } else if (Triple.getArch() == llvm::Triple::ppc ||
-               Triple.getArch() == llvm::Triple::ppc64) {
-      ArchName =
-        (A->getOption().matches(options::OPT_m32)) ? "powerpc" : "powerpc64";
-    }
-  }
-
-  ToolChain *&TC = ToolChains[ArchName];
-
-  if (!TC && !Arch.compare ("hexagon")) {
-    llvm::Triple TCTriple (getTriple());
-    TC = new toolchains::Hexagon_TC (getDriver(), TCTriple);
-  }
-
-  if (!TC) {
-    llvm::Triple TCTriple(getTriple());
-    TCTriple.setArchName(ArchName);
-
-    TC = new toolchains::Linux(getDriver(), TCTriple);
-  }
-
-  return TC;
-}
-
-// Windows Host Info
-
-/// WindowsHostInfo - Host information to use on Microsoft Windows.
-class WindowsHostInfo : public HostInfo {
-  /// Cache of tool chains we have created.
-  mutable llvm::StringMap<ToolChain*> ToolChains;
-
-public:
-  WindowsHostInfo(const Driver &D, const llvm::Triple& Triple);
-  ~WindowsHostInfo();
-
-  virtual types::ID lookupTypeForExtension(const char *Ext) const {
-    return types::lookupTypeForExtension(Ext);
-  }
-
-  virtual ToolChain *CreateToolChain(const ArgList &Args,
-                                     const char *ArchName) const;
-};
-
-WindowsHostInfo::WindowsHostInfo(const Driver &D, const llvm::Triple& Triple)
-  : HostInfo(D, Triple) {
-}
-
-WindowsHostInfo::~WindowsHostInfo() {
-  for (llvm::StringMap<ToolChain*>::iterator
-         it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
-    delete it->second;
-}
-
-ToolChain *WindowsHostInfo::CreateToolChain(const ArgList &Args,
-                                            const char *ArchName) const {
-  assert(!ArchName &&
-         "Unexpected arch name on platform without driver driver support.");
-
-  // Automatically handle some instances of -m32/-m64 we know about.
-  std::string Arch = getArchName();
-  ArchName = Arch.c_str();
-  if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
-    if (Triple.getArch() == llvm::Triple::x86 ||
-        Triple.getArch() == llvm::Triple::x86_64) {
-      ArchName =
-        (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
-    }
-  }
-
-  ToolChain *&TC = ToolChains[ArchName];
-  if (!TC) {
-    llvm::Triple TCTriple(getTriple());
-    TCTriple.setArchName(ArchName);
-
-    TC = new toolchains::Windows(getDriver(), TCTriple);
-  }
-
-  return TC;
-}
-
-// FIXME: This is a placeholder.
-class MinGWHostInfo : public UnknownHostInfo {
-public:
-  MinGWHostInfo(const Driver &D, const llvm::Triple& Triple);
-};
-
-MinGWHostInfo::MinGWHostInfo(const Driver &D, const llvm::Triple& Triple)
-  : UnknownHostInfo(D, Triple) {}
-
-} // end anon namespace
-
-const HostInfo *
-clang::driver::createAuroraUXHostInfo(const Driver &D,
-                                      const llvm::Triple& Triple){
-  return new AuroraUXHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createDarwinHostInfo(const Driver &D,
-                                    const llvm::Triple& Triple){
-  return new DarwinHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createOpenBSDHostInfo(const Driver &D,
-                                     const llvm::Triple& Triple) {
-  return new OpenBSDHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createFreeBSDHostInfo(const Driver &D,
-                                     const llvm::Triple& Triple) {
-  return new FreeBSDHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createNetBSDHostInfo(const Driver &D,
-                                     const llvm::Triple& Triple) {
-  return new NetBSDHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createMinixHostInfo(const Driver &D,
-                                     const llvm::Triple& Triple) {
-  return new MinixHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createDragonFlyHostInfo(const Driver &D,
-                                       const llvm::Triple& Triple) {
-  return new DragonFlyHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createLinuxHostInfo(const Driver &D,
-                                   const llvm::Triple& Triple) {
-  return new LinuxHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createTCEHostInfo(const Driver &D,
-                                   const llvm::Triple& Triple) {
-  return new TCEHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createWindowsHostInfo(const Driver &D,
-                                     const llvm::Triple& Triple) {
-  return new WindowsHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createMinGWHostInfo(const Driver &D,
-                                   const llvm::Triple& Triple) {
-  return new MinGWHostInfo(D, Triple);
-}
-
-const HostInfo *
-clang::driver::createUnknownHostInfo(const Driver &D,
-                                     const llvm::Triple& Triple) {
-  return new UnknownHostInfo(D, Triple);
-}
diff --git a/clang/lib/Driver/Tools.cpp b/clang/lib/Driver/Tools.cpp
index 7254a364df2..ed3a9eba3f0 100644
--- a/clang/lib/Driver/Tools.cpp
+++ b/clang/lib/Driver/Tools.cpp
@@ -16,7 +16,6 @@
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Job.h"
-#include "clang/Driver/HostInfo.h"
 #include "clang/Driver/ObjCRuntime.h"
 #include "clang/Driver/Option.h"
 #include "clang/Driver/Options.h"