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

1 files changed, 0 insertions, 670 deletions

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);
-}