contrib/llvm/tools/clang/lib/Driver/HostInfo.cpp

   1 //===--- HostInfo.cpp - Host specific information -------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "clang/Driver/HostInfo.h"
  11
  12 #include "clang/Driver/Arg.h"
  13 #include "clang/Driver/ArgList.h"
  14 #include "clang/Driver/Driver.h"
  15 #include "clang/Driver/DriverDiagnostic.h"
  16 #include "clang/Driver/Option.h"
  17 #include "clang/Driver/Options.h"
  18
  19 #include "llvm/ADT/StringMap.h"
  20 #include "llvm/Support/Compiler.h"
  21
  22 #include "ToolChains.h"
  23
  24 #include <cassert>
  25
  26 using namespace clang::driver;
  27
  28 HostInfo::HostInfo(const Driver &D, const llvm::Triple &_Triple)
  29   : TheDriver(D), Triple(_Triple) {
  30 }
  31
  32 HostInfo::~HostInfo() {
  33 }
  34
  35 namespace {
  36
  37 // Darwin Host Info
  38
  39 /// DarwinHostInfo - Darwin host information implementation.
  40 class DarwinHostInfo : public HostInfo {
  41   /// Cache of tool chains we have created.
  42   mutable llvm::DenseMap<unsigned, ToolChain*> ToolChains;
  43
  44 public:
  45   DarwinHostInfo(const Driver &D, const llvm::Triple &Triple);
  46   ~DarwinHostInfo();
  47
  48   virtual bool useDriverDriver() const;
  49
  50   virtual ToolChain *CreateToolChain(const ArgList &Args,
  51                                      const char *ArchName) const;
  52 };
  53
  54 DarwinHostInfo::DarwinHostInfo(const Driver &D, const llvm::Triple& Triple)
  55   : HostInfo(D, Triple) {
  56 }
  57
  58 DarwinHostInfo::~DarwinHostInfo() {
  59   for (llvm::DenseMap<unsigned, ToolChain*>::iterator
  60          it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
  61     delete it->second;
  62 }
  63
  64 bool DarwinHostInfo::useDriverDriver() const {
  65   return true;
  66 }
  67
  68 ToolChain *DarwinHostInfo::CreateToolChain(const ArgList &Args,
  69                                            const char *ArchName) const {
  70   llvm::Triple::ArchType Arch;
  71
  72   if (!ArchName) {
  73     // If we aren't looking for a specific arch, infer the default architecture
  74     // based on -arch and -m32/-m64 command line options.
  75     if (Arg *A = Args.getLastArg(options::OPT_arch)) {
  76       // The gcc driver behavior with multiple -arch flags wasn't consistent for
  77       // things which rely on a default architecture. We just use the last -arch
  78       // to find the default tool chain (assuming it is valid).
  79       Arch = llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args));
  80
  81       // If it was invalid just use the host, we will reject this command line
  82       // later.
  83       if (Arch == llvm::Triple::UnknownArch)
  84         Arch = getTriple().getArch();
  85     } else {
  86       // Otherwise default to the arch of the host.
  87       Arch = getTriple().getArch();
  88     }
  89
  90     // Honor -m32 and -m64 when finding the default tool chain.
  91     //
  92     // FIXME: Should this information be in llvm::Triple?
  93     if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
  94       if (A->getOption().matches(options::OPT_m32)) {
  95         if (Arch == llvm::Triple::x86_64)
  96           Arch = llvm::Triple::x86;
  97         if (Arch == llvm::Triple::ppc64)
  98           Arch = llvm::Triple::ppc;
  99       } else {
 100         if (Arch == llvm::Triple::x86)
 101           Arch = llvm::Triple::x86_64;
 102         if (Arch == llvm::Triple::ppc)
 103           Arch = llvm::Triple::ppc64;
 104       }
 105     }
 106   } else
 107     Arch = llvm::Triple::getArchTypeForDarwinArchName(ArchName);
 108
 109   assert(Arch != llvm::Triple::UnknownArch && "Unexpected arch!");
 110   ToolChain *&TC = ToolChains[Arch];
 111   if (!TC) {
 112     llvm::Triple TCTriple(getTriple());
 113     TCTriple.setArch(Arch);
 114
 115     // If we recognized the arch, match it to the toolchains we support.
 116     if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64 ||
 117         Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
 118       TC = new toolchains::DarwinClang(*this, TCTriple);
 119     } else
 120       TC = new toolchains::Darwin_Generic_GCC(*this, TCTriple);
 121   }
 122
 123   return TC;
 124 }
 125
 126 // TCE Host Info
 127
 128 /// TCEHostInfo - TCE host information implementation (see http://tce.cs.tut.fi)
 129 class TCEHostInfo : public HostInfo {
 130
 131 public:
 132   TCEHostInfo(const Driver &D, const llvm::Triple &Triple);
 133   ~TCEHostInfo() {}
 134
 135   virtual bool useDriverDriver() const;
 136
 137   virtual ToolChain *CreateToolChain(const ArgList &Args,
 138                                      const char *ArchName) const;
 139 };
 140
 141 TCEHostInfo::TCEHostInfo(const Driver &D, const llvm::Triple& Triple)
 142   : HostInfo(D, Triple) {
 143 }
 144
 145 bool TCEHostInfo::useDriverDriver() const {
 146   return false;
 147 }
 148
 149 ToolChain *TCEHostInfo::CreateToolChain(const ArgList &Args,
 150                                         const char *ArchName) const {
 151   llvm::Triple TCTriple(getTriple());
 152 //  TCTriple.setArchName(ArchName);
 153   return new toolchains::TCEToolChain(*this, TCTriple);
 154 }
 155
 156
 157 // Unknown Host Info
 158
 159 /// UnknownHostInfo - Generic host information to use for unknown hosts.
 160 class UnknownHostInfo : public HostInfo {
 161   /// Cache of tool chains we have created.
 162   mutable llvm::StringMap<ToolChain*> ToolChains;
 163
 164 public:
 165   UnknownHostInfo(const Driver &D, const llvm::Triple& Triple);
 166   ~UnknownHostInfo();
 167
 168   virtual bool useDriverDriver() const;
 169
 170   virtual ToolChain *CreateToolChain(const ArgList &Args,
 171                                      const char *ArchName) const;
 172 };
 173
 174 UnknownHostInfo::UnknownHostInfo(const Driver &D, const llvm::Triple& Triple)
 175   : HostInfo(D, Triple) {
 176 }
 177
 178 UnknownHostInfo::~UnknownHostInfo() {
 179   for (llvm::StringMap<ToolChain*>::iterator
 180          it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
 181     delete it->second;
 182 }
 183
 184 bool UnknownHostInfo::useDriverDriver() const {
 185   return false;
 186 }
 187
 188 ToolChain *UnknownHostInfo::CreateToolChain(const ArgList &Args,
 189                                             const char *ArchName) const {
 190   assert(!ArchName &&
 191          "Unexpected arch name on platform without driver support.");
 192
 193   // Automatically handle some instances of -m32/-m64 we know about.
 194   std::string Arch = getArchName();
 195   ArchName = Arch.c_str();
 196   if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
 197     if (Triple.getArch() == llvm::Triple::x86 ||
 198         Triple.getArch() == llvm::Triple::x86_64) {
 199       ArchName =
 200         (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
 201     } else if (Triple.getArch() == llvm::Triple::ppc ||
 202                Triple.getArch() == llvm::Triple::ppc64) {
 203       ArchName =
 204         (A->getOption().matches(options::OPT_m32)) ? "powerpc" : "powerpc64";
 205     }
 206   }
 207
 208   ToolChain *&TC = ToolChains[ArchName];
 209   if (!TC) {
 210     llvm::Triple TCTriple(getTriple());
 211     TCTriple.setArchName(ArchName);
 212
 213     TC = new toolchains::Generic_GCC(*this, TCTriple);
 214   }
 215
 216   return TC;
 217 }
 218
 219 // OpenBSD Host Info
 220
 221 /// OpenBSDHostInfo -  OpenBSD host information implementation.
 222 class OpenBSDHostInfo : public HostInfo {
 223   /// Cache of tool chains we have created.
 224   mutable llvm::StringMap<ToolChain*> ToolChains;
 225
 226 public:
 227   OpenBSDHostInfo(const Driver &D, const llvm::Triple& Triple)
 228     : HostInfo(D, Triple) {}
 229   ~OpenBSDHostInfo();
 230
 231   virtual bool useDriverDriver() const;
 232
 233   virtual ToolChain *CreateToolChain(const ArgList &Args,
 234                                      const char *ArchName) const;
 235 };
 236
 237 OpenBSDHostInfo::~OpenBSDHostInfo() {
 238   for (llvm::StringMap<ToolChain*>::iterator
 239          it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
 240     delete it->second;
 241 }
 242
 243 bool OpenBSDHostInfo::useDriverDriver() const {
 244   return false;
 245 }
 246
 247 ToolChain *OpenBSDHostInfo::CreateToolChain(const ArgList &Args,
 248                                             const char *ArchName) const {
 249   assert(!ArchName &&
 250          "Unexpected arch name on platform without driver driver support.");
 251
 252   std::string Arch = getArchName();
 253   ArchName = Arch.c_str();
 254
 255   ToolChain *&TC = ToolChains[ArchName];
 256   if (!TC) {
 257     llvm::Triple TCTriple(getTriple());
 258     TCTriple.setArchName(ArchName);
 259
 260     TC = new toolchains::OpenBSD(*this, TCTriple);
 261   }
 262
 263   return TC;
 264 }
 265
 266 // AuroraUX Host Info
 267
 268 /// AuroraUXHostInfo - AuroraUX host information implementation.
 269 class AuroraUXHostInfo : public HostInfo {
 270   /// Cache of tool chains we have created.
 271   mutable llvm::StringMap<ToolChain*> ToolChains;
 272
 273 public:
 274   AuroraUXHostInfo(const Driver &D, const llvm::Triple& Triple)
 275     : HostInfo(D, Triple) {}
 276   ~AuroraUXHostInfo();
 277
 278   virtual bool useDriverDriver() const;
 279
 280   virtual ToolChain *CreateToolChain(const ArgList &Args,
 281                                      const char *ArchName) const;
 282 };
 283
 284 AuroraUXHostInfo::~AuroraUXHostInfo() {
 285   for (llvm::StringMap<ToolChain*>::iterator
 286          it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
 287     delete it->second;
 288 }
 289
 290 bool AuroraUXHostInfo::useDriverDriver() const {
 291   return false;
 292 }
 293
 294 ToolChain *AuroraUXHostInfo::CreateToolChain(const ArgList &Args,
 295                                              const char *ArchName) const {
 296   assert(!ArchName &&
 297          "Unexpected arch name on platform without driver driver support.");
 298
 299   ToolChain *&TC = ToolChains[getArchName()];
 300
 301   if (!TC) {
 302     llvm::Triple TCTriple(getTriple());
 303     TCTriple.setArchName(getArchName());
 304
 305     TC = new toolchains::AuroraUX(*this, TCTriple);
 306   }
 307
 308   return TC;
 309 }
 310
 311 // FreeBSD Host Info
 312
 313 /// FreeBSDHostInfo -  FreeBSD host information implementation.
 314 class FreeBSDHostInfo : public HostInfo {
 315   /// Cache of tool chains we have created.
 316   mutable llvm::StringMap<ToolChain*> ToolChains;
 317
 318 public:
 319   FreeBSDHostInfo(const Driver &D, const llvm::Triple& Triple)
 320     : HostInfo(D, Triple) {}
 321   ~FreeBSDHostInfo();
 322
 323   virtual bool useDriverDriver() const;
 324
 325   virtual ToolChain *CreateToolChain(const ArgList &Args,
 326                                      const char *ArchName) const;
 327 };
 328
 329 FreeBSDHostInfo::~FreeBSDHostInfo() {
 330   for (llvm::StringMap<ToolChain*>::iterator
 331          it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
 332     delete it->second;
 333 }
 334
 335 bool FreeBSDHostInfo::useDriverDriver() const {
 336   return false;
 337 }
 338
 339 ToolChain *FreeBSDHostInfo::CreateToolChain(const ArgList &Args,
 340                                             const char *ArchName) const {
 341   assert(!ArchName &&
 342          "Unexpected arch name on platform without driver driver support.");
 343
 344   // Automatically handle some instances of -m32/-m64 we know about.
 345   std::string Arch = getArchName();
 346   ArchName = Arch.c_str();
 347   if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
 348     if (Triple.getArch() == llvm::Triple::x86 ||
 349         Triple.getArch() == llvm::Triple::x86_64) {
 350       ArchName =
 351         (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
 352     } else if (Triple.getArch() == llvm::Triple::ppc ||
 353                Triple.getArch() == llvm::Triple::ppc64) {
 354       ArchName =
 355         (A->getOption().matches(options::OPT_m32)) ? "powerpc" : "powerpc64";
 356     }
 357   }
 358
 359   ToolChain *&TC = ToolChains[ArchName];
 360   if (!TC) {
 361     llvm::Triple TCTriple(getTriple());
 362     TCTriple.setArchName(ArchName);
 363
 364     TC = new toolchains::FreeBSD(*this, TCTriple);
 365   }
 366
 367   return TC;
 368 }
 369
 370 // NetBSD Host Info
 371
 372 /// NetBSDHostInfo -  NetBSD host information implementation.
 373 class NetBSDHostInfo : public HostInfo {
 374   /// Cache of tool chains we have created.
 375   mutable llvm::StringMap<ToolChain*> ToolChains;
 376
 377 public:
 378   NetBSDHostInfo(const Driver &D, const llvm::Triple& Triple)
 379     : HostInfo(D, Triple) {}
 380   ~NetBSDHostInfo();
 381
 382   virtual bool useDriverDriver() const;
 383
 384   virtual ToolChain *CreateToolChain(const ArgList &Args,
 385                                      const char *ArchName) const;
 386 };
 387
 388 NetBSDHostInfo::~NetBSDHostInfo() {
 389   for (llvm::StringMap<ToolChain*>::iterator
 390          it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
 391     delete it->second;
 392 }
 393
 394 bool NetBSDHostInfo::useDriverDriver() const {
 395   return false;
 396 }
 397
 398 ToolChain *NetBSDHostInfo::CreateToolChain(const ArgList &Args,
 399                                             const char *ArchName) const {
 400   assert(!ArchName &&
 401          "Unexpected arch name on platform without driver driver support.");
 402
 403   // Automatically handle some instances of -m32/-m64 we know about.
 404   std::string Arch = getArchName();
 405   ArchName = Arch.c_str();
 406   if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
 407     if (Triple.getArch() == llvm::Triple::x86 ||
 408         Triple.getArch() == llvm::Triple::x86_64) {
 409       ArchName =
 410         (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
 411     } else if (Triple.getArch() == llvm::Triple::ppc ||
 412                Triple.getArch() == llvm::Triple::ppc64) {
 413       ArchName =
 414         (A->getOption().matches(options::OPT_m32)) ? "powerpc" : "powerpc64";
 415     }
 416   }
 417   llvm::Triple TargetTriple(getTriple());
 418   TargetTriple.setArchName(ArchName);
 419
 420   ToolChain *TC;
 421
 422   // XXX Cache toolchain even if -m32 is used
 423   if (Arch == ArchName) {
 424     TC = ToolChains[ArchName];
 425     if (TC)
 426       return TC;
 427   }
 428
 429   TC = new toolchains::NetBSD(*this, TargetTriple, getTriple());
 430
 431   return TC;
 432 }
 433
 434 // Minix Host Info
 435
 436 /// MinixHostInfo -  Minix host information implementation.
 437 class MinixHostInfo : public HostInfo {
 438   /// Cache of tool chains we have created.
 439   mutable llvm::StringMap<ToolChain*> ToolChains;
 440
 441 public:
 442   MinixHostInfo(const Driver &D, const llvm::Triple& Triple)
 443     : HostInfo(D, Triple) {}
 444   ~MinixHostInfo();
 445
 446   virtual bool useDriverDriver() const;
 447
 448   virtual ToolChain *CreateToolChain(const ArgList &Args,
 449                                      const char *ArchName) const;
 450 };
 451
 452 MinixHostInfo::~MinixHostInfo() {
 453   for (llvm::StringMap<ToolChain*>::iterator
 454          it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it){
 455     delete it->second;
 456   }
 457 }
 458
 459 bool MinixHostInfo::useDriverDriver() const {
 460   return false;
 461 }
 462
 463 ToolChain *MinixHostInfo::CreateToolChain(const ArgList &Args,
 464                                             const char *ArchName) const {
 465   assert(!ArchName &&
 466          "Unexpected arch name on platform without driver driver support.");
 467
 468   std::string Arch = getArchName();
 469   ArchName = Arch.c_str();
 470
 471   ToolChain *&TC = ToolChains[ArchName];
 472   if (!TC) {
 473     llvm::Triple TCTriple(getTriple());
 474     TCTriple.setArchName(ArchName);
 475
 476     TC = new toolchains::Minix(*this, TCTriple);
 477   }
 478
 479   return TC;
 480 }
 481
 482 // DragonFly Host Info
 483
 484 /// DragonFlyHostInfo -  DragonFly host information implementation.
 485 class DragonFlyHostInfo : public HostInfo {
 486   /// Cache of tool chains we have created.
 487   mutable llvm::StringMap<ToolChain*> ToolChains;
 488
 489 public:
 490   DragonFlyHostInfo(const Driver &D, const llvm::Triple& Triple)
 491     : HostInfo(D, Triple) {}
 492   ~DragonFlyHostInfo();
 493
 494   virtual bool useDriverDriver() const;
 495
 496   virtual ToolChain *CreateToolChain(const ArgList &Args,
 497                                      const char *ArchName) const;
 498 };
 499
 500 DragonFlyHostInfo::~DragonFlyHostInfo() {
 501   for (llvm::StringMap<ToolChain*>::iterator
 502          it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
 503     delete it->second;
 504 }
 505
 506 bool DragonFlyHostInfo::useDriverDriver() const {
 507   return false;
 508 }
 509
 510 ToolChain *DragonFlyHostInfo::CreateToolChain(const ArgList &Args,
 511                                               const char *ArchName) const {
 512   assert(!ArchName &&
 513          "Unexpected arch name on platform without driver driver support.");
 514
 515   ToolChain *&TC = ToolChains[getArchName()];
 516
 517   if (!TC) {
 518     llvm::Triple TCTriple(getTriple());
 519     TCTriple.setArchName(getArchName());
 520
 521     TC = new toolchains::DragonFly(*this, TCTriple);
 522   }
 523
 524   return TC;
 525 }
 526
 527 // Linux Host Info
 528
 529 /// LinuxHostInfo -  Linux host information implementation.
 530 class LinuxHostInfo : public HostInfo {
 531   /// Cache of tool chains we have created.
 532   mutable llvm::StringMap<ToolChain*> ToolChains;
 533
 534 public:
 535   LinuxHostInfo(const Driver &D, const llvm::Triple& Triple)
 536     : HostInfo(D, Triple) {}
 537   ~LinuxHostInfo();
 538
 539   virtual bool useDriverDriver() const;
 540
 541   virtual ToolChain *CreateToolChain(const ArgList &Args,
 542                                      const char *ArchName) const;
 543 };
 544
 545 LinuxHostInfo::~LinuxHostInfo() {
 546   for (llvm::StringMap<ToolChain*>::iterator
 547          it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
 548     delete it->second;
 549 }
 550
 551 bool LinuxHostInfo::useDriverDriver() const {
 552   return false;
 553 }
 554
 555 ToolChain *LinuxHostInfo::CreateToolChain(const ArgList &Args,
 556                                           const char *ArchName) const {
 557
 558   assert(!ArchName &&
 559          "Unexpected arch name on platform without driver driver support.");
 560
 561   // Automatically handle some instances of -m32/-m64 we know about.
 562   std::string Arch = getArchName();
 563   ArchName = Arch.c_str();
 564   if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
 565     if (Triple.getArch() == llvm::Triple::x86 ||
 566         Triple.getArch() == llvm::Triple::x86_64) {
 567       ArchName =
 568         (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
 569     } else if (Triple.getArch() == llvm::Triple::ppc ||
 570                Triple.getArch() == llvm::Triple::ppc64) {
 571       ArchName =
 572         (A->getOption().matches(options::OPT_m32)) ? "powerpc" : "powerpc64";
 573     }
 574   }
 575
 576   ToolChain *&TC = ToolChains[ArchName];
 577
 578   if (!TC) {
 579     llvm::Triple TCTriple(getTriple());
 580     TCTriple.setArchName(ArchName);
 581
 582     TC = new toolchains::Linux(*this, TCTriple);
 583   }
 584
 585   return TC;
 586 }
 587
 588 // Windows Host Info
 589
 590 /// WindowsHostInfo - Host information to use on Microsoft Windows.
 591 class WindowsHostInfo : public HostInfo {
 592   /// Cache of tool chains we have created.
 593   mutable llvm::StringMap<ToolChain*> ToolChains;
 594
 595 public:
 596   WindowsHostInfo(const Driver &D, const llvm::Triple& Triple);
 597   ~WindowsHostInfo();
 598
 599   virtual bool useDriverDriver() const;
 600
 601   virtual types::ID lookupTypeForExtension(const char *Ext) const {
 602     return types::lookupTypeForExtension(Ext);
 603   }
 604
 605   virtual ToolChain *CreateToolChain(const ArgList &Args,
 606                                      const char *ArchName) const;
 607 };
 608
 609 WindowsHostInfo::WindowsHostInfo(const Driver &D, const llvm::Triple& Triple)
 610   : HostInfo(D, Triple) {
 611 }
 612
 613 WindowsHostInfo::~WindowsHostInfo() {
 614   for (llvm::StringMap<ToolChain*>::iterator
 615          it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
 616     delete it->second;
 617 }
 618
 619 bool WindowsHostInfo::useDriverDriver() const {
 620   return false;
 621 }
 622
 623 ToolChain *WindowsHostInfo::CreateToolChain(const ArgList &Args,
 624                                             const char *ArchName) const {
 625   assert(!ArchName &&
 626          "Unexpected arch name on platform without driver driver support.");
 627
 628   // Automatically handle some instances of -m32/-m64 we know about.
 629   std::string Arch = getArchName();
 630   ArchName = Arch.c_str();
 631   if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
 632     if (Triple.getArch() == llvm::Triple::x86 ||
 633         Triple.getArch() == llvm::Triple::x86_64) {
 634       ArchName =
 635         (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
 636     }
 637   }
 638
 639   ToolChain *&TC = ToolChains[ArchName];
 640   if (!TC) {
 641     llvm::Triple TCTriple(getTriple());
 642     TCTriple.setArchName(ArchName);
 643
 644     TC = new toolchains::Windows(*this, TCTriple);
 645   }
 646
 647   return TC;
 648 }
 649
 650 // FIXME: This is a placeholder.
 651 class MinGWHostInfo : public UnknownHostInfo {
 652 public:
 653   MinGWHostInfo(const Driver &D, const llvm::Triple& Triple);
 654 };
 655
 656 MinGWHostInfo::MinGWHostInfo(const Driver &D, const llvm::Triple& Triple)
 657   : UnknownHostInfo(D, Triple) {}
 658
 659 } // end anon namespace
 660
 661 const HostInfo *
 662 clang::driver::createAuroraUXHostInfo(const Driver &D,
 663                                       const llvm::Triple& Triple){
 664   return new AuroraUXHostInfo(D, Triple);
 665 }
 666
 667 const HostInfo *
 668 clang::driver::createDarwinHostInfo(const Driver &D,
 669                                     const llvm::Triple& Triple){
 670   return new DarwinHostInfo(D, Triple);
 671 }
 672
 673 const HostInfo *
 674 clang::driver::createOpenBSDHostInfo(const Driver &D,
 675                                      const llvm::Triple& Triple) {
 676   return new OpenBSDHostInfo(D, Triple);
 677 }
 678
 679 const HostInfo *
 680 clang::driver::createFreeBSDHostInfo(const Driver &D,
 681                                      const llvm::Triple& Triple) {
 682   return new FreeBSDHostInfo(D, Triple);
 683 }
 684
 685 const HostInfo *
 686 clang::driver::createNetBSDHostInfo(const Driver &D,
 687                                      const llvm::Triple& Triple) {
 688   return new NetBSDHostInfo(D, Triple);
 689 }
 690
 691 const HostInfo *
 692 clang::driver::createMinixHostInfo(const Driver &D,
 693                                      const llvm::Triple& Triple) {
 694   return new MinixHostInfo(D, Triple);
 695 }
 696
 697 const HostInfo *
 698 clang::driver::createDragonFlyHostInfo(const Driver &D,
 699                                        const llvm::Triple& Triple) {
 700   return new DragonFlyHostInfo(D, Triple);
 701 }
 702
 703 const HostInfo *
 704 clang::driver::createLinuxHostInfo(const Driver &D,
 705                                    const llvm::Triple& Triple) {
 706   return new LinuxHostInfo(D, Triple);
 707 }
 708
 709 const HostInfo *
 710 clang::driver::createTCEHostInfo(const Driver &D,
 711                                    const llvm::Triple& Triple) {
 712   return new TCEHostInfo(D, Triple);
 713 }
 714
 715 const HostInfo *
 716 clang::driver::createWindowsHostInfo(const Driver &D,
 717                                      const llvm::Triple& Triple) {
 718   return new WindowsHostInfo(D, Triple);
 719 }
 720
 721 const HostInfo *
 722 clang::driver::createMinGWHostInfo(const Driver &D,
 723                                    const llvm::Triple& Triple) {
 724   return new MinGWHostInfo(D, Triple);
 725 }
 726
 727 const HostInfo *
 728 clang::driver::createUnknownHostInfo(const Driver &D,
 729                                      const llvm::Triple& Triple) {
 730   return new UnknownHostInfo(D, Triple);
 731 }