Home | History | Annotate | Download | only in Driver 
      1 //===--- ToolChains.cpp - ToolChain Implementations -----------------------===//
      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 "ToolChains.h"
     11 
     12 #ifdef HAVE_CLANG_CONFIG_H
     13 # include "clang/Config/config.h"
     14 #endif
     15 
     16 #include "clang/Driver/Arg.h"
     17 #include "clang/Driver/ArgList.h"
     18 #include "clang/Driver/Compilation.h"
     19 #include "clang/Driver/Driver.h"
     20 #include "clang/Driver/DriverDiagnostic.h"
     21 #include "clang/Driver/HostInfo.h"
     22 #include "clang/Driver/ObjCRuntime.h"
     23 #include "clang/Driver/OptTable.h"
     24 #include "clang/Driver/Option.h"
     25 #include "clang/Driver/Options.h"
     26 #include "clang/Basic/Version.h"
     27 
     28 #include "llvm/ADT/SmallString.h"
     29 #include "llvm/ADT/StringExtras.h"
     30 #include "llvm/ADT/StringSwitch.h"
     31 #include "llvm/ADT/STLExtras.h"
     32 #include "llvm/Support/ErrorHandling.h"
     33 #include "llvm/Support/FileSystem.h"
     34 #include "llvm/Support/MemoryBuffer.h"
     35 #include "llvm/Support/raw_ostream.h"
     36 #include "llvm/Support/Path.h"
     37 #include "llvm/Support/system_error.h"
     38 
     39 #include <cstdlib> // ::getenv
     40 
     41 #include "llvm/Config/config.h" // for CXX_INCLUDE_ROOT
     42 
     43 using namespace clang::driver;
     44 using namespace clang::driver::toolchains;
     45 using namespace clang;
     46 
     47 /// Darwin - Darwin tool chain for i386 and x86_64.
     48 
     49 Darwin::Darwin(const HostInfo &Host, const llvm::Triple& Triple)
     50   : ToolChain(Host, Triple), TargetInitialized(false),
     51     ARCRuntimeForSimulator(ARCSimulator_None),
     52     LibCXXForSimulator(LibCXXSimulator_None)
     53 {
     54   // Compute the initial Darwin version based on the host.
     55   bool HadExtra;
     56   std::string OSName = Triple.getOSName();
     57   if (!Driver::GetReleaseVersion(&OSName.c_str()[6],
     58                                  DarwinVersion[0], DarwinVersion[1],
     59                                  DarwinVersion[2], HadExtra))
     60     getDriver().Diag(diag::err_drv_invalid_darwin_version) << OSName;
     61 
     62   llvm::raw_string_ostream(MacosxVersionMin)
     63     << "10." << std::max(0, (int)DarwinVersion[0] - 4) << '.'
     64     << DarwinVersion[1];
     65 }
     66 
     67 types::ID Darwin::LookupTypeForExtension(const char *Ext) const {
     68   types::ID Ty = types::lookupTypeForExtension(Ext);
     69 
     70   // Darwin always preprocesses assembly files (unless -x is used explicitly).
     71   if (Ty == types::TY_PP_Asm)
     72     return types::TY_Asm;
     73 
     74   return Ty;
     75 }
     76 
     77 bool Darwin::HasNativeLLVMSupport() const {
     78   return true;
     79 }
     80 
     81 bool Darwin::hasARCRuntime() const {
     82   // FIXME: Remove this once there is a proper way to detect an ARC runtime
     83   // for the simulator.
     84   switch (ARCRuntimeForSimulator) {
     85   case ARCSimulator_None:
     86     break;
     87   case ARCSimulator_HasARCRuntime:
     88     return true;
     89   case ARCSimulator_NoARCRuntime:
     90     return false;
     91   }
     92 
     93   if (isTargetIPhoneOS())
     94     return !isIPhoneOSVersionLT(5);
     95   else
     96     return !isMacosxVersionLT(10, 7);
     97 }
     98 
     99 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
    100 void Darwin::configureObjCRuntime(ObjCRuntime &runtime) const {
    101   if (runtime.getKind() != ObjCRuntime::NeXT)
    102     return ToolChain::configureObjCRuntime(runtime);
    103 
    104   runtime.HasARC = runtime.HasWeak = hasARCRuntime();
    105 
    106   // So far, objc_terminate is only available in iOS 5.
    107   // FIXME: do the simulator logic properly.
    108   if (!ARCRuntimeForSimulator && isTargetIPhoneOS())
    109     runtime.HasTerminate = !isIPhoneOSVersionLT(5);
    110   else
    111     runtime.HasTerminate = false;
    112 }
    113 
    114 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
    115 bool Darwin::hasBlocksRuntime() const {
    116   if (isTargetIPhoneOS())
    117     return !isIPhoneOSVersionLT(3, 2);
    118   else
    119     return !isMacosxVersionLT(10, 6);
    120 }
    121 
    122 static const char *GetArmArchForMArch(StringRef Value) {
    123   return llvm::StringSwitch<const char*>(Value)
    124     .Case("armv6k", "armv6")
    125     .Case("armv5tej", "armv5")
    126     .Case("xscale", "xscale")
    127     .Case("armv4t", "armv4t")
    128     .Case("armv7", "armv7")
    129     .Cases("armv7a", "armv7-a", "armv7")
    130     .Cases("armv7r", "armv7-r", "armv7")
    131     .Cases("armv7m", "armv7-m", "armv7")
    132     .Default(0);
    133 }
    134 
    135 static const char *GetArmArchForMCpu(StringRef Value) {
    136   return llvm::StringSwitch<const char *>(Value)
    137     .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "arm926ej-s","armv5")
    138     .Cases("arm10e", "arm10tdmi", "armv5")
    139     .Cases("arm1020t", "arm1020e", "arm1022e", "arm1026ej-s", "armv5")
    140     .Case("xscale", "xscale")
    141     .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s",
    142            "arm1176jzf-s", "cortex-m0", "armv6")
    143     .Cases("cortex-a8", "cortex-r4", "cortex-m3", "cortex-a9", "armv7")
    144     .Default(0);
    145 }
    146 
    147 StringRef Darwin::getDarwinArchName(const ArgList &Args) const {
    148   switch (getTriple().getArch()) {
    149   default:
    150     return getArchName();
    151 
    152   case llvm::Triple::thumb:
    153   case llvm::Triple::arm: {
    154     if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
    155       if (const char *Arch = GetArmArchForMArch(A->getValue(Args)))
    156         return Arch;
    157 
    158     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
    159       if (const char *Arch = GetArmArchForMCpu(A->getValue(Args)))
    160         return Arch;
    161 
    162     return "arm";
    163   }
    164   }
    165 }
    166 
    167 Darwin::~Darwin() {
    168   // Free tool implementations.
    169   for (llvm::DenseMap<unsigned, Tool*>::iterator
    170          it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
    171     delete it->second;
    172 }
    173 
    174 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
    175                                                 types::ID InputType) const {
    176   llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
    177 
    178   // If the target isn't initialized (e.g., an unknown Darwin platform, return
    179   // the default triple).
    180   if (!isTargetInitialized())
    181     return Triple.getTriple();
    182 
    183   unsigned Version[3];
    184   getTargetVersion(Version);
    185 
    186   llvm::SmallString<16> Str;
    187   llvm::raw_svector_ostream(Str)
    188     << (isTargetIPhoneOS() ? "ios" : "macosx")
    189     << Version[0] << "." << Version[1] << "." << Version[2];
    190   Triple.setOSName(Str.str());
    191 
    192   return Triple.getTriple();
    193 }
    194 
    195 Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA,
    196                          const ActionList &Inputs) const {
    197   Action::ActionClass Key;
    198 
    199   if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) {
    200     // Fallback to llvm-gcc for i386 kext compiles, we don't support that ABI.
    201     if (Inputs.size() == 1 &&
    202         types::isCXX(Inputs[0]->getType()) &&
    203         getTriple().isOSDarwin() &&
    204         getTriple().getArch() == llvm::Triple::x86 &&
    205         (C.getArgs().getLastArg(options::OPT_fapple_kext) ||
    206          C.getArgs().getLastArg(options::OPT_mkernel)))
    207       Key = JA.getKind();
    208     else
    209       Key = Action::AnalyzeJobClass;
    210   } else
    211     Key = JA.getKind();
    212 
    213   // FIXME: This doesn't belong here, but ideally we will support static soon
    214   // anyway.
    215   bool HasStatic = (C.getArgs().hasArg(options::OPT_mkernel) ||
    216                     C.getArgs().hasArg(options::OPT_static) ||
    217                     C.getArgs().hasArg(options::OPT_fapple_kext));
    218   bool IsIADefault = IsIntegratedAssemblerDefault() && !HasStatic;
    219   bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
    220                                              options::OPT_no_integrated_as,
    221                                              IsIADefault);
    222 
    223   Tool *&T = Tools[Key];
    224   if (!T) {
    225     switch (Key) {
    226     case Action::InputClass:
    227     case Action::BindArchClass:
    228       llvm_unreachable("Invalid tool kind.");
    229     case Action::PreprocessJobClass:
    230       T = new tools::darwin::Preprocess(*this); break;
    231     case Action::AnalyzeJobClass:
    232       T = new tools::Clang(*this); break;
    233     case Action::PrecompileJobClass:
    234     case Action::CompileJobClass:
    235       T = new tools::darwin::Compile(*this); break;
    236     case Action::AssembleJobClass: {
    237       if (UseIntegratedAs)
    238         T = new tools::ClangAs(*this);
    239       else
    240         T = new tools::darwin::Assemble(*this);
    241       break;
    242     }
    243     case Action::LinkJobClass:
    244       T = new tools::darwin::Link(*this); break;
    245     case Action::LipoJobClass:
    246       T = new tools::darwin::Lipo(*this); break;
    247     case Action::DsymutilJobClass:
    248       T = new tools::darwin::Dsymutil(*this); break;
    249     case Action::VerifyJobClass:
    250       T = new tools::darwin::VerifyDebug(*this); break;
    251     }
    252   }
    253 
    254   return *T;
    255 }
    256 
    257 
    258 DarwinClang::DarwinClang(const HostInfo &Host, const llvm::Triple& Triple)
    259   : Darwin(Host, Triple)
    260 {
    261   getProgramPaths().push_back(getDriver().getInstalledDir());
    262   if (getDriver().getInstalledDir() != getDriver().Dir)
    263     getProgramPaths().push_back(getDriver().Dir);
    264 
    265   // We expect 'as', 'ld', etc. to be adjacent to our install dir.
    266   getProgramPaths().push_back(getDriver().getInstalledDir());
    267   if (getDriver().getInstalledDir() != getDriver().Dir)
    268     getProgramPaths().push_back(getDriver().Dir);
    269 
    270   // For fallback, we need to know how to find the GCC cc1 executables, so we
    271   // also add the GCC libexec paths. This is legacy code that can be removed
    272   // once fallback is no longer useful.
    273   AddGCCLibexecPath(DarwinVersion[0]);
    274   AddGCCLibexecPath(DarwinVersion[0] - 2);
    275   AddGCCLibexecPath(DarwinVersion[0] - 1);
    276   AddGCCLibexecPath(DarwinVersion[0] + 1);
    277   AddGCCLibexecPath(DarwinVersion[0] + 2);
    278 }
    279 
    280 void DarwinClang::AddGCCLibexecPath(unsigned darwinVersion) {
    281   std::string ToolChainDir = "i686-apple-darwin";
    282   ToolChainDir += llvm::utostr(darwinVersion);
    283   ToolChainDir += "/4.2.1";
    284 
    285   std::string Path = getDriver().Dir;
    286   Path += "/../llvm-gcc-4.2/libexec/gcc/";
    287   Path += ToolChainDir;
    288   getProgramPaths().push_back(Path);
    289 
    290   Path = "/usr/llvm-gcc-4.2/libexec/gcc/";
    291   Path += ToolChainDir;
    292   getProgramPaths().push_back(Path);
    293 }
    294 
    295 void DarwinClang::AddLinkSearchPathArgs(const ArgList &Args,
    296                                        ArgStringList &CmdArgs) const {
    297   // The Clang toolchain uses explicit paths for internal libraries.
    298 
    299   // Unfortunately, we still might depend on a few of the libraries that are
    300   // only available in the gcc library directory (in particular
    301   // libstdc++.dylib). For now, hardcode the path to the known install location.
    302   llvm::sys::Path P(getDriver().Dir);
    303   P.eraseComponent(); // .../usr/bin -> ../usr
    304   P.appendComponent("lib");
    305   P.appendComponent("gcc");
    306   switch (getTriple().getArch()) {
    307   default:
    308     llvm_unreachable("Invalid Darwin arch!");
    309   case llvm::Triple::x86:
    310   case llvm::Triple::x86_64:
    311     P.appendComponent("i686-apple-darwin10");
    312     break;
    313   case llvm::Triple::arm:
    314   case llvm::Triple::thumb:
    315     P.appendComponent("arm-apple-darwin10");
    316     break;
    317   case llvm::Triple::ppc:
    318   case llvm::Triple::ppc64:
    319     P.appendComponent("powerpc-apple-darwin10");
    320     break;
    321   }
    322   P.appendComponent("4.2.1");
    323 
    324   // Determine the arch specific GCC subdirectory.
    325   const char *ArchSpecificDir = 0;
    326   switch (getTriple().getArch()) {
    327   default:
    328     break;
    329   case llvm::Triple::arm:
    330   case llvm::Triple::thumb: {
    331     std::string Triple = ComputeLLVMTriple(Args);
    332     StringRef TripleStr = Triple;
    333     if (TripleStr.startswith("armv5") || TripleStr.startswith("thumbv5"))
    334       ArchSpecificDir = "v5";
    335     else if (TripleStr.startswith("armv6") || TripleStr.startswith("thumbv6"))
    336       ArchSpecificDir = "v6";
    337     else if (TripleStr.startswith("armv7") || TripleStr.startswith("thumbv7"))
    338       ArchSpecificDir = "v7";
    339     break;
    340   }
    341   case llvm::Triple::ppc64:
    342     ArchSpecificDir = "ppc64";
    343     break;
    344   case llvm::Triple::x86_64:
    345     ArchSpecificDir = "x86_64";
    346     break;
    347   }
    348 
    349   if (ArchSpecificDir) {
    350     P.appendComponent(ArchSpecificDir);
    351     bool Exists;
    352     if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
    353       CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
    354     P.eraseComponent();
    355   }
    356 
    357   bool Exists;
    358   if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
    359     CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
    360 }
    361 
    362 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
    363                                  ArgStringList &CmdArgs) const {
    364 
    365   CmdArgs.push_back("-force_load");
    366   llvm::sys::Path P(getDriver().ClangExecutable);
    367   P.eraseComponent(); // 'clang'
    368   P.eraseComponent(); // 'bin'
    369   P.appendComponent("lib");
    370   P.appendComponent("arc");
    371   P.appendComponent("libarclite_");
    372   std::string s = P.str();
    373   // Mash in the platform.
    374   if (isTargetIOSSimulator())
    375     s += "iphonesimulator";
    376   else if (isTargetIPhoneOS())
    377     s += "iphoneos";
    378   // FIXME: Remove this once we depend fully on -mios-simulator-version-min.
    379   else if (ARCRuntimeForSimulator != ARCSimulator_None)
    380     s += "iphonesimulator";
    381   else
    382     s += "macosx";
    383   s += ".a";
    384 
    385   CmdArgs.push_back(Args.MakeArgString(s));
    386 }
    387 
    388 void DarwinClang::AddLinkRuntimeLib(const ArgList &Args,
    389                                     ArgStringList &CmdArgs,
    390                                     const char *DarwinStaticLib) const {
    391   llvm::sys::Path P(getDriver().ResourceDir);
    392   P.appendComponent("lib");
    393   P.appendComponent("darwin");
    394   P.appendComponent(DarwinStaticLib);
    395 
    396   // For now, allow missing resource libraries to support developers who may
    397   // not have compiler-rt checked out or integrated into their build.
    398   bool Exists;
    399   if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
    400     CmdArgs.push_back(Args.MakeArgString(P.str()));
    401 }
    402 
    403 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
    404                                         ArgStringList &CmdArgs) const {
    405   // Darwin doesn't support real static executables, don't link any runtime
    406   // libraries with -static.
    407   if (Args.hasArg(options::OPT_static))
    408     return;
    409 
    410   // Reject -static-libgcc for now, we can deal with this when and if someone
    411   // cares. This is useful in situations where someone wants to statically link
    412   // something like libstdc++, and needs its runtime support routines.
    413   if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
    414     getDriver().Diag(diag::err_drv_unsupported_opt)
    415       << A->getAsString(Args);
    416     return;
    417   }
    418 
    419   // Otherwise link libSystem, then the dynamic runtime library, and finally any
    420   // target specific static runtime library.
    421   CmdArgs.push_back("-lSystem");
    422 
    423   // Select the dynamic runtime library and the target specific static library.
    424   if (isTargetIPhoneOS()) {
    425     // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
    426     // it never went into the SDK.
    427     // Linking against libgcc_s.1 isn't needed for iOS 5.0+
    428     if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator())
    429       CmdArgs.push_back("-lgcc_s.1");
    430 
    431     // We currently always need a static runtime library for iOS.
    432     AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
    433   } else {
    434     // The dynamic runtime library was merged with libSystem for 10.6 and
    435     // beyond; only 10.4 and 10.5 need an additional runtime library.
    436     if (isMacosxVersionLT(10, 5))
    437       CmdArgs.push_back("-lgcc_s.10.4");
    438     else if (isMacosxVersionLT(10, 6))
    439       CmdArgs.push_back("-lgcc_s.10.5");
    440 
    441     // For OS X, we thought we would only need a static runtime library when
    442     // targeting 10.4, to provide versions of the static functions which were
    443     // omitted from 10.4.dylib.
    444     //
    445     // Unfortunately, that turned out to not be true, because Darwin system
    446     // headers can still use eprintf on i386, and it is not exported from
    447     // libSystem. Therefore, we still must provide a runtime library just for
    448     // the tiny tiny handful of projects that *might* use that symbol.
    449     if (isMacosxVersionLT(10, 5)) {
    450       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
    451     } else {
    452       if (getTriple().getArch() == llvm::Triple::x86)
    453         AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.eprintf.a");
    454       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
    455     }
    456   }
    457 }
    458 
    459 static inline StringRef SimulatorVersionDefineName() {
    460   return "__IPHONE_OS_VERSION_MIN_REQUIRED";
    461 }
    462 
    463 /// \brief Parse the simulator version define:
    464 /// __IPHONE_OS_VERSION_MIN_REQUIRED=([0-9])([0-9][0-9])([0-9][0-9])
    465 // and return the grouped values as integers, e.g:
    466 //   __IPHONE_OS_VERSION_MIN_REQUIRED=40201
    467 // will return Major=4, Minor=2, Micro=1.
    468 static bool GetVersionFromSimulatorDefine(StringRef define,
    469                                           unsigned &Major, unsigned &Minor,
    470                                           unsigned &Micro) {
    471   assert(define.startswith(SimulatorVersionDefineName()));
    472   StringRef name, version;
    473   llvm::tie(name, version) = define.split('=');
    474   if (version.empty())
    475     return false;
    476   std::string verstr = version.str();
    477   char *end;
    478   unsigned num = (unsigned) strtol(verstr.c_str(), &end, 10);
    479   if (*end != '\0')
    480     return false;
    481   Major = num / 10000;
    482   num = num % 10000;
    483   Minor = num / 100;
    484   Micro = num % 100;
    485   return true;
    486 }
    487 
    488 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
    489   const OptTable &Opts = getDriver().getOpts();
    490 
    491   Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
    492   Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
    493   Arg *iOSSimVersion = Args.getLastArg(
    494     options::OPT_mios_simulator_version_min_EQ);
    495 
    496   // FIXME: HACK! When compiling for the simulator we don't get a
    497   // '-miphoneos-version-min' to help us know whether there is an ARC runtime
    498   // or not; try to parse a __IPHONE_OS_VERSION_MIN_REQUIRED
    499   // define passed in command-line.
    500   if (!iOSVersion && !iOSSimVersion) {
    501     for (arg_iterator it = Args.filtered_begin(options::OPT_D),
    502            ie = Args.filtered_end(); it != ie; ++it) {
    503       StringRef define = (*it)->getValue(Args);
    504       if (define.startswith(SimulatorVersionDefineName())) {
    505         unsigned Major = 0, Minor = 0, Micro = 0;
    506         if (GetVersionFromSimulatorDefine(define, Major, Minor, Micro) &&
    507             Major < 10 && Minor < 100 && Micro < 100) {
    508           ARCRuntimeForSimulator = Major < 5 ? ARCSimulator_NoARCRuntime
    509                                              : ARCSimulator_HasARCRuntime;
    510           LibCXXForSimulator = Major < 5 ? LibCXXSimulator_NotAvailable
    511                                          : LibCXXSimulator_Available;
    512         }
    513         break;
    514       }
    515     }
    516   }
    517 
    518   if (OSXVersion && (iOSVersion || iOSSimVersion)) {
    519     getDriver().Diag(diag::err_drv_argument_not_allowed_with)
    520           << OSXVersion->getAsString(Args)
    521           << (iOSVersion ? iOSVersion : iOSSimVersion)->getAsString(Args);
    522     iOSVersion = iOSSimVersion = 0;
    523   } else if (iOSVersion && iOSSimVersion) {
    524     getDriver().Diag(diag::err_drv_argument_not_allowed_with)
    525           << iOSVersion->getAsString(Args)
    526           << iOSSimVersion->getAsString(Args);
    527     iOSSimVersion = 0;
    528   } else if (!OSXVersion && !iOSVersion && !iOSSimVersion) {
    529     // If no deployment target was specified on the command line, check for
    530     // environment defines.
    531     StringRef OSXTarget;
    532     StringRef iOSTarget;
    533     StringRef iOSSimTarget;
    534     if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
    535       OSXTarget = env;
    536     if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
    537       iOSTarget = env;
    538     if (char *env = ::getenv("IOS_SIMULATOR_DEPLOYMENT_TARGET"))
    539       iOSSimTarget = env;
    540 
    541     // If no '-miphoneos-version-min' specified on the command line and
    542     // IPHONEOS_DEPLOYMENT_TARGET is not defined, see if we can set the default
    543     // based on isysroot.
    544     if (iOSTarget.empty()) {
    545       if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
    546         StringRef first, second;
    547         StringRef isysroot = A->getValue(Args);
    548         llvm::tie(first, second) = isysroot.split(StringRef("SDKs/iPhoneOS"));
    549         if (second != "")
    550           iOSTarget = second.substr(0,3);
    551       }
    552     }
    553 
    554     // If no OSX or iOS target has been specified and we're compiling for armv7,
    555     // go ahead as assume we're targeting iOS.
    556     if (OSXTarget.empty() && iOSTarget.empty())
    557       if (getDarwinArchName(Args) == "armv7")
    558         iOSTarget = "0.0";
    559 
    560     // Handle conflicting deployment targets
    561     //
    562     // FIXME: Don't hardcode default here.
    563 
    564     // Do not allow conflicts with the iOS simulator target.
    565     if (!iOSSimTarget.empty() && (!OSXTarget.empty() || !iOSTarget.empty())) {
    566       getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
    567         << "IOS_SIMULATOR_DEPLOYMENT_TARGET"
    568         << (!OSXTarget.empty() ? "MACOSX_DEPLOYMENT_TARGET" :
    569             "IPHONEOS_DEPLOYMENT_TARGET");
    570     }
    571 
    572     // Allow conflicts among OSX and iOS for historical reasons, but choose the
    573     // default platform.
    574     if (!OSXTarget.empty() && !iOSTarget.empty()) {
    575       if (getTriple().getArch() == llvm::Triple::arm ||
    576           getTriple().getArch() == llvm::Triple::thumb)
    577         OSXTarget = "";
    578       else
    579         iOSTarget = "";
    580     }
    581 
    582     if (!OSXTarget.empty()) {
    583       const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
    584       OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget);
    585       Args.append(OSXVersion);
    586     } else if (!iOSTarget.empty()) {
    587       const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
    588       iOSVersion = Args.MakeJoinedArg(0, O, iOSTarget);
    589       Args.append(iOSVersion);
    590     } else if (!iOSSimTarget.empty()) {
    591       const Option *O = Opts.getOption(
    592         options::OPT_mios_simulator_version_min_EQ);
    593       iOSSimVersion = Args.MakeJoinedArg(0, O, iOSSimTarget);
    594       Args.append(iOSSimVersion);
    595     } else {
    596       // Otherwise, assume we are targeting OS X.
    597       const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
    598       OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin);
    599       Args.append(OSXVersion);
    600     }
    601   }
    602 
    603   // Reject invalid architecture combinations.
    604   if (iOSSimVersion && (getTriple().getArch() != llvm::Triple::x86 &&
    605                         getTriple().getArch() != llvm::Triple::x86_64)) {
    606     getDriver().Diag(diag::err_drv_invalid_arch_for_deployment_target)
    607       << getTriple().getArchName() << iOSSimVersion->getAsString(Args);
    608   }
    609 
    610   // Set the tool chain target information.
    611   unsigned Major, Minor, Micro;
    612   bool HadExtra;
    613   if (OSXVersion) {
    614     assert((!iOSVersion && !iOSSimVersion) && "Unknown target platform!");
    615     if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor,
    616                                    Micro, HadExtra) || HadExtra ||
    617         Major != 10 || Minor >= 100 || Micro >= 100)
    618       getDriver().Diag(diag::err_drv_invalid_version_number)
    619         << OSXVersion->getAsString(Args);
    620   } else {
    621     const Arg *Version = iOSVersion ? iOSVersion : iOSSimVersion;
    622     assert(Version && "Unknown target platform!");
    623     if (!Driver::GetReleaseVersion(Version->getValue(Args), Major, Minor,
    624                                    Micro, HadExtra) || HadExtra ||
    625         Major >= 10 || Minor >= 100 || Micro >= 100)
    626       getDriver().Diag(diag::err_drv_invalid_version_number)
    627         << Version->getAsString(Args);
    628   }
    629 
    630   bool IsIOSSim = bool(iOSSimVersion);
    631 
    632   // In GCC, the simulator historically was treated as being OS X in some
    633   // contexts, like determining the link logic, despite generally being called
    634   // with an iOS deployment target. For compatibility, we detect the
    635   // simulator as iOS + x86, and treat it differently in a few contexts.
    636   if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
    637                      getTriple().getArch() == llvm::Triple::x86_64))
    638     IsIOSSim = true;
    639 
    640   setTarget(/*IsIPhoneOS=*/ !OSXVersion, Major, Minor, Micro, IsIOSSim);
    641 }
    642 
    643 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
    644                                       ArgStringList &CmdArgs) const {
    645   CXXStdlibType Type = GetCXXStdlibType(Args);
    646 
    647   switch (Type) {
    648   case ToolChain::CST_Libcxx:
    649     CmdArgs.push_back("-lc++");
    650     break;
    651 
    652   case ToolChain::CST_Libstdcxx: {
    653     // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
    654     // it was previously found in the gcc lib dir. However, for all the Darwin
    655     // platforms we care about it was -lstdc++.6, so we search for that
    656     // explicitly if we can't see an obvious -lstdc++ candidate.
    657 
    658     // Check in the sysroot first.
    659     bool Exists;
    660     if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
    661       llvm::sys::Path P(A->getValue(Args));
    662       P.appendComponent("usr");
    663       P.appendComponent("lib");
    664       P.appendComponent("libstdc++.dylib");
    665 
    666       if (llvm::sys::fs::exists(P.str(), Exists) || !Exists) {
    667         P.eraseComponent();
    668         P.appendComponent("libstdc++.6.dylib");
    669         if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
    670           CmdArgs.push_back(Args.MakeArgString(P.str()));
    671           return;
    672         }
    673       }
    674     }
    675 
    676     // Otherwise, look in the root.
    677     if ((llvm::sys::fs::exists("/usr/lib/libstdc++.dylib", Exists) || !Exists)&&
    678       (!llvm::sys::fs::exists("/usr/lib/libstdc++.6.dylib", Exists) && Exists)){
    679       CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
    680       return;
    681     }
    682 
    683     // Otherwise, let the linker search.
    684     CmdArgs.push_back("-lstdc++");
    685     break;
    686   }
    687   }
    688 }
    689 
    690 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
    691                                    ArgStringList &CmdArgs) const {
    692 
    693   // For Darwin platforms, use the compiler-rt-based support library
    694   // instead of the gcc-provided one (which is also incidentally
    695   // only present in the gcc lib dir, which makes it hard to find).
    696 
    697   llvm::sys::Path P(getDriver().ResourceDir);
    698   P.appendComponent("lib");
    699   P.appendComponent("darwin");
    700   P.appendComponent("libclang_rt.cc_kext.a");
    701 
    702   // For now, allow missing resource libraries to support developers who may
    703   // not have compiler-rt checked out or integrated into their build.
    704   bool Exists;
    705   if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
    706     CmdArgs.push_back(Args.MakeArgString(P.str()));
    707 }
    708 
    709 DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
    710                                       const char *BoundArch) const {
    711   DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
    712   const OptTable &Opts = getDriver().getOpts();
    713 
    714   // FIXME: We really want to get out of the tool chain level argument
    715   // translation business, as it makes the driver functionality much
    716   // more opaque. For now, we follow gcc closely solely for the
    717   // purpose of easily achieving feature parity & testability. Once we
    718   // have something that works, we should reevaluate each translation
    719   // and try to push it down into tool specific logic.
    720 
    721   for (ArgList::const_iterator it = Args.begin(),
    722          ie = Args.end(); it != ie; ++it) {
    723     Arg *A = *it;
    724 
    725     if (A->getOption().matches(options::OPT_Xarch__)) {
    726       // Skip this argument unless the architecture matches either the toolchain
    727       // triple arch, or the arch being bound.
    728       //
    729       // FIXME: Canonicalize name.
    730       StringRef XarchArch = A->getValue(Args, 0);
    731       if (!(XarchArch == getArchName()  ||
    732             (BoundArch && XarchArch == BoundArch)))
    733         continue;
    734 
    735       Arg *OriginalArg = A;
    736       unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1));
    737       unsigned Prev = Index;
    738       Arg *XarchArg = Opts.ParseOneArg(Args, Index);
    739 
    740       // If the argument parsing failed or more than one argument was
    741       // consumed, the -Xarch_ argument's parameter tried to consume
    742       // extra arguments. Emit an error and ignore.
    743       //
    744       // We also want to disallow any options which would alter the
    745       // driver behavior; that isn't going to work in our model. We
    746       // use isDriverOption() as an approximation, although things
    747       // like -O4 are going to slip through.
    748       if (!XarchArg || Index > Prev + 1) {
    749         getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
    750           << A->getAsString(Args);
    751         continue;
    752       } else if (XarchArg->getOption().isDriverOption()) {
    753         getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
    754           << A->getAsString(Args);
    755         continue;
    756       }
    757 
    758       XarchArg->setBaseArg(A);
    759       A = XarchArg;
    760 
    761       DAL->AddSynthesizedArg(A);
    762 
    763       // Linker input arguments require custom handling. The problem is that we
    764       // have already constructed the phase actions, so we can not treat them as
    765       // "input arguments".
    766       if (A->getOption().isLinkerInput()) {
    767         // Convert the argument into individual Zlinker_input_args.
    768         for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
    769           DAL->AddSeparateArg(OriginalArg,
    770                               Opts.getOption(options::OPT_Zlinker_input),
    771                               A->getValue(Args, i));
    772 
    773         }
    774         continue;
    775       }
    776     }
    777 
    778     // Sob. These is strictly gcc compatible for the time being. Apple
    779     // gcc translates options twice, which means that self-expanding
    780     // options add duplicates.
    781     switch ((options::ID) A->getOption().getID()) {
    782     default:
    783       DAL->append(A);
    784       break;
    785 
    786     case options::OPT_mkernel:
    787     case options::OPT_fapple_kext:
    788       DAL->append(A);
    789       DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
    790       break;
    791 
    792     case options::OPT_dependency_file:
    793       DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF),
    794                           A->getValue(Args));
    795       break;
    796 
    797     case options::OPT_gfull:
    798       DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
    799       DAL->AddFlagArg(A,
    800                Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
    801       break;
    802 
    803     case options::OPT_gused:
    804       DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
    805       DAL->AddFlagArg(A,
    806              Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
    807       break;
    808 
    809     case options::OPT_shared:
    810       DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
    811       break;
    812 
    813     case options::OPT_fconstant_cfstrings:
    814       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
    815       break;
    816 
    817     case options::OPT_fno_constant_cfstrings:
    818       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
    819       break;
    820 
    821     case options::OPT_Wnonportable_cfstrings:
    822       DAL->AddFlagArg(A,
    823                       Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
    824       break;
    825 
    826     case options::OPT_Wno_nonportable_cfstrings:
    827       DAL->AddFlagArg(A,
    828                    Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
    829       break;
    830 
    831     case options::OPT_fpascal_strings:
    832       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
    833       break;
    834 
    835     case options::OPT_fno_pascal_strings:
    836       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
    837       break;
    838     }
    839   }
    840 
    841   if (getTriple().getArch() == llvm::Triple::x86 ||
    842       getTriple().getArch() == llvm::Triple::x86_64)
    843     if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
    844       DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2");
    845 
    846   // Add the arch options based on the particular spelling of -arch, to match
    847   // how the driver driver works.
    848   if (BoundArch) {
    849     StringRef Name = BoundArch;
    850     const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ);
    851     const Option *MArch = Opts.getOption(options::OPT_march_EQ);
    852 
    853     // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
    854     // which defines the list of which architectures we accept.
    855     if (Name == "ppc")
    856       ;
    857     else if (Name == "ppc601")
    858       DAL->AddJoinedArg(0, MCpu, "601");
    859     else if (Name == "ppc603")
    860       DAL->AddJoinedArg(0, MCpu, "603");
    861     else if (Name == "ppc604")
    862       DAL->AddJoinedArg(0, MCpu, "604");
    863     else if (Name == "ppc604e")
    864       DAL->AddJoinedArg(0, MCpu, "604e");
    865     else if (Name == "ppc750")
    866       DAL->AddJoinedArg(0, MCpu, "750");
    867     else if (Name == "ppc7400")
    868       DAL->AddJoinedArg(0, MCpu, "7400");
    869     else if (Name == "ppc7450")
    870       DAL->AddJoinedArg(0, MCpu, "7450");
    871     else if (Name == "ppc970")
    872       DAL->AddJoinedArg(0, MCpu, "970");
    873 
    874     else if (Name == "ppc64")
    875       DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
    876 
    877     else if (Name == "i386")
    878       ;
    879     else if (Name == "i486")
    880       DAL->AddJoinedArg(0, MArch, "i486");
    881     else if (Name == "i586")
    882       DAL->AddJoinedArg(0, MArch, "i586");
    883     else if (Name == "i686")
    884       DAL->AddJoinedArg(0, MArch, "i686");
    885     else if (Name == "pentium")
    886       DAL->AddJoinedArg(0, MArch, "pentium");
    887     else if (Name == "pentium2")
    888       DAL->AddJoinedArg(0, MArch, "pentium2");
    889     else if (Name == "pentpro")
    890       DAL->AddJoinedArg(0, MArch, "pentiumpro");
    891     else if (Name == "pentIIm3")
    892       DAL->AddJoinedArg(0, MArch, "pentium2");
    893 
    894     else if (Name == "x86_64")
    895       DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
    896 
    897     else if (Name == "arm")
    898       DAL->AddJoinedArg(0, MArch, "armv4t");
    899     else if (Name == "armv4t")
    900       DAL->AddJoinedArg(0, MArch, "armv4t");
    901     else if (Name == "armv5")
    902       DAL->AddJoinedArg(0, MArch, "armv5tej");
    903     else if (Name == "xscale")
    904       DAL->AddJoinedArg(0, MArch, "xscale");
    905     else if (Name == "armv6")
    906       DAL->AddJoinedArg(0, MArch, "armv6k");
    907     else if (Name == "armv7")
    908       DAL->AddJoinedArg(0, MArch, "armv7a");
    909 
    910     else
    911       llvm_unreachable("invalid Darwin arch");
    912   }
    913 
    914   // Add an explicit version min argument for the deployment target. We do this
    915   // after argument translation because -Xarch_ arguments may add a version min
    916   // argument.
    917   AddDeploymentTarget(*DAL);
    918 
    919   // Validate the C++ standard library choice.
    920   CXXStdlibType Type = GetCXXStdlibType(*DAL);
    921   if (Type == ToolChain::CST_Libcxx) {
    922     switch (LibCXXForSimulator) {
    923     case LibCXXSimulator_None:
    924       // Handle non-simulator cases.
    925       if (isTargetIPhoneOS()) {
    926         if (isIPhoneOSVersionLT(5, 0)) {
    927           getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment)
    928             << "iOS 5.0";
    929         }
    930       }
    931       break;
    932     case LibCXXSimulator_NotAvailable:
    933       getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment)
    934         << "iOS 5.0";
    935       break;
    936     case LibCXXSimulator_Available:
    937       break;
    938     }
    939   }
    940 
    941   return DAL;
    942 }
    943 
    944 bool Darwin::IsUnwindTablesDefault() const {
    945   // FIXME: Gross; we should probably have some separate target
    946   // definition, possibly even reusing the one in clang.
    947   return getArchName() == "x86_64";
    948 }
    949 
    950 bool Darwin::UseDwarfDebugFlags() const {
    951   if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
    952     return S[0] != '\0';
    953   return false;
    954 }
    955 
    956 bool Darwin::UseSjLjExceptions() const {
    957   // Darwin uses SjLj exceptions on ARM.
    958   return (getTriple().getArch() == llvm::Triple::arm ||
    959           getTriple().getArch() == llvm::Triple::thumb);
    960 }
    961 
    962 const char *Darwin::GetDefaultRelocationModel() const {
    963   return "pic";
    964 }
    965 
    966 const char *Darwin::GetForcedPicModel() const {
    967   if (getArchName() == "x86_64")
    968     return "pic";
    969   return 0;
    970 }
    971 
    972 bool Darwin::SupportsProfiling() const {
    973   // Profiling instrumentation is only supported on x86.
    974   return getArchName() == "i386" || getArchName() == "x86_64";
    975 }
    976 
    977 bool Darwin::SupportsObjCGC() const {
    978   // Garbage collection is supported everywhere except on iPhone OS.
    979   return !isTargetIPhoneOS();
    980 }
    981 
    982 std::string
    983 Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args,
    984                                                 types::ID InputType) const {
    985   return ComputeLLVMTriple(Args, InputType);
    986 }
    987 
    988 /// Generic_GCC - A tool chain using the 'gcc' command to perform
    989 /// all subcommands; this relies on gcc translating the majority of
    990 /// command line options.
    991 
    992 Generic_GCC::Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple)
    993   : ToolChain(Host, Triple) {
    994   getProgramPaths().push_back(getDriver().getInstalledDir());
    995   if (getDriver().getInstalledDir() != getDriver().Dir)
    996     getProgramPaths().push_back(getDriver().Dir);
    997 }
    998 
    999 Generic_GCC::~Generic_GCC() {
   1000   // Free tool implementations.
   1001   for (llvm::DenseMap<unsigned, Tool*>::iterator
   1002          it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
   1003     delete it->second;
   1004 }
   1005 
   1006 Tool &Generic_GCC::SelectTool(const Compilation &C,
   1007                               const JobAction &JA,
   1008                               const ActionList &Inputs) const {
   1009   Action::ActionClass Key;
   1010   if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
   1011     Key = Action::AnalyzeJobClass;
   1012   else
   1013     Key = JA.getKind();
   1014 
   1015   Tool *&T = Tools[Key];
   1016   if (!T) {
   1017     switch (Key) {
   1018     case Action::InputClass:
   1019     case Action::BindArchClass:
   1020       llvm_unreachable("Invalid tool kind.");
   1021     case Action::PreprocessJobClass:
   1022       T = new tools::gcc::Preprocess(*this); break;
   1023     case Action::PrecompileJobClass:
   1024       T = new tools::gcc::Precompile(*this); break;
   1025     case Action::AnalyzeJobClass:
   1026       T = new tools::Clang(*this); break;
   1027     case Action::CompileJobClass:
   1028       T = new tools::gcc::Compile(*this); break;
   1029     case Action::AssembleJobClass:
   1030       T = new tools::gcc::Assemble(*this); break;
   1031     case Action::LinkJobClass:
   1032       T = new tools::gcc::Link(*this); break;
   1033 
   1034       // This is a bit ungeneric, but the only platform using a driver
   1035       // driver is Darwin.
   1036     case Action::LipoJobClass:
   1037       T = new tools::darwin::Lipo(*this); break;
   1038     case Action::DsymutilJobClass:
   1039       T = new tools::darwin::Dsymutil(*this); break;
   1040     case Action::VerifyJobClass:
   1041       T = new tools::darwin::VerifyDebug(*this); break;
   1042     }
   1043   }
   1044 
   1045   return *T;
   1046 }
   1047 
   1048 bool Generic_GCC::IsUnwindTablesDefault() const {
   1049   // FIXME: Gross; we should probably have some separate target
   1050   // definition, possibly even reusing the one in clang.
   1051   return getArchName() == "x86_64";
   1052 }
   1053 
   1054 const char *Generic_GCC::GetDefaultRelocationModel() const {
   1055   return "static";
   1056 }
   1057 
   1058 const char *Generic_GCC::GetForcedPicModel() const {
   1059   return 0;
   1060 }
   1061 
   1062 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
   1063 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
   1064 /// Currently does not support anything else but compilation.
   1065 
   1066 TCEToolChain::TCEToolChain(const HostInfo &Host, const llvm::Triple& Triple)
   1067   : ToolChain(Host, Triple) {
   1068   // Path mangling to find libexec
   1069   std::string Path(getDriver().Dir);
   1070 
   1071   Path += "/../libexec";
   1072   getProgramPaths().push_back(Path);
   1073 }
   1074 
   1075 TCEToolChain::~TCEToolChain() {
   1076   for (llvm::DenseMap<unsigned, Tool*>::iterator
   1077            it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
   1078       delete it->second;
   1079 }
   1080 
   1081 bool TCEToolChain::IsMathErrnoDefault() const {
   1082   return true;
   1083 }
   1084 
   1085 bool TCEToolChain::IsUnwindTablesDefault() const {
   1086   return false;
   1087 }
   1088 
   1089 const char *TCEToolChain::GetDefaultRelocationModel() const {
   1090   return "static";
   1091 }
   1092 
   1093 const char *TCEToolChain::GetForcedPicModel() const {
   1094   return 0;
   1095 }
   1096 
   1097 Tool &TCEToolChain::SelectTool(const Compilation &C,
   1098                             const JobAction &JA,
   1099                                const ActionList &Inputs) const {
   1100   Action::ActionClass Key;
   1101   Key = Action::AnalyzeJobClass;
   1102 
   1103   Tool *&T = Tools[Key];
   1104   if (!T) {
   1105     switch (Key) {
   1106     case Action::PreprocessJobClass:
   1107       T = new tools::gcc::Preprocess(*this); break;
   1108     case Action::AnalyzeJobClass:
   1109       T = new tools::Clang(*this); break;
   1110     default:
   1111      llvm_unreachable("Unsupported action for TCE target.");
   1112     }
   1113   }
   1114   return *T;
   1115 }
   1116 
   1117 /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
   1118 
   1119 OpenBSD::OpenBSD(const HostInfo &Host, const llvm::Triple& Triple)
   1120   : Generic_ELF(Host, Triple) {
   1121   getFilePaths().push_back(getDriver().Dir + "/../lib");
   1122   getFilePaths().push_back("/usr/lib");
   1123 }
   1124 
   1125 Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA,
   1126                           const ActionList &Inputs) const {
   1127   Action::ActionClass Key;
   1128   if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
   1129     Key = Action::AnalyzeJobClass;
   1130   else
   1131     Key = JA.getKind();
   1132 
   1133   bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
   1134                                              options::OPT_no_integrated_as,
   1135                                              IsIntegratedAssemblerDefault());
   1136 
   1137   Tool *&T = Tools[Key];
   1138   if (!T) {
   1139     switch (Key) {
   1140     case Action::AssembleJobClass: {
   1141       if (UseIntegratedAs)
   1142         T = new tools::ClangAs(*this);
   1143       else
   1144         T = new tools::openbsd::Assemble(*this);
   1145       break;
   1146     }
   1147     case Action::LinkJobClass:
   1148       T = new tools::openbsd::Link(*this); break;
   1149     default:
   1150       T = &Generic_GCC::SelectTool(C, JA, Inputs);
   1151     }
   1152   }
   1153 
   1154   return *T;
   1155 }
   1156 
   1157 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
   1158 
   1159 FreeBSD::FreeBSD(const HostInfo &Host, const llvm::Triple& Triple)
   1160   : Generic_ELF(Host, Triple) {
   1161 
   1162   // Determine if we are compiling 32-bit code on an x86_64 platform.
   1163   bool Lib32 = false;
   1164   if (Triple.getArch() == llvm::Triple::x86 &&
   1165       llvm::Triple(getDriver().DefaultHostTriple).getArch() ==
   1166         llvm::Triple::x86_64)
   1167     Lib32 = true;
   1168 
   1169   if (Triple.getArch() == llvm::Triple::ppc &&
   1170       llvm::Triple(getDriver().DefaultHostTriple).getArch() ==
   1171         llvm::Triple::ppc64)
   1172     Lib32 = true;
   1173 
   1174   if (Lib32) {
   1175     getFilePaths().push_back("/usr/lib32");
   1176   } else {
   1177     getFilePaths().push_back("/usr/lib");
   1178   }
   1179 }
   1180 
   1181 Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA,
   1182                           const ActionList &Inputs) const {
   1183   Action::ActionClass Key;
   1184   if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
   1185     Key = Action::AnalyzeJobClass;
   1186   else
   1187     Key = JA.getKind();
   1188 
   1189   bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
   1190                                              options::OPT_no_integrated_as,
   1191                                              IsIntegratedAssemblerDefault());
   1192 
   1193   Tool *&T = Tools[Key];
   1194   if (!T) {
   1195     switch (Key) {
   1196     case Action::AssembleJobClass:
   1197       if (UseIntegratedAs)
   1198         T = new tools::ClangAs(*this);
   1199       else
   1200         T = new tools::freebsd::Assemble(*this);
   1201       break;
   1202     case Action::LinkJobClass:
   1203       T = new tools::freebsd::Link(*this); break;
   1204     default:
   1205       T = &Generic_GCC::SelectTool(C, JA, Inputs);
   1206     }
   1207   }
   1208 
   1209   return *T;
   1210 }
   1211 
   1212 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
   1213 
   1214 NetBSD::NetBSD(const HostInfo &Host, const llvm::Triple& Triple,
   1215                const llvm::Triple& ToolTriple)
   1216   : Generic_ELF(Host, Triple), ToolTriple(ToolTriple) {
   1217 
   1218   // Determine if we are compiling 32-bit code on an x86_64 platform.
   1219   bool Lib32 = false;
   1220   if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
   1221       Triple.getArch() == llvm::Triple::x86)
   1222     Lib32 = true;
   1223 
   1224   if (getDriver().UseStdLib) {
   1225     if (Lib32)
   1226       getFilePaths().push_back("=/usr/lib/i386");
   1227     else
   1228       getFilePaths().push_back("=/usr/lib");
   1229   }
   1230 }
   1231 
   1232 Tool &NetBSD::SelectTool(const Compilation &C, const JobAction &JA,
   1233                          const ActionList &Inputs) const {
   1234   Action::ActionClass Key;
   1235   if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
   1236     Key = Action::AnalyzeJobClass;
   1237   else
   1238     Key = JA.getKind();
   1239 
   1240   bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
   1241                                              options::OPT_no_integrated_as,
   1242                                              IsIntegratedAssemblerDefault());
   1243 
   1244   Tool *&T = Tools[Key];
   1245   if (!T) {
   1246     switch (Key) {
   1247     case Action::AssembleJobClass:
   1248       if (UseIntegratedAs)
   1249         T = new tools::ClangAs(*this);
   1250       else
   1251         T = new tools::netbsd::Assemble(*this, ToolTriple);
   1252       break;
   1253     case Action::LinkJobClass:
   1254       T = new tools::netbsd::Link(*this, ToolTriple);
   1255       break;
   1256     default:
   1257       T = &Generic_GCC::SelectTool(C, JA, Inputs);
   1258     }
   1259   }
   1260 
   1261   return *T;
   1262 }
   1263 
   1264 /// Minix - Minix tool chain which can call as(1) and ld(1) directly.
   1265 
   1266 Minix::Minix(const HostInfo &Host, const llvm::Triple& Triple)
   1267   : Generic_GCC(Host, Triple) {
   1268   getFilePaths().push_back(getDriver().Dir + "/../lib");
   1269   getFilePaths().push_back("/usr/lib");
   1270   getFilePaths().push_back("/usr/gnu/lib");
   1271   getFilePaths().push_back("/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
   1272 }
   1273 
   1274 Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA,
   1275                         const ActionList &Inputs) const {
   1276   Action::ActionClass Key;
   1277   if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
   1278     Key = Action::AnalyzeJobClass;
   1279   else
   1280     Key = JA.getKind();
   1281 
   1282   Tool *&T = Tools[Key];
   1283   if (!T) {
   1284     switch (Key) {
   1285     case Action::AssembleJobClass:
   1286       T = new tools::minix::Assemble(*this); break;
   1287     case Action::LinkJobClass:
   1288       T = new tools::minix::Link(*this); break;
   1289     default:
   1290       T = &Generic_GCC::SelectTool(C, JA, Inputs);
   1291     }
   1292   }
   1293 
   1294   return *T;
   1295 }
   1296 
   1297 /// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
   1298 
   1299 AuroraUX::AuroraUX(const HostInfo &Host, const llvm::Triple& Triple)
   1300   : Generic_GCC(Host, Triple) {
   1301 
   1302   getProgramPaths().push_back(getDriver().getInstalledDir());
   1303   if (getDriver().getInstalledDir() != getDriver().Dir)
   1304     getProgramPaths().push_back(getDriver().Dir);
   1305 
   1306   getFilePaths().push_back(getDriver().Dir + "/../lib");
   1307   getFilePaths().push_back("/usr/lib");
   1308   getFilePaths().push_back("/usr/sfw/lib");
   1309   getFilePaths().push_back("/opt/gcc4/lib");
   1310   getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
   1311 
   1312 }
   1313 
   1314 Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA,
   1315                            const ActionList &Inputs) const {
   1316   Action::ActionClass Key;
   1317   if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
   1318     Key = Action::AnalyzeJobClass;
   1319   else
   1320     Key = JA.getKind();
   1321 
   1322   Tool *&T = Tools[Key];
   1323   if (!T) {
   1324     switch (Key) {
   1325     case Action::AssembleJobClass:
   1326       T = new tools::auroraux::Assemble(*this); break;
   1327     case Action::LinkJobClass:
   1328       T = new tools::auroraux::Link(*this); break;
   1329     default:
   1330       T = &Generic_GCC::SelectTool(C, JA, Inputs);
   1331     }
   1332   }
   1333 
   1334   return *T;
   1335 }
   1336 
   1337 
   1338 /// Linux toolchain (very bare-bones at the moment).
   1339 
   1340 enum LinuxDistro {
   1341   ArchLinux,
   1342   DebianLenny,
   1343   DebianSqueeze,
   1344   DebianWheezy,
   1345   Exherbo,
   1346   RHEL4,
   1347   RHEL5,
   1348   RHEL6,
   1349   Fedora13,
   1350   Fedora14,
   1351   Fedora15,
   1352   FedoraRawhide,
   1353   OpenSuse11_3,
   1354   OpenSuse11_4,
   1355   OpenSuse12_1,
   1356   UbuntuHardy,
   1357   UbuntuIntrepid,
   1358   UbuntuJaunty,
   1359   UbuntuKarmic,
   1360   UbuntuLucid,
   1361   UbuntuMaverick,
   1362   UbuntuNatty,
   1363   UbuntuOneiric,
   1364   UnknownDistro
   1365 };
   1366 
   1367 static bool IsRedhat(enum LinuxDistro Distro) {
   1368   return Distro == Fedora13 || Distro == Fedora14 ||
   1369          Distro == Fedora15 || Distro == FedoraRawhide ||
   1370          Distro == RHEL4 || Distro == RHEL5 || Distro == RHEL6;
   1371 }
   1372 
   1373 static bool IsOpenSuse(enum LinuxDistro Distro) {
   1374   return Distro == OpenSuse11_3 || Distro == OpenSuse11_4 ||
   1375          Distro == OpenSuse12_1;
   1376 }
   1377 
   1378 static bool IsDebian(enum LinuxDistro Distro) {
   1379   return Distro == DebianLenny || Distro == DebianSqueeze ||
   1380          Distro == DebianWheezy;
   1381 }
   1382 
   1383 static bool IsUbuntu(enum LinuxDistro Distro) {
   1384   return Distro == UbuntuHardy  || Distro == UbuntuIntrepid ||
   1385          Distro == UbuntuLucid  || Distro == UbuntuMaverick ||
   1386          Distro == UbuntuJaunty || Distro == UbuntuKarmic ||
   1387          Distro == UbuntuNatty  || Distro == UbuntuOneiric;
   1388 }
   1389 
   1390 // FIXME: This should be deleted. We should assume a multilib environment, and
   1391 // fallback gracefully if any parts of it are absent.
   1392 static bool HasMultilib(llvm::Triple::ArchType Arch, enum LinuxDistro Distro) {
   1393   if (Arch == llvm::Triple::x86_64) {
   1394     bool Exists;
   1395     if (Distro == Exherbo &&
   1396         (llvm::sys::fs::exists("/usr/lib32/libc.so", Exists) || !Exists))
   1397       return false;
   1398   }
   1399 
   1400   return true;
   1401 }
   1402 
   1403 static LinuxDistro DetectLinuxDistro(llvm::Triple::ArchType Arch) {
   1404   llvm::OwningPtr<llvm::MemoryBuffer> File;
   1405   if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
   1406     StringRef Data = File.get()->getBuffer();
   1407     SmallVector<StringRef, 8> Lines;
   1408     Data.split(Lines, "\n");
   1409     for (unsigned int i = 0, s = Lines.size(); i < s; ++ i) {
   1410       if (Lines[i] == "DISTRIB_CODENAME=hardy")
   1411         return UbuntuHardy;
   1412       else if (Lines[i] == "DISTRIB_CODENAME=intrepid")
   1413         return UbuntuIntrepid;
   1414       else if (Lines[i] == "DISTRIB_CODENAME=jaunty")
   1415         return UbuntuJaunty;
   1416       else if (Lines[i] == "DISTRIB_CODENAME=karmic")
   1417         return UbuntuKarmic;
   1418       else if (Lines[i] == "DISTRIB_CODENAME=lucid")
   1419         return UbuntuLucid;
   1420       else if (Lines[i] == "DISTRIB_CODENAME=maverick")
   1421         return UbuntuMaverick;
   1422       else if (Lines[i] == "DISTRIB_CODENAME=natty")
   1423         return UbuntuNatty;
   1424       else if (Lines[i] == "DISTRIB_CODENAME=oneiric")
   1425         return UbuntuOneiric;
   1426     }
   1427     return UnknownDistro;
   1428   }
   1429 
   1430   if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
   1431     StringRef Data = File.get()->getBuffer();
   1432     if (Data.startswith("Fedora release 15"))
   1433       return Fedora15;
   1434     else if (Data.startswith("Fedora release 14"))
   1435       return Fedora14;
   1436     else if (Data.startswith("Fedora release 13"))
   1437       return Fedora13;
   1438     else if (Data.startswith("Fedora release") &&
   1439              Data.find("Rawhide") != StringRef::npos)
   1440       return FedoraRawhide;
   1441     else if (Data.startswith("Red Hat Enterprise Linux") &&
   1442              Data.find("release 6") != StringRef::npos)
   1443       return RHEL6;
   1444     else if ((Data.startswith("Red Hat Enterprise Linux") ||
   1445 	      Data.startswith("CentOS")) &&
   1446              Data.find("release 5") != StringRef::npos)
   1447       return RHEL5;
   1448     else if ((Data.startswith("Red Hat Enterprise Linux") ||
   1449 	      Data.startswith("CentOS")) &&
   1450              Data.find("release 4") != StringRef::npos)
   1451       return RHEL4;
   1452     return UnknownDistro;
   1453   }
   1454 
   1455   if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
   1456     StringRef Data = File.get()->getBuffer();
   1457     if (Data[0] == '5')
   1458       return DebianLenny;
   1459     else if (Data.startswith("squeeze/sid"))
   1460       return DebianSqueeze;
   1461     else if (Data.startswith("wheezy/sid"))
   1462       return DebianWheezy;
   1463     return UnknownDistro;
   1464   }
   1465 
   1466   if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File)) {
   1467     StringRef Data = File.get()->getBuffer();
   1468     if (Data.startswith("openSUSE 11.3"))
   1469       return OpenSuse11_3;
   1470     else if (Data.startswith("openSUSE 11.4"))
   1471       return OpenSuse11_4;
   1472     else if (Data.startswith("openSUSE 12.1"))
   1473       return OpenSuse12_1;
   1474     return UnknownDistro;
   1475   }
   1476 
   1477   bool Exists;
   1478   if (!llvm::sys::fs::exists("/etc/exherbo-release", Exists) && Exists)
   1479     return Exherbo;
   1480 
   1481   if (!llvm::sys::fs::exists("/etc/arch-release", Exists) && Exists)
   1482     return ArchLinux;
   1483 
   1484   return UnknownDistro;
   1485 }
   1486 
   1487 /// \brief Trivial helper function to simplify code checking path existence.
   1488 static bool PathExists(StringRef Path) {
   1489   bool Exists;
   1490   if (!llvm::sys::fs::exists(Path, Exists))
   1491     return Exists;
   1492   return false;
   1493 }
   1494 
   1495 namespace {
   1496 /// \brief This is a class to find a viable GCC installation for Clang to use.
   1497 ///
   1498 /// This class tries to find a GCC installation on the system, and report
   1499 /// information about it. It starts from the host information provided to the
   1500 /// Driver, and has logic for fuzzing that where appropriate.
   1501 class GCCInstallationDetector {
   1502   /// \brief Struct to store and manipulate GCC versions.
   1503   ///
   1504   /// We rely on assumptions about the form and structure of GCC version
   1505   /// numbers: they consist of at most three '.'-separated components, and each
   1506   /// component is a non-negative integer.
   1507   struct GCCVersion {
   1508     unsigned Major, Minor, Patch;
   1509 
   1510     static GCCVersion Parse(StringRef VersionText) {
   1511       const GCCVersion BadVersion = {0, 0, 0};
   1512       std::pair<StringRef, StringRef> First = VersionText.split('.');
   1513       std::pair<StringRef, StringRef> Second = First.second.split('.');
   1514 
   1515       GCCVersion GoodVersion = {0, 0, 0};
   1516       if (First.first.getAsInteger(10, GoodVersion.Major))
   1517         return BadVersion;
   1518       if (Second.first.getAsInteger(10, GoodVersion.Minor))
   1519         return BadVersion;
   1520       // We accept a number, or a string for the patch version, in case there
   1521       // is a strang suffix, or other mangling: '4.1.x', '4.1.2-rc3'. When it
   1522       // isn't a number, we just use '0' as the number but accept it.
   1523       if (Second.first.getAsInteger(10, GoodVersion.Patch))
   1524         GoodVersion.Patch = 0;
   1525       return GoodVersion;
   1526     }
   1527 
   1528     bool operator<(const GCCVersion &RHS) const {
   1529       if (Major < RHS.Major) return true;
   1530       if (Major > RHS.Major) return false;
   1531       if (Minor < RHS.Minor) return true;
   1532       if (Minor > RHS.Minor) return false;
   1533       return Patch < RHS.Patch;
   1534     }
   1535     bool operator>(const GCCVersion &RHS) const { return RHS < *this; }
   1536     bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); }
   1537     bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); }
   1538   };
   1539 
   1540   bool IsValid;
   1541   std::string GccTriple;
   1542 
   1543   // FIXME: These might be better as path objects.
   1544   std::string GccInstallPath;
   1545   std::string GccParentLibPath;
   1546 
   1547   llvm::SmallString<128> CxxIncludeRoot;
   1548 
   1549 public:
   1550   /// \brief Construct a GCCInstallationDetector from the driver.
   1551   ///
   1552   /// This performs all of the autodetection and sets up the various paths.
   1553   /// Once constructed, a GCCInstallation is esentially immutable.
   1554   GCCInstallationDetector(const Driver &D)
   1555     : IsValid(false),
   1556       GccTriple(D.DefaultHostTriple),
   1557       CxxIncludeRoot(CXX_INCLUDE_ROOT) {
   1558     // FIXME: Using CXX_INCLUDE_ROOT is here is a bit of a hack, but
   1559     // avoids adding yet another option to configure/cmake.
   1560     // It would probably be cleaner to break it in two variables
   1561     // CXX_GCC_ROOT with just /foo/bar
   1562     // CXX_GCC_VER with 4.5.2
   1563     // Then we would have
   1564     // CXX_INCLUDE_ROOT = CXX_GCC_ROOT/include/c++/CXX_GCC_VER
   1565     // and this function would return
   1566     // CXX_GCC_ROOT/lib/gcc/CXX_INCLUDE_ARCH/CXX_GCC_VER
   1567     if (CxxIncludeRoot != "") {
   1568       // This is of the form /foo/bar/include/c++/4.5.2/
   1569       if (CxxIncludeRoot.back() == '/')
   1570         llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the /
   1571       StringRef Version = llvm::sys::path::filename(CxxIncludeRoot);
   1572       llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the version
   1573       llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the c++
   1574       llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the include
   1575       GccInstallPath = CxxIncludeRoot.str();
   1576       GccInstallPath.append("/lib/gcc/");
   1577       GccInstallPath.append(CXX_INCLUDE_ARCH);
   1578       GccInstallPath.append("/");
   1579       GccInstallPath.append(Version);
   1580       GccParentLibPath = GccInstallPath + "/../../..";
   1581       IsValid = true;
   1582       return;
   1583     }
   1584 
   1585     llvm::Triple::ArchType HostArch = llvm::Triple(GccTriple).getArch();
   1586     // The library directories which may contain GCC installations.
   1587     SmallVector<StringRef, 4> CandidateLibDirs;
   1588     // The compatible GCC triples for this particular architecture.
   1589     SmallVector<StringRef, 10> CandidateTriples;
   1590     CollectLibDirsAndTriples(HostArch, CandidateLibDirs, CandidateTriples);
   1591 
   1592     // Always include the default host triple as the final fallback if no
   1593     // specific triple is detected.
   1594     CandidateTriples.push_back(D.DefaultHostTriple);
   1595 
   1596     // Compute the set of prefixes for our search.
   1597     SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
   1598                                          D.PrefixDirs.end());
   1599     Prefixes.push_back(D.SysRoot);
   1600     Prefixes.push_back(D.SysRoot + "/usr");
   1601     Prefixes.push_back(D.InstalledDir + "/..");
   1602 
   1603     // Loop over the various components which exist and select the best GCC
   1604     // installation available. GCC installs are ranked by version number.
   1605     GCCVersion BestVersion = {0, 0, 0};
   1606     for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) {
   1607       if (!PathExists(Prefixes[i]))
   1608         continue;
   1609       for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) {
   1610         const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str();
   1611         if (!PathExists(LibDir))
   1612           continue;
   1613         for (unsigned k = 0, ke = CandidateTriples.size(); k < ke; ++k)
   1614           ScanLibDirForGCCTriple(LibDir, CandidateTriples[k], BestVersion);
   1615       }
   1616     }
   1617   }
   1618 
   1619   /// \brief Check whether we detected a valid GCC install.
   1620   bool isValid() const { return IsValid; }
   1621 
   1622   /// \brief Get the GCC triple for the detected install.
   1623   const std::string &getTriple() const { return GccTriple; }
   1624 
   1625   /// \brief Get the detected GCC installation path.
   1626   const std::string &getInstallPath() const { return GccInstallPath; }
   1627 
   1628   /// \brief Get the detected GCC parent lib path.
   1629   const std::string &getParentLibPath() const { return GccParentLibPath; }
   1630 
   1631 private:
   1632   static void CollectLibDirsAndTriples(llvm::Triple::ArchType HostArch,
   1633                                        SmallVectorImpl<StringRef> &LibDirs,
   1634                                        SmallVectorImpl<StringRef> &Triples) {
   1635     if (HostArch == llvm::Triple::arm || HostArch == llvm::Triple::thumb) {
   1636       static const char *const ARMLibDirs[] = { "/lib" };
   1637       static const char *const ARMTriples[] = { "arm-linux-gnueabi" };
   1638       LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs));
   1639       Triples.append(ARMTriples, ARMTriples + llvm::array_lengthof(ARMTriples));
   1640     } else if (HostArch == llvm::Triple::x86_64) {
   1641       static const char *const X86_64LibDirs[] = { "/lib64", "/lib" };
   1642       static const char *const X86_64Triples[] = {
   1643         "x86_64-linux-gnu",
   1644         "x86_64-unknown-linux-gnu",
   1645         "x86_64-pc-linux-gnu",
   1646         "x86_64-redhat-linux6E",
   1647         "x86_64-redhat-linux",
   1648         "x86_64-suse-linux",
   1649         "x86_64-manbo-linux-gnu",
   1650         "x86_64-linux-gnu",
   1651         "x86_64-slackware-linux"
   1652       };
   1653       LibDirs.append(X86_64LibDirs,
   1654                      X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
   1655       Triples.append(X86_64Triples,
   1656                      X86_64Triples + llvm::array_lengthof(X86_64Triples));
   1657     } else if (HostArch == llvm::Triple::x86) {
   1658       static const char *const X86LibDirs[] = { "/lib32", "/lib" };
   1659       static const char *const X86Triples[] = {
   1660         "i686-linux-gnu",
   1661         "i386-linux-gnu",
   1662         "i686-pc-linux-gnu",
   1663         "i486-linux-gnu",
   1664         "i686-redhat-linux",
   1665         "i386-redhat-linux",
   1666         "i586-suse-linux",
   1667         "i486-slackware-linux"
   1668       };
   1669       LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
   1670       Triples.append(X86Triples, X86Triples + llvm::array_lengthof(X86Triples));
   1671     } else if (HostArch == llvm::Triple::ppc) {
   1672       static const char *const PPCLibDirs[] = { "/lib32", "/lib" };
   1673       static const char *const PPCTriples[] = {
   1674         "powerpc-linux-gnu",
   1675         "powerpc-unknown-linux-gnu"
   1676       };
   1677       LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
   1678       Triples.append(PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples));
   1679     } else if (HostArch == llvm::Triple::ppc64) {
   1680       static const char *const PPC64LibDirs[] = { "/lib64", "/lib" };
   1681       static const char *const PPC64Triples[] = {
   1682         "powerpc64-unknown-linux-gnu"
   1683       };
   1684       LibDirs.append(PPC64LibDirs,
   1685                      PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
   1686       Triples.append(PPC64Triples,
   1687                      PPC64Triples + llvm::array_lengthof(PPC64Triples));
   1688     }
   1689   }
   1690 
   1691   void ScanLibDirForGCCTriple(const std::string &LibDir,
   1692                               StringRef CandidateTriple,
   1693                               GCCVersion &BestVersion) {
   1694     // There are various different suffixes involving the triple we
   1695     // check for. We also record what is necessary to walk from each back
   1696     // up to the lib directory.
   1697     const std::string Suffixes[] = {
   1698       "/gcc/" + CandidateTriple.str(),
   1699       "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
   1700 
   1701       // Ubuntu has a strange mis-matched pair of triples that this happens to
   1702       // match.
   1703       // FIXME: It may be worthwhile to generalize this and look for a second
   1704       // triple.
   1705       "/" + CandidateTriple.str() + "/gcc/i686-linux-gnu"
   1706     };
   1707     const std::string InstallSuffixes[] = {
   1708       "/../../..",
   1709       "/../../../..",
   1710       "/../../../.."
   1711     };
   1712     // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
   1713     const unsigned NumSuffixes = (llvm::array_lengthof(Suffixes) -
   1714                                   (CandidateTriple != "i386-linux-gnu"));
   1715     for (unsigned i = 0; i < NumSuffixes; ++i) {
   1716       StringRef Suffix = Suffixes[i];
   1717       llvm::error_code EC;
   1718       for (llvm::sys::fs::directory_iterator LI(LibDir + Suffix, EC), LE;
   1719            !EC && LI != LE; LI = LI.increment(EC)) {
   1720         StringRef VersionText = llvm::sys::path::filename(LI->path());
   1721         GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
   1722         static const GCCVersion MinVersion = { 4, 1, 1 };
   1723         if (CandidateVersion < MinVersion)
   1724           continue;
   1725         if (CandidateVersion <= BestVersion)
   1726           continue;
   1727         if (!PathExists(LI->path() + "/crtbegin.o"))
   1728           continue;
   1729 
   1730         BestVersion = CandidateVersion;
   1731         GccTriple = CandidateTriple.str();
   1732         // FIXME: We hack together the directory name here instead of
   1733         // using LI to ensure stable path separators across Windows and
   1734         // Linux.
   1735         GccInstallPath = LibDir + Suffixes[i] + "/" + VersionText.str();
   1736         GccParentLibPath = GccInstallPath + InstallSuffixes[i];
   1737         IsValid = true;
   1738       }
   1739     }
   1740   }
   1741 };
   1742 }
   1743 
   1744 static void addPathIfExists(const std::string &Path,
   1745                             ToolChain::path_list &Paths) {
   1746   if (PathExists(Path)) Paths.push_back(Path);
   1747 }
   1748 
   1749 Linux::Linux(const HostInfo &Host, const llvm::Triple &Triple)
   1750   : Generic_ELF(Host, Triple) {
   1751   llvm::Triple::ArchType Arch =
   1752     llvm::Triple(getDriver().DefaultHostTriple).getArch();
   1753   const std::string &SysRoot = getDriver().SysRoot;
   1754   GCCInstallationDetector GCCInstallation(getDriver());
   1755 
   1756   // OpenSuse stores the linker with the compiler, add that to the search
   1757   // path.
   1758   ToolChain::path_list &PPaths = getProgramPaths();
   1759   PPaths.push_back(GCCInstallation.getParentLibPath() + "/../" +
   1760                    GCCInstallation.getTriple() + "/bin");
   1761 
   1762   Linker = GetProgramPath("ld");
   1763 
   1764   LinuxDistro Distro = DetectLinuxDistro(Arch);
   1765 
   1766   if (IsOpenSuse(Distro) || IsUbuntu(Distro)) {
   1767     ExtraOpts.push_back("-z");
   1768     ExtraOpts.push_back("relro");
   1769   }
   1770 
   1771   if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
   1772     ExtraOpts.push_back("-X");
   1773 
   1774   if (IsRedhat(Distro) || IsOpenSuse(Distro) || Distro == UbuntuMaverick ||
   1775       Distro == UbuntuNatty || Distro == UbuntuOneiric)
   1776     ExtraOpts.push_back("--hash-style=gnu");
   1777 
   1778   if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid ||
   1779       Distro == UbuntuJaunty || Distro == UbuntuKarmic)
   1780     ExtraOpts.push_back("--hash-style=both");
   1781 
   1782   if (IsRedhat(Distro))
   1783     ExtraOpts.push_back("--no-add-needed");
   1784 
   1785   if (Distro == DebianSqueeze || Distro == DebianWheezy ||
   1786       IsOpenSuse(Distro) ||
   1787       (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
   1788       Distro == UbuntuLucid ||
   1789       Distro == UbuntuMaverick || Distro == UbuntuKarmic ||
   1790       Distro == UbuntuNatty || Distro == UbuntuOneiric)
   1791     ExtraOpts.push_back("--build-id");
   1792 
   1793   if (IsOpenSuse(Distro))
   1794     ExtraOpts.push_back("--enable-new-dtags");
   1795 
   1796   // The selection of paths to try here is designed to match the patterns which
   1797   // the GCC driver itself uses, as this is part of the GCC-compatible driver.
   1798   // This was determined by running GCC in a fake filesystem, creating all
   1799   // possible permutations of these directories, and seeing which ones it added
   1800   // to the link paths.
   1801   path_list &Paths = getFilePaths();
   1802   const bool Is32Bits = (getArch() == llvm::Triple::x86 ||
   1803                          getArch() == llvm::Triple::ppc);
   1804 
   1805   const std::string Suffix32 = Arch == llvm::Triple::x86_64 ? "/32" : "";
   1806   const std::string Suffix64 = Arch == llvm::Triple::x86_64 ? "" : "/64";
   1807   const std::string Suffix = Is32Bits ? Suffix32 : Suffix64;
   1808   const std::string Multilib = Is32Bits ? "lib32" : "lib64";
   1809 
   1810   // FIXME: Because we add paths only when they exist on the system, I think we
   1811   // should remove the concept of 'HasMultilib'. It's more likely to break the
   1812   // behavior than to preserve any useful invariant on the system.
   1813   if (HasMultilib(Arch, Distro)) {
   1814     // Add the multilib suffixed paths.
   1815     if (GCCInstallation.isValid()) {
   1816       const std::string &LibPath = GCCInstallation.getParentLibPath();
   1817       const std::string &GccTriple = GCCInstallation.getTriple();
   1818       // FIXME: This OpenSuse-specific path shouldn't be needed any more, but
   1819       // I don't want to remove it without finding someone to test.
   1820       if (IsOpenSuse(Distro) && Is32Bits)
   1821         Paths.push_back(LibPath + "/../" + GccTriple + "/lib/../lib");
   1822 
   1823       addPathIfExists(GCCInstallation.getInstallPath() + Suffix, Paths);
   1824       addPathIfExists(LibPath + "/../" + GccTriple + "/lib/../" + Multilib,
   1825                       Paths);
   1826       addPathIfExists(LibPath + "/../" + Multilib, Paths);
   1827     }
   1828     addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
   1829     addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
   1830 
   1831     // Try walking via the GCC triple path in case of multiarch GCC
   1832     // installations with strange symlinks.
   1833     if (GCCInstallation.isValid())
   1834       addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple() +
   1835                       "/../../" + Multilib, Paths);
   1836   }
   1837 
   1838   // Add the non-multilib suffixed paths (if potentially different).
   1839   if (GCCInstallation.isValid()) {
   1840     const std::string &LibPath = GCCInstallation.getParentLibPath();
   1841     const std::string &GccTriple = GCCInstallation.getTriple();
   1842     if (!Suffix.empty() || !HasMultilib(Arch, Distro))
   1843       addPathIfExists(GCCInstallation.getInstallPath(), Paths);
   1844     addPathIfExists(LibPath + "/../" + GccTriple + "/lib", Paths);
   1845     addPathIfExists(LibPath, Paths);
   1846   }
   1847   addPathIfExists(SysRoot + "/lib", Paths);
   1848   addPathIfExists(SysRoot + "/usr/lib", Paths);
   1849 
   1850   // Add a multiarch lib directory whenever it exists and is plausible.
   1851   if (GCCInstallation.isValid() && Arch == getArch())
   1852     addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple(), Paths);
   1853 }
   1854 
   1855 bool Linux::HasNativeLLVMSupport() const {
   1856   return true;
   1857 }
   1858 
   1859 Tool &Linux::SelectTool(const Compilation &C, const JobAction &JA,
   1860                         const ActionList &Inputs) const {
   1861   Action::ActionClass Key;
   1862   if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
   1863     Key = Action::AnalyzeJobClass;
   1864   else
   1865     Key = JA.getKind();
   1866 
   1867   bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
   1868                                              options::OPT_no_integrated_as,
   1869                                              IsIntegratedAssemblerDefault());
   1870 
   1871   Tool *&T = Tools[Key];
   1872   if (!T) {
   1873     switch (Key) {
   1874     case Action::AssembleJobClass:
   1875       if (UseIntegratedAs)
   1876         T = new tools::ClangAs(*this);
   1877       else
   1878         T = new tools::linuxtools::Assemble(*this);
   1879       break;
   1880     case Action::LinkJobClass:
   1881       T = new tools::linuxtools::Link(*this); break;
   1882     default:
   1883       T = &Generic_GCC::SelectTool(C, JA, Inputs);
   1884     }
   1885   }
   1886 
   1887   return *T;
   1888 }
   1889 
   1890 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
   1891 
   1892 DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple)
   1893   : Generic_ELF(Host, Triple) {
   1894 
   1895   // Path mangling to find libexec
   1896   getProgramPaths().push_back(getDriver().getInstalledDir());
   1897   if (getDriver().getInstalledDir() != getDriver().Dir)
   1898     getProgramPaths().push_back(getDriver().Dir);
   1899 
   1900   getFilePaths().push_back(getDriver().Dir + "/../lib");
   1901   getFilePaths().push_back("/usr/lib");
   1902   getFilePaths().push_back("/usr/lib/gcc41");
   1903 }
   1904 
   1905 Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA,
   1906                             const ActionList &Inputs) const {
   1907   Action::ActionClass Key;
   1908   if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
   1909     Key = Action::AnalyzeJobClass;
   1910   else
   1911     Key = JA.getKind();
   1912 
   1913   Tool *&T = Tools[Key];
   1914   if (!T) {
   1915     switch (Key) {
   1916     case Action::AssembleJobClass:
   1917       T = new tools::dragonfly::Assemble(*this); break;
   1918     case Action::LinkJobClass:
   1919       T = new tools::dragonfly::Link(*this); break;
   1920     default:
   1921       T = &Generic_GCC::SelectTool(C, JA, Inputs);
   1922     }
   1923   }
   1924 
   1925   return *T;
   1926 }
   1927 
   1928 Windows::Windows(const HostInfo &Host, const llvm::Triple& Triple)
   1929   : ToolChain(Host, Triple) {
   1930 }
   1931 
   1932 Tool &Windows::SelectTool(const Compilation &C, const JobAction &JA,
   1933                           const ActionList &Inputs) const {
   1934   Action::ActionClass Key;
   1935   if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
   1936     Key = Action::AnalyzeJobClass;
   1937   else
   1938     Key = JA.getKind();
   1939 
   1940   bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
   1941                                              options::OPT_no_integrated_as,
   1942                                              IsIntegratedAssemblerDefault());
   1943 
   1944   Tool *&T = Tools[Key];
   1945   if (!T) {
   1946     switch (Key) {
   1947     case Action::InputClass:
   1948     case Action::BindArchClass:
   1949     case Action::LipoJobClass:
   1950     case Action::DsymutilJobClass:
   1951     case Action::VerifyJobClass:
   1952       llvm_unreachable("Invalid tool kind.");
   1953     case Action::PreprocessJobClass:
   1954     case Action::PrecompileJobClass:
   1955     case Action::AnalyzeJobClass:
   1956     case Action::CompileJobClass:
   1957       T = new tools::Clang(*this); break;
   1958     case Action::AssembleJobClass:
   1959       if (!UseIntegratedAs && getTriple().getEnvironment() == llvm::Triple::MachO)
   1960         T = new tools::darwin::Assemble(*this);
   1961       else
   1962         T = new tools::ClangAs(*this);
   1963       break;
   1964     case Action::LinkJobClass:
   1965       T = new tools::visualstudio::Link(*this); break;
   1966     }
   1967   }
   1968 
   1969   return *T;
   1970 }
   1971 
   1972 bool Windows::IsIntegratedAssemblerDefault() const {
   1973   return true;
   1974 }
   1975 
   1976 bool Windows::IsUnwindTablesDefault() const {
   1977   // FIXME: Gross; we should probably have some separate target
   1978   // definition, possibly even reusing the one in clang.
   1979   return getArchName() == "x86_64";
   1980 }
   1981 
   1982 const char *Windows::GetDefaultRelocationModel() const {
   1983   return "static";
   1984 }
   1985 
   1986 const char *Windows::GetForcedPicModel() const {
   1987   if (getArchName() == "x86_64")
   1988     return "pic";
   1989   return 0;
   1990 }
   1991