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

   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 #include "SanitizerArgs.h"
  12 #include "clang/Basic/ObjCRuntime.h"
  13 #include "clang/Basic/Version.h"
  14 #include "clang/Driver/Arg.h"
  15 #include "clang/Driver/ArgList.h"
  16 #include "clang/Driver/Compilation.h"
  17 #include "clang/Driver/Driver.h"
  18 #include "clang/Driver/DriverDiagnostic.h"
  19 #include "clang/Driver/OptTable.h"
  20 #include "clang/Driver/Option.h"
  21 #include "clang/Driver/Options.h"
  22 #include "llvm/ADT/STLExtras.h"
  23 #include "llvm/ADT/SmallString.h"
  24 #include "llvm/ADT/StringExtras.h"
  25 #include "llvm/ADT/StringSwitch.h"
  26 #include "llvm/Support/ErrorHandling.h"
  27 #include "llvm/Support/FileSystem.h"
  28 #include "llvm/Support/MemoryBuffer.h"
  29 #include "llvm/Support/Path.h"
  30 #include "llvm/Support/raw_ostream.h"
  31 #include "llvm/Support/system_error.h"
  32
  33 // FIXME: This needs to be listed last until we fix the broken include guards
  34 // in these files and the LLVM config.h files.
  35 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
  36
  37 #include <cstdlib> // ::getenv
  38
  39 using namespace clang::driver;
  40 using namespace clang::driver::toolchains;
  41 using namespace clang;
  42
  43 /// Darwin - Darwin tool chain for i386 and x86_64.
  44
  45 Darwin::Darwin(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
  46   : ToolChain(D, Triple, Args), TargetInitialized(false)
  47 {
  48   // Compute the initial Darwin version from the triple
  49   unsigned Major, Minor, Micro;
  50   if (!Triple.getMacOSXVersion(Major, Minor, Micro))
  51     getDriver().Diag(diag::err_drv_invalid_darwin_version) <<
  52       Triple.getOSName();
  53   llvm::raw_string_ostream(MacosxVersionMin)
  54     << Major << '.' << Minor << '.' << Micro;
  55
  56   // FIXME: DarwinVersion is only used to find GCC's libexec directory.
  57   // It should be removed when we stop supporting that.
  58   DarwinVersion[0] = Minor + 4;
  59   DarwinVersion[1] = Micro;
  60   DarwinVersion[2] = 0;
  61
  62   // Compute the initial iOS version from the triple
  63   Triple.getiOSVersion(Major, Minor, Micro);
  64   llvm::raw_string_ostream(iOSVersionMin)
  65     << Major << '.' << Minor << '.' << Micro;
  66 }
  67
  68 types::ID Darwin::LookupTypeForExtension(const char *Ext) const {
  69   types::ID Ty = types::lookupTypeForExtension(Ext);
  70
  71   // Darwin always preprocesses assembly files (unless -x is used explicitly).
  72   if (Ty == types::TY_PP_Asm)
  73     return types::TY_Asm;
  74
  75   return Ty;
  76 }
  77
  78 bool Darwin::HasNativeLLVMSupport() const {
  79   return true;
  80 }
  81
  82 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
  83 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
  84   if (isTargetIPhoneOS())
  85     return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
  86   if (isNonFragile)
  87     return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
  88   return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
  89 }
  90
  91 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
  92 bool Darwin::hasBlocksRuntime() const {
  93   if (isTargetIPhoneOS())
  94     return !isIPhoneOSVersionLT(3, 2);
  95   else
  96     return !isMacosxVersionLT(10, 6);
  97 }
  98
  99 static const char *GetArmArchForMArch(StringRef Value) {
 100   return llvm::StringSwitch<const char*>(Value)
 101     .Case("armv6k", "armv6")
 102     .Case("armv6m", "armv6m")
 103     .Case("armv5tej", "armv5")
 104     .Case("xscale", "xscale")
 105     .Case("armv4t", "armv4t")
 106     .Case("armv7", "armv7")
 107     .Cases("armv7a", "armv7-a", "armv7")
 108     .Cases("armv7r", "armv7-r", "armv7")
 109     .Cases("armv7em", "armv7e-m", "armv7em")
 110     .Cases("armv7f", "armv7-f", "armv7f")
 111     .Cases("armv7k", "armv7-k", "armv7k")
 112     .Cases("armv7m", "armv7-m", "armv7m")
 113     .Cases("armv7s", "armv7-s", "armv7s")
 114     .Default(0);
 115 }
 116
 117 static const char *GetArmArchForMCpu(StringRef Value) {
 118   return llvm::StringSwitch<const char *>(Value)
 119     .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "arm926ej-s","armv5")
 120     .Cases("arm10e", "arm10tdmi", "armv5")
 121     .Cases("arm1020t", "arm1020e", "arm1022e", "arm1026ej-s", "armv5")
 122     .Case("xscale", "xscale")
 123     .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "arm1176jzf-s", "armv6")
 124     .Case("cortex-m0", "armv6m")
 125     .Cases("cortex-a8", "cortex-r4", "cortex-a9", "cortex-a15", "armv7")
 126     .Case("cortex-a9-mp", "armv7f")
 127     .Case("cortex-m3", "armv7m")
 128     .Case("cortex-m4", "armv7em")
 129     .Case("swift", "armv7s")
 130     .Default(0);
 131 }
 132
 133 StringRef Darwin::getDarwinArchName(const ArgList &Args) const {
 134   switch (getTriple().getArch()) {
 135   default:
 136     return getArchName();
 137
 138   case llvm::Triple::thumb:
 139   case llvm::Triple::arm: {
 140     if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
 141       if (const char *Arch = GetArmArchForMArch(A->getValue()))
 142         return Arch;
 143
 144     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
 145       if (const char *Arch = GetArmArchForMCpu(A->getValue()))
 146         return Arch;
 147
 148     return "arm";
 149   }
 150   }
 151 }
 152
 153 Darwin::~Darwin() {
 154 }
 155
 156 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
 157                                                 types::ID InputType) const {
 158   llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
 159
 160   // If the target isn't initialized (e.g., an unknown Darwin platform, return
 161   // the default triple).
 162   if (!isTargetInitialized())
 163     return Triple.getTriple();
 164
 165   SmallString<16> Str;
 166   Str += isTargetIPhoneOS() ? "ios" : "macosx";
 167   Str += getTargetVersion().getAsString();
 168   Triple.setOSName(Str);
 169
 170   return Triple.getTriple();
 171 }
 172
 173 void Generic_ELF::anchor() {}
 174
 175 Tool *Darwin::getTool(Action::ActionClass AC) const {
 176   switch (AC) {
 177   case Action::LipoJobClass:
 178     if (!Lipo)
 179       Lipo.reset(new tools::darwin::Lipo(*this));
 180     return Lipo.get();
 181   case Action::DsymutilJobClass:
 182     if (!Dsymutil)
 183       Dsymutil.reset(new tools::darwin::Dsymutil(*this));
 184     return Dsymutil.get();
 185   case Action::VerifyJobClass:
 186     if (!VerifyDebug)
 187       VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
 188     return VerifyDebug.get();
 189   default:
 190     return ToolChain::getTool(AC);
 191   }
 192 }
 193
 194 Tool *Darwin::buildLinker() const {
 195   return new tools::darwin::Link(*this);
 196 }
 197
 198 Tool *Darwin::buildAssembler() const {
 199   return new tools::darwin::Assemble(*this);
 200 }
 201
 202 DarwinClang::DarwinClang(const Driver &D, const llvm::Triple& Triple,
 203                          const ArgList &Args)
 204   : Darwin(D, Triple, Args)
 205 {
 206   getProgramPaths().push_back(getDriver().getInstalledDir());
 207   if (getDriver().getInstalledDir() != getDriver().Dir)
 208     getProgramPaths().push_back(getDriver().Dir);
 209
 210   // We expect 'as', 'ld', etc. to be adjacent to our install dir.
 211   getProgramPaths().push_back(getDriver().getInstalledDir());
 212   if (getDriver().getInstalledDir() != getDriver().Dir)
 213     getProgramPaths().push_back(getDriver().Dir);
 214 }
 215
 216 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
 217                                  ArgStringList &CmdArgs) const {
 218
 219   CmdArgs.push_back("-force_load");
 220   llvm::sys::Path P(getDriver().ClangExecutable);
 221   P.eraseComponent(); // 'clang'
 222   P.eraseComponent(); // 'bin'
 223   P.appendComponent("lib");
 224   P.appendComponent("arc");
 225   P.appendComponent("libarclite_");
 226   std::string s = P.str();
 227   // Mash in the platform.
 228   if (isTargetIOSSimulator())
 229     s += "iphonesimulator";
 230   else if (isTargetIPhoneOS())
 231     s += "iphoneos";
 232   else
 233     s += "macosx";
 234   s += ".a";
 235
 236   CmdArgs.push_back(Args.MakeArgString(s));
 237 }
 238
 239 void DarwinClang::AddLinkRuntimeLib(const ArgList &Args,
 240                                     ArgStringList &CmdArgs,
 241                                     const char *DarwinStaticLib,
 242                                     bool AlwaysLink) const {
 243   llvm::sys::Path P(getDriver().ResourceDir);
 244   P.appendComponent("lib");
 245   P.appendComponent("darwin");
 246   P.appendComponent(DarwinStaticLib);
 247
 248   // For now, allow missing resource libraries to support developers who may
 249   // not have compiler-rt checked out or integrated into their build (unless
 250   // we explicitly force linking with this library).
 251   bool Exists;
 252   if (AlwaysLink || (!llvm::sys::fs::exists(P.str(), Exists) && Exists))
 253     CmdArgs.push_back(Args.MakeArgString(P.str()));
 254 }
 255
 256 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
 257                                         ArgStringList &CmdArgs) const {
 258   // Darwin only supports the compiler-rt based runtime libraries.
 259   switch (GetRuntimeLibType(Args)) {
 260   case ToolChain::RLT_CompilerRT:
 261     break;
 262   default:
 263     getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
 264       << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "darwin";
 265     return;
 266   }
 267
 268   // Darwin doesn't support real static executables, don't link any runtime
 269   // libraries with -static.
 270   if (Args.hasArg(options::OPT_static) ||
 271       Args.hasArg(options::OPT_fapple_kext) ||
 272       Args.hasArg(options::OPT_mkernel))
 273     return;
 274
 275   // Reject -static-libgcc for now, we can deal with this when and if someone
 276   // cares. This is useful in situations where someone wants to statically link
 277   // something like libstdc++, and needs its runtime support routines.
 278   if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
 279     getDriver().Diag(diag::err_drv_unsupported_opt)
 280       << A->getAsString(Args);
 281     return;
 282   }
 283
 284   // If we are building profile support, link that library in.
 285   if (Args.hasArg(options::OPT_fprofile_arcs) ||
 286       Args.hasArg(options::OPT_fprofile_generate) ||
 287       Args.hasArg(options::OPT_fcreate_profile) ||
 288       Args.hasArg(options::OPT_coverage)) {
 289     // Select the appropriate runtime library for the target.
 290     if (isTargetIPhoneOS()) {
 291       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_ios.a");
 292     } else {
 293       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_osx.a");
 294     }
 295   }
 296
 297   SanitizerArgs Sanitize(getDriver(), Args);
 298
 299   // Add Ubsan runtime library, if required.
 300   if (Sanitize.needsUbsanRt()) {
 301     if (isTargetIPhoneOS()) {
 302       getDriver().Diag(diag::err_drv_clang_unsupported_per_platform)
 303         << "-fsanitize=undefined";
 304     } else {
 305       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ubsan_osx.a", true);
 306
 307       // The Ubsan runtime library requires C++.
 308       AddCXXStdlibLibArgs(Args, CmdArgs);
 309     }
 310   }
 311
 312   // Add ASAN runtime library, if required. Dynamic libraries and bundles
 313   // should not be linked with the runtime library.
 314   if (Sanitize.needsAsanRt()) {
 315     if (isTargetIPhoneOS() && !isTargetIOSSimulator()) {
 316       getDriver().Diag(diag::err_drv_clang_unsupported_per_platform)
 317         << "-fsanitize=address";
 318     } else {
 319       if (Args.hasArg(options::OPT_dynamiclib) ||
 320           Args.hasArg(options::OPT_bundle)) {
 321         // Assume the binary will provide the ASan runtime.
 322       } else {
 323         AddLinkRuntimeLib(Args, CmdArgs,
 324                           "libclang_rt.asan_osx_dynamic.dylib", true);
 325         // The ASAN runtime library requires C++.
 326         AddCXXStdlibLibArgs(Args, CmdArgs);
 327       }
 328     }
 329   }
 330
 331   // Otherwise link libSystem, then the dynamic runtime library, and finally any
 332   // target specific static runtime library.
 333   CmdArgs.push_back("-lSystem");
 334
 335   // Select the dynamic runtime library and the target specific static library.
 336   if (isTargetIPhoneOS()) {
 337     // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
 338     // it never went into the SDK.
 339     // Linking against libgcc_s.1 isn't needed for iOS 5.0+
 340     if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator())
 341       CmdArgs.push_back("-lgcc_s.1");
 342
 343     // We currently always need a static runtime library for iOS.
 344     AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
 345   } else {
 346     // The dynamic runtime library was merged with libSystem for 10.6 and
 347     // beyond; only 10.4 and 10.5 need an additional runtime library.
 348     if (isMacosxVersionLT(10, 5))
 349       CmdArgs.push_back("-lgcc_s.10.4");
 350     else if (isMacosxVersionLT(10, 6))
 351       CmdArgs.push_back("-lgcc_s.10.5");
 352
 353     // For OS X, we thought we would only need a static runtime library when
 354     // targeting 10.4, to provide versions of the static functions which were
 355     // omitted from 10.4.dylib.
 356     //
 357     // Unfortunately, that turned out to not be true, because Darwin system
 358     // headers can still use eprintf on i386, and it is not exported from
 359     // libSystem. Therefore, we still must provide a runtime library just for
 360     // the tiny tiny handful of projects that *might* use that symbol.
 361     if (isMacosxVersionLT(10, 5)) {
 362       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
 363     } else {
 364       if (getTriple().getArch() == llvm::Triple::x86)
 365         AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.eprintf.a");
 366       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
 367     }
 368   }
 369 }
 370
 371 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
 372   const OptTable &Opts = getDriver().getOpts();
 373
 374   // Support allowing the SDKROOT environment variable used by xcrun and other
 375   // Xcode tools to define the default sysroot, by making it the default for
 376   // isysroot.
 377   if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
 378     // Warn if the path does not exist.
 379     bool Exists;
 380     if (llvm::sys::fs::exists(A->getValue(), Exists) || !Exists)
 381       getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
 382   } else {
 383     if (char *env = ::getenv("SDKROOT")) {
 384       // We only use this value as the default if it is an absolute path,
 385       // exists, and it is not the root path.
 386       if (llvm::sys::path::is_absolute(env) && llvm::sys::fs::exists(env) &&
 387           StringRef(env) != "/") {
 388         Args.append(Args.MakeSeparateArg(
 389                       0, Opts.getOption(options::OPT_isysroot), env));
 390       }
 391     }
 392   }
 393
 394   Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
 395   Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
 396   Arg *iOSSimVersion = Args.getLastArg(
 397     options::OPT_mios_simulator_version_min_EQ);
 398
 399   if (OSXVersion && (iOSVersion || iOSSimVersion)) {
 400     getDriver().Diag(diag::err_drv_argument_not_allowed_with)
 401           << OSXVersion->getAsString(Args)
 402           << (iOSVersion ? iOSVersion : iOSSimVersion)->getAsString(Args);
 403     iOSVersion = iOSSimVersion = 0;
 404   } else if (iOSVersion && iOSSimVersion) {
 405     getDriver().Diag(diag::err_drv_argument_not_allowed_with)
 406           << iOSVersion->getAsString(Args)
 407           << iOSSimVersion->getAsString(Args);
 408     iOSSimVersion = 0;
 409   } else if (!OSXVersion && !iOSVersion && !iOSSimVersion) {
 410     // If no deployment target was specified on the command line, check for
 411     // environment defines.
 412     StringRef OSXTarget;
 413     StringRef iOSTarget;
 414     StringRef iOSSimTarget;
 415     if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
 416       OSXTarget = env;
 417     if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
 418       iOSTarget = env;
 419     if (char *env = ::getenv("IOS_SIMULATOR_DEPLOYMENT_TARGET"))
 420       iOSSimTarget = env;
 421
 422     // If no '-miphoneos-version-min' specified on the command line and
 423     // IPHONEOS_DEPLOYMENT_TARGET is not defined, see if we can set the default
 424     // based on -isysroot.
 425     if (iOSTarget.empty()) {
 426       if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
 427         StringRef first, second;
 428         StringRef isysroot = A->getValue();
 429         llvm::tie(first, second) = isysroot.split(StringRef("SDKs/iPhoneOS"));
 430         if (second != "")
 431           iOSTarget = second.substr(0,3);
 432       }
 433     }
 434
 435     // If no OSX or iOS target has been specified and we're compiling for armv7,
 436     // go ahead as assume we're targeting iOS.
 437     if (OSXTarget.empty() && iOSTarget.empty() &&
 438         (getDarwinArchName(Args) == "armv7" ||
 439          getDarwinArchName(Args) == "armv7s"))
 440         iOSTarget = iOSVersionMin;
 441
 442     // Handle conflicting deployment targets
 443     //
 444     // FIXME: Don't hardcode default here.
 445
 446     // Do not allow conflicts with the iOS simulator target.
 447     if (!iOSSimTarget.empty() && (!OSXTarget.empty() || !iOSTarget.empty())) {
 448       getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
 449         << "IOS_SIMULATOR_DEPLOYMENT_TARGET"
 450         << (!OSXTarget.empty() ? "MACOSX_DEPLOYMENT_TARGET" :
 451             "IPHONEOS_DEPLOYMENT_TARGET");
 452     }
 453
 454     // Allow conflicts among OSX and iOS for historical reasons, but choose the
 455     // default platform.
 456     if (!OSXTarget.empty() && !iOSTarget.empty()) {
 457       if (getTriple().getArch() == llvm::Triple::arm ||
 458           getTriple().getArch() == llvm::Triple::thumb)
 459         OSXTarget = "";
 460       else
 461         iOSTarget = "";
 462     }
 463
 464     if (!OSXTarget.empty()) {
 465       const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
 466       OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget);
 467       Args.append(OSXVersion);
 468     } else if (!iOSTarget.empty()) {
 469       const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
 470       iOSVersion = Args.MakeJoinedArg(0, O, iOSTarget);
 471       Args.append(iOSVersion);
 472     } else if (!iOSSimTarget.empty()) {
 473       const Option O = Opts.getOption(
 474         options::OPT_mios_simulator_version_min_EQ);
 475       iOSSimVersion = Args.MakeJoinedArg(0, O, iOSSimTarget);
 476       Args.append(iOSSimVersion);
 477     } else {
 478       // Otherwise, assume we are targeting OS X.
 479       const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
 480       OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin);
 481       Args.append(OSXVersion);
 482     }
 483   }
 484
 485   // Reject invalid architecture combinations.
 486   if (iOSSimVersion && (getTriple().getArch() != llvm::Triple::x86 &&
 487                         getTriple().getArch() != llvm::Triple::x86_64)) {
 488     getDriver().Diag(diag::err_drv_invalid_arch_for_deployment_target)
 489       << getTriple().getArchName() << iOSSimVersion->getAsString(Args);
 490   }
 491
 492   // Set the tool chain target information.
 493   unsigned Major, Minor, Micro;
 494   bool HadExtra;
 495   if (OSXVersion) {
 496     assert((!iOSVersion && !iOSSimVersion) && "Unknown target platform!");
 497     if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor,
 498                                    Micro, HadExtra) || HadExtra ||
 499         Major != 10 || Minor >= 100 || Micro >= 100)
 500       getDriver().Diag(diag::err_drv_invalid_version_number)
 501         << OSXVersion->getAsString(Args);
 502   } else {
 503     const Arg *Version = iOSVersion ? iOSVersion : iOSSimVersion;
 504     assert(Version && "Unknown target platform!");
 505     if (!Driver::GetReleaseVersion(Version->getValue(), Major, Minor,
 506                                    Micro, HadExtra) || HadExtra ||
 507         Major >= 10 || Minor >= 100 || Micro >= 100)
 508       getDriver().Diag(diag::err_drv_invalid_version_number)
 509         << Version->getAsString(Args);
 510   }
 511
 512   bool IsIOSSim = bool(iOSSimVersion);
 513
 514   // In GCC, the simulator historically was treated as being OS X in some
 515   // contexts, like determining the link logic, despite generally being called
 516   // with an iOS deployment target. For compatibility, we detect the
 517   // simulator as iOS + x86, and treat it differently in a few contexts.
 518   if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
 519                      getTriple().getArch() == llvm::Triple::x86_64))
 520     IsIOSSim = true;
 521
 522   setTarget(/*IsIPhoneOS=*/ !OSXVersion, Major, Minor, Micro, IsIOSSim);
 523 }
 524
 525 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
 526                                       ArgStringList &CmdArgs) const {
 527   CXXStdlibType Type = GetCXXStdlibType(Args);
 528
 529   switch (Type) {
 530   case ToolChain::CST_Libcxx:
 531     CmdArgs.push_back("-lc++");
 532     break;
 533
 534   case ToolChain::CST_Libstdcxx: {
 535     // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
 536     // it was previously found in the gcc lib dir. However, for all the Darwin
 537     // platforms we care about it was -lstdc++.6, so we search for that
 538     // explicitly if we can't see an obvious -lstdc++ candidate.
 539
 540     // Check in the sysroot first.
 541     bool Exists;
 542     if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
 543       llvm::sys::Path P(A->getValue());
 544       P.appendComponent("usr");
 545       P.appendComponent("lib");
 546       P.appendComponent("libstdc++.dylib");
 547
 548       if (llvm::sys::fs::exists(P.str(), Exists) || !Exists) {
 549         P.eraseComponent();
 550         P.appendComponent("libstdc++.6.dylib");
 551         if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
 552           CmdArgs.push_back(Args.MakeArgString(P.str()));
 553           return;
 554         }
 555       }
 556     }
 557
 558     // Otherwise, look in the root.
 559     // FIXME: This should be removed someday when we don't have to care about
 560     // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
 561     if ((llvm::sys::fs::exists("/usr/lib/libstdc++.dylib", Exists) || !Exists)&&
 562       (!llvm::sys::fs::exists("/usr/lib/libstdc++.6.dylib", Exists) && Exists)){
 563       CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
 564       return;
 565     }
 566
 567     // Otherwise, let the linker search.
 568     CmdArgs.push_back("-lstdc++");
 569     break;
 570   }
 571   }
 572 }
 573
 574 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
 575                                    ArgStringList &CmdArgs) const {
 576
 577   // For Darwin platforms, use the compiler-rt-based support library
 578   // instead of the gcc-provided one (which is also incidentally
 579   // only present in the gcc lib dir, which makes it hard to find).
 580
 581   llvm::sys::Path P(getDriver().ResourceDir);
 582   P.appendComponent("lib");
 583   P.appendComponent("darwin");
 584
 585   // Use the newer cc_kext for iOS ARM after 6.0.
 586   if (!isTargetIPhoneOS() || isTargetIOSSimulator() ||
 587       !isIPhoneOSVersionLT(6, 0)) {
 588     P.appendComponent("libclang_rt.cc_kext.a");
 589   } else {
 590     P.appendComponent("libclang_rt.cc_kext_ios5.a");
 591   }
 592
 593   // For now, allow missing resource libraries to support developers who may
 594   // not have compiler-rt checked out or integrated into their build.
 595   bool Exists;
 596   if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
 597     CmdArgs.push_back(Args.MakeArgString(P.str()));
 598 }
 599
 600 DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
 601                                       const char *BoundArch) const {
 602   DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
 603   const OptTable &Opts = getDriver().getOpts();
 604
 605   // FIXME: We really want to get out of the tool chain level argument
 606   // translation business, as it makes the driver functionality much
 607   // more opaque. For now, we follow gcc closely solely for the
 608   // purpose of easily achieving feature parity & testability. Once we
 609   // have something that works, we should reevaluate each translation
 610   // and try to push it down into tool specific logic.
 611
 612   for (ArgList::const_iterator it = Args.begin(),
 613          ie = Args.end(); it != ie; ++it) {
 614     Arg *A = *it;
 615
 616     if (A->getOption().matches(options::OPT_Xarch__)) {
 617       // Skip this argument unless the architecture matches either the toolchain
 618       // triple arch, or the arch being bound.
 619       llvm::Triple::ArchType XarchArch =
 620         tools::darwin::getArchTypeForDarwinArchName(A->getValue(0));
 621       if (!(XarchArch == getArch()  ||
 622             (BoundArch && XarchArch ==
 623              tools::darwin::getArchTypeForDarwinArchName(BoundArch))))
 624         continue;
 625
 626       Arg *OriginalArg = A;
 627       unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
 628       unsigned Prev = Index;
 629       Arg *XarchArg = Opts.ParseOneArg(Args, Index);
 630
 631       // If the argument parsing failed or more than one argument was
 632       // consumed, the -Xarch_ argument's parameter tried to consume
 633       // extra arguments. Emit an error and ignore.
 634       //
 635       // We also want to disallow any options which would alter the
 636       // driver behavior; that isn't going to work in our model. We
 637       // use isDriverOption() as an approximation, although things
 638       // like -O4 are going to slip through.
 639       if (!XarchArg || Index > Prev + 1) {
 640         getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
 641           << A->getAsString(Args);
 642         continue;
 643       } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
 644         getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
 645           << A->getAsString(Args);
 646         continue;
 647       }
 648
 649       XarchArg->setBaseArg(A);
 650       A = XarchArg;
 651
 652       DAL->AddSynthesizedArg(A);
 653
 654       // Linker input arguments require custom handling. The problem is that we
 655       // have already constructed the phase actions, so we can not treat them as
 656       // "input arguments".
 657       if (A->getOption().hasFlag(options::LinkerInput)) {
 658         // Convert the argument into individual Zlinker_input_args.
 659         for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
 660           DAL->AddSeparateArg(OriginalArg,
 661                               Opts.getOption(options::OPT_Zlinker_input),
 662                               A->getValue(i));
 663
 664         }
 665         continue;
 666       }
 667     }
 668
 669     // Sob. These is strictly gcc compatible for the time being. Apple
 670     // gcc translates options twice, which means that self-expanding
 671     // options add duplicates.
 672     switch ((options::ID) A->getOption().getID()) {
 673     default:
 674       DAL->append(A);
 675       break;
 676
 677     case options::OPT_mkernel:
 678     case options::OPT_fapple_kext:
 679       DAL->append(A);
 680       DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
 681       break;
 682
 683     case options::OPT_dependency_file:
 684       DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF),
 685                           A->getValue());
 686       break;
 687
 688     case options::OPT_gfull:
 689       DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
 690       DAL->AddFlagArg(A,
 691                Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
 692       break;
 693
 694     case options::OPT_gused:
 695       DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
 696       DAL->AddFlagArg(A,
 697              Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
 698       break;
 699
 700     case options::OPT_shared:
 701       DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
 702       break;
 703
 704     case options::OPT_fconstant_cfstrings:
 705       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
 706       break;
 707
 708     case options::OPT_fno_constant_cfstrings:
 709       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
 710       break;
 711
 712     case options::OPT_Wnonportable_cfstrings:
 713       DAL->AddFlagArg(A,
 714                       Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
 715       break;
 716
 717     case options::OPT_Wno_nonportable_cfstrings:
 718       DAL->AddFlagArg(A,
 719                    Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
 720       break;
 721
 722     case options::OPT_fpascal_strings:
 723       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
 724       break;
 725
 726     case options::OPT_fno_pascal_strings:
 727       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
 728       break;
 729     }
 730   }
 731
 732   if (getTriple().getArch() == llvm::Triple::x86 ||
 733       getTriple().getArch() == llvm::Triple::x86_64)
 734     if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
 735       DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2");
 736
 737   // Add the arch options based on the particular spelling of -arch, to match
 738   // how the driver driver works.
 739   if (BoundArch) {
 740     StringRef Name = BoundArch;
 741     const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
 742     const Option MArch = Opts.getOption(options::OPT_march_EQ);
 743
 744     // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
 745     // which defines the list of which architectures we accept.
 746     if (Name == "ppc")
 747       ;
 748     else if (Name == "ppc601")
 749       DAL->AddJoinedArg(0, MCpu, "601");
 750     else if (Name == "ppc603")
 751       DAL->AddJoinedArg(0, MCpu, "603");
 752     else if (Name == "ppc604")
 753       DAL->AddJoinedArg(0, MCpu, "604");
 754     else if (Name == "ppc604e")
 755       DAL->AddJoinedArg(0, MCpu, "604e");
 756     else if (Name == "ppc750")
 757       DAL->AddJoinedArg(0, MCpu, "750");
 758     else if (Name == "ppc7400")
 759       DAL->AddJoinedArg(0, MCpu, "7400");
 760     else if (Name == "ppc7450")
 761       DAL->AddJoinedArg(0, MCpu, "7450");
 762     else if (Name == "ppc970")
 763       DAL->AddJoinedArg(0, MCpu, "970");
 764
 765     else if (Name == "ppc64")
 766       DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
 767
 768     else if (Name == "i386")
 769       ;
 770     else if (Name == "i486")
 771       DAL->AddJoinedArg(0, MArch, "i486");
 772     else if (Name == "i586")
 773       DAL->AddJoinedArg(0, MArch, "i586");
 774     else if (Name == "i686")
 775       DAL->AddJoinedArg(0, MArch, "i686");
 776     else if (Name == "pentium")
 777       DAL->AddJoinedArg(0, MArch, "pentium");
 778     else if (Name == "pentium2")
 779       DAL->AddJoinedArg(0, MArch, "pentium2");
 780     else if (Name == "pentpro")
 781       DAL->AddJoinedArg(0, MArch, "pentiumpro");
 782     else if (Name == "pentIIm3")
 783       DAL->AddJoinedArg(0, MArch, "pentium2");
 784
 785     else if (Name == "x86_64")
 786       DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
 787
 788     else if (Name == "arm")
 789       DAL->AddJoinedArg(0, MArch, "armv4t");
 790     else if (Name == "armv4t")
 791       DAL->AddJoinedArg(0, MArch, "armv4t");
 792     else if (Name == "armv5")
 793       DAL->AddJoinedArg(0, MArch, "armv5tej");
 794     else if (Name == "xscale")
 795       DAL->AddJoinedArg(0, MArch, "xscale");
 796     else if (Name == "armv6")
 797       DAL->AddJoinedArg(0, MArch, "armv6k");
 798     else if (Name == "armv6m")
 799       DAL->AddJoinedArg(0, MArch, "armv6m");
 800     else if (Name == "armv7")
 801       DAL->AddJoinedArg(0, MArch, "armv7a");
 802     else if (Name == "armv7em")
 803       DAL->AddJoinedArg(0, MArch, "armv7em");
 804     else if (Name == "armv7f")
 805       DAL->AddJoinedArg(0, MArch, "armv7f");
 806     else if (Name == "armv7k")
 807       DAL->AddJoinedArg(0, MArch, "armv7k");
 808     else if (Name == "armv7m")
 809       DAL->AddJoinedArg(0, MArch, "armv7m");
 810     else if (Name == "armv7s")
 811       DAL->AddJoinedArg(0, MArch, "armv7s");
 812
 813     else
 814       llvm_unreachable("invalid Darwin arch");
 815   }
 816
 817   // Add an explicit version min argument for the deployment target. We do this
 818   // after argument translation because -Xarch_ arguments may add a version min
 819   // argument.
 820   if (BoundArch)
 821     AddDeploymentTarget(*DAL);
 822
 823   // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
 824   // FIXME: It would be far better to avoid inserting those -static arguments,
 825   // but we can't check the deployment target in the translation code until
 826   // it is set here.
 827   if (isTargetIPhoneOS() && !isIPhoneOSVersionLT(6, 0)) {
 828     for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
 829       Arg *A = *it;
 830       ++it;
 831       if (A->getOption().getID() != options::OPT_mkernel &&
 832           A->getOption().getID() != options::OPT_fapple_kext)
 833         continue;
 834       assert(it != ie && "unexpected argument translation");
 835       A = *it;
 836       assert(A->getOption().getID() == options::OPT_static &&
 837              "missing expected -static argument");
 838       it = DAL->getArgs().erase(it);
 839     }
 840   }
 841
 842   // Validate the C++ standard library choice.
 843   CXXStdlibType Type = GetCXXStdlibType(*DAL);
 844   if (Type == ToolChain::CST_Libcxx) {
 845     // Check whether the target provides libc++.
 846     StringRef where;
 847
 848     // Complain about targetting iOS < 5.0 in any way.
 849     if (isTargetIPhoneOS() && isIPhoneOSVersionLT(5, 0))
 850       where = "iOS 5.0";
 851
 852     if (where != StringRef()) {
 853       getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment)
 854         << where;
 855     }
 856   }
 857
 858   return DAL;
 859 }
 860
 861 bool Darwin::IsUnwindTablesDefault() const {
 862   return getArch() == llvm::Triple::x86_64;
 863 }
 864
 865 bool Darwin::UseDwarfDebugFlags() const {
 866   if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
 867     return S[0] != '\0';
 868   return false;
 869 }
 870
 871 bool Darwin::UseSjLjExceptions() const {
 872   // Darwin uses SjLj exceptions on ARM.
 873   return (getTriple().getArch() == llvm::Triple::arm ||
 874           getTriple().getArch() == llvm::Triple::thumb);
 875 }
 876
 877 bool Darwin::isPICDefault() const {
 878   return true;
 879 }
 880
 881 bool Darwin::isPICDefaultForced() const {
 882   return getArch() == llvm::Triple::x86_64;
 883 }
 884
 885 bool Darwin::SupportsProfiling() const {
 886   // Profiling instrumentation is only supported on x86.
 887   return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
 888 }
 889
 890 bool Darwin::SupportsObjCGC() const {
 891   // Garbage collection is supported everywhere except on iPhone OS.
 892   return !isTargetIPhoneOS();
 893 }
 894
 895 void Darwin::CheckObjCARC() const {
 896   if (isTargetIPhoneOS() || !isMacosxVersionLT(10, 6))
 897     return;
 898   getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
 899 }
 900
 901 std::string
 902 Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args,
 903                                                 types::ID InputType) const {
 904   return ComputeLLVMTriple(Args, InputType);
 905 }
 906
 907 /// Generic_GCC - A tool chain using the 'gcc' command to perform
 908 /// all subcommands; this relies on gcc translating the majority of
 909 /// command line options.
 910
 911 /// \brief Parse a GCCVersion object out of a string of text.
 912 ///
 913 /// This is the primary means of forming GCCVersion objects.
 914 /*static*/
 915 Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) {
 916   const GCCVersion BadVersion = { VersionText.str(), -1, -1, -1, "" };
 917   std::pair<StringRef, StringRef> First = VersionText.split('.');
 918   std::pair<StringRef, StringRef> Second = First.second.split('.');
 919
 920   GCCVersion GoodVersion = { VersionText.str(), -1, -1, -1, "" };
 921   if (First.first.getAsInteger(10, GoodVersion.Major) ||
 922       GoodVersion.Major < 0)
 923     return BadVersion;
 924   if (Second.first.getAsInteger(10, GoodVersion.Minor) ||
 925       GoodVersion.Minor < 0)
 926     return BadVersion;
 927
 928   // First look for a number prefix and parse that if present. Otherwise just
 929   // stash the entire patch string in the suffix, and leave the number
 930   // unspecified. This covers versions strings such as:
 931   //   4.4
 932   //   4.4.0
 933   //   4.4.x
 934   //   4.4.2-rc4
 935   //   4.4.x-patched
 936   // And retains any patch number it finds.
 937   StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
 938   if (!PatchText.empty()) {
 939     if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
 940       // Try to parse the number and any suffix.
 941       if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
 942           GoodVersion.Patch < 0)
 943         return BadVersion;
 944       GoodVersion.PatchSuffix = PatchText.substr(EndNumber).str();
 945     }
 946   }
 947
 948   return GoodVersion;
 949 }
 950
 951 /// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering.
 952 bool Generic_GCC::GCCVersion::operator<(const GCCVersion &RHS) const {
 953   if (Major != RHS.Major)
 954     return Major < RHS.Major;
 955   if (Minor != RHS.Minor)
 956     return Minor < RHS.Minor;
 957   if (Patch != RHS.Patch) {
 958     // Note that versions without a specified patch sort higher than those with
 959     // a patch.
 960     if (RHS.Patch == -1)
 961       return true;
 962     if (Patch == -1)
 963       return false;
 964
 965     // Otherwise just sort on the patch itself.
 966     return Patch < RHS.Patch;
 967   }
 968   if (PatchSuffix != RHS.PatchSuffix) {
 969     // Sort empty suffixes higher.
 970     if (RHS.PatchSuffix.empty())
 971       return true;
 972     if (PatchSuffix.empty())
 973       return false;
 974
 975     // Provide a lexicographic sort to make this a total ordering.
 976     return PatchSuffix < RHS.PatchSuffix;
 977   }
 978
 979   // The versions are equal.
 980   return false;
 981 }
 982
 983 static StringRef getGCCToolchainDir(const ArgList &Args) {
 984   const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
 985   if (A)
 986     return A->getValue();
 987   return GCC_INSTALL_PREFIX;
 988 }
 989
 990 /// \brief Construct a GCCInstallationDetector from the driver.
 991 ///
 992 /// This performs all of the autodetection and sets up the various paths.
 993 /// Once constructed, a GCCInstallationDetector is essentially immutable.
 994 ///
 995 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
 996 /// should instead pull the target out of the driver. This is currently
 997 /// necessary because the driver doesn't store the final version of the target
 998 /// triple.
 999 Generic_GCC::GCCInstallationDetector::GCCInstallationDetector(
1000     const Driver &D,
1001     const llvm::Triple &TargetTriple,
1002     const ArgList &Args)
1003     : IsValid(false) {
1004   llvm::Triple MultiarchTriple
1005     = TargetTriple.isArch32Bit() ? TargetTriple.get64BitArchVariant()
1006                                  : TargetTriple.get32BitArchVariant();
1007   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1008   // The library directories which may contain GCC installations.
1009   SmallVector<StringRef, 4> CandidateLibDirs, CandidateMultiarchLibDirs;
1010   // The compatible GCC triples for this particular architecture.
1011   SmallVector<StringRef, 10> CandidateTripleAliases;
1012   SmallVector<StringRef, 10> CandidateMultiarchTripleAliases;
1013   CollectLibDirsAndTriples(TargetTriple, MultiarchTriple, CandidateLibDirs,
1014                            CandidateTripleAliases,
1015                            CandidateMultiarchLibDirs,
1016                            CandidateMultiarchTripleAliases);
1017
1018   // Compute the set of prefixes for our search.
1019   SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1020                                        D.PrefixDirs.end());
1021
1022   StringRef GCCToolchainDir = getGCCToolchainDir(Args);
1023   if (GCCToolchainDir != "") {
1024     if (GCCToolchainDir.back() == '/')
1025       GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1026
1027     Prefixes.push_back(GCCToolchainDir);
1028   } else {
1029     Prefixes.push_back(D.SysRoot);
1030     Prefixes.push_back(D.SysRoot + "/usr");
1031     Prefixes.push_back(D.InstalledDir + "/..");
1032   }
1033
1034   // Loop over the various components which exist and select the best GCC
1035   // installation available. GCC installs are ranked by version number.
1036   Version = GCCVersion::Parse("0.0.0");
1037   for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) {
1038     if (!llvm::sys::fs::exists(Prefixes[i]))
1039       continue;
1040     for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) {
1041       const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str();
1042       if (!llvm::sys::fs::exists(LibDir))
1043         continue;
1044       for (unsigned k = 0, ke = CandidateTripleAliases.size(); k < ke; ++k)
1045         ScanLibDirForGCCTriple(TargetArch, Args, LibDir,
1046                                CandidateTripleAliases[k]);
1047     }
1048     for (unsigned j = 0, je = CandidateMultiarchLibDirs.size(); j < je; ++j) {
1049       const std::string LibDir
1050         = Prefixes[i] + CandidateMultiarchLibDirs[j].str();
1051       if (!llvm::sys::fs::exists(LibDir))
1052         continue;
1053       for (unsigned k = 0, ke = CandidateMultiarchTripleAliases.size(); k < ke;
1054            ++k)
1055         ScanLibDirForGCCTriple(TargetArch, Args, LibDir,
1056                                CandidateMultiarchTripleAliases[k],
1057                                /*NeedsMultiarchSuffix=*/true);
1058     }
1059   }
1060 }
1061
1062 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1063     const llvm::Triple &TargetTriple,
1064     const llvm::Triple &MultiarchTriple,
1065     SmallVectorImpl<StringRef> &LibDirs,
1066     SmallVectorImpl<StringRef> &TripleAliases,
1067     SmallVectorImpl<StringRef> &MultiarchLibDirs,
1068     SmallVectorImpl<StringRef> &MultiarchTripleAliases) {
1069   // Declare a bunch of static data sets that we'll select between below. These
1070   // are specifically designed to always refer to string literals to avoid any
1071   // lifetime or initialization issues.
1072   static const char *const AArch64LibDirs[] = { "/lib" };
1073   static const char *const AArch64Triples[] = {
1074     "aarch64-none-linux-gnu",
1075     "aarch64-linux-gnu"
1076   };
1077
1078   static const char *const ARMLibDirs[] = { "/lib" };
1079   static const char *const ARMTriples[] = {
1080     "arm-linux-gnueabi",
1081     "arm-linux-androideabi"
1082   };
1083   static const char *const ARMHFTriples[] = {
1084     "arm-linux-gnueabihf",
1085   };
1086
1087   static const char *const X86_64LibDirs[] = { "/lib64", "/lib" };
1088   static const char *const X86_64Triples[] = {
1089     "x86_64-linux-gnu",
1090     "x86_64-unknown-linux-gnu",
1091     "x86_64-pc-linux-gnu",
1092     "x86_64-redhat-linux6E",
1093     "x86_64-redhat-linux",
1094     "x86_64-suse-linux",
1095     "x86_64-manbo-linux-gnu",
1096     "x86_64-linux-gnu",
1097     "x86_64-slackware-linux"
1098   };
1099   static const char *const X86LibDirs[] = { "/lib32", "/lib" };
1100   static const char *const X86Triples[] = {
1101     "i686-linux-gnu",
1102     "i686-pc-linux-gnu",
1103     "i486-linux-gnu",
1104     "i386-linux-gnu",
1105     "i386-redhat-linux6E",
1106     "i686-redhat-linux",
1107     "i586-redhat-linux",
1108     "i386-redhat-linux",
1109     "i586-suse-linux",
1110     "i486-slackware-linux",
1111     "i686-montavista-linux"
1112   };
1113
1114   static const char *const MIPSLibDirs[] = { "/lib" };
1115   static const char *const MIPSTriples[] = { "mips-linux-gnu" };
1116   static const char *const MIPSELLibDirs[] = { "/lib" };
1117   static const char *const MIPSELTriples[] = {
1118     "mipsel-linux-gnu",
1119     "mipsel-linux-android"
1120   };
1121
1122   static const char *const MIPS64LibDirs[] = { "/lib64", "/lib" };
1123   static const char *const MIPS64Triples[] = { "mips64-linux-gnu" };
1124   static const char *const MIPS64ELLibDirs[] = { "/lib64", "/lib" };
1125   static const char *const MIPS64ELTriples[] = { "mips64el-linux-gnu" };
1126
1127   static const char *const PPCLibDirs[] = { "/lib32", "/lib" };
1128   static const char *const PPCTriples[] = {
1129     "powerpc-linux-gnu",
1130     "powerpc-unknown-linux-gnu",
1131     "powerpc-linux-gnuspe",
1132     "powerpc-suse-linux",
1133     "powerpc-montavista-linuxspe"
1134   };
1135   static const char *const PPC64LibDirs[] = { "/lib64", "/lib" };
1136   static const char *const PPC64Triples[] = {
1137     "powerpc64-linux-gnu",
1138     "powerpc64-unknown-linux-gnu",
1139     "powerpc64-suse-linux",
1140     "ppc64-redhat-linux"
1141   };
1142
1143   switch (TargetTriple.getArch()) {
1144   case llvm::Triple::aarch64:
1145     LibDirs.append(AArch64LibDirs, AArch64LibDirs
1146                    + llvm::array_lengthof(AArch64LibDirs));
1147     TripleAliases.append(
1148       AArch64Triples, AArch64Triples + llvm::array_lengthof(AArch64Triples));
1149     MultiarchLibDirs.append(
1150       AArch64LibDirs, AArch64LibDirs + llvm::array_lengthof(AArch64LibDirs));
1151     MultiarchTripleAliases.append(
1152       AArch64Triples, AArch64Triples + llvm::array_lengthof(AArch64Triples));
1153     break;
1154   case llvm::Triple::arm:
1155   case llvm::Triple::thumb:
1156     LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs));
1157     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1158       TripleAliases.append(
1159         ARMHFTriples, ARMHFTriples + llvm::array_lengthof(ARMHFTriples));
1160     } else {
1161       TripleAliases.append(
1162         ARMTriples, ARMTriples + llvm::array_lengthof(ARMTriples));
1163     }
1164     break;
1165   case llvm::Triple::x86_64:
1166     LibDirs.append(
1167       X86_64LibDirs, X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1168     TripleAliases.append(
1169       X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples));
1170     MultiarchLibDirs.append(
1171       X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1172     MultiarchTripleAliases.append(
1173       X86Triples, X86Triples + llvm::array_lengthof(X86Triples));
1174     break;
1175   case llvm::Triple::x86:
1176     LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1177     TripleAliases.append(
1178       X86Triples, X86Triples + llvm::array_lengthof(X86Triples));
1179     MultiarchLibDirs.append(
1180       X86_64LibDirs, X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1181     MultiarchTripleAliases.append(
1182       X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples));
1183     break;
1184   case llvm::Triple::mips:
1185     LibDirs.append(
1186       MIPSLibDirs, MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1187     TripleAliases.append(
1188       MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples));
1189     MultiarchLibDirs.append(
1190       MIPS64LibDirs, MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1191     MultiarchTripleAliases.append(
1192       MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1193     break;
1194   case llvm::Triple::mipsel:
1195     LibDirs.append(
1196       MIPSELLibDirs, MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1197     TripleAliases.append(
1198       MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1199     MultiarchLibDirs.append(
1200       MIPS64ELLibDirs, MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1201     MultiarchTripleAliases.append(
1202       MIPS64ELTriples, MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1203     break;
1204   case llvm::Triple::mips64:
1205     LibDirs.append(
1206       MIPS64LibDirs, MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1207     TripleAliases.append(
1208       MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1209     MultiarchLibDirs.append(
1210       MIPSLibDirs, MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1211     MultiarchTripleAliases.append(
1212       MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples));
1213     break;
1214   case llvm::Triple::mips64el:
1215     LibDirs.append(
1216       MIPS64ELLibDirs, MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1217     TripleAliases.append(
1218       MIPS64ELTriples, MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1219     MultiarchLibDirs.append(
1220       MIPSELLibDirs, MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1221     MultiarchTripleAliases.append(
1222       MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1223     break;
1224   case llvm::Triple::ppc:
1225     LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1226     TripleAliases.append(
1227       PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples));
1228     MultiarchLibDirs.append(
1229       PPC64LibDirs, PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1230     MultiarchTripleAliases.append(
1231       PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples));
1232     break;
1233   case llvm::Triple::ppc64:
1234     LibDirs.append(
1235       PPC64LibDirs, PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1236     TripleAliases.append(
1237       PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples));
1238     MultiarchLibDirs.append(
1239       PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1240     MultiarchTripleAliases.append(
1241       PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples));
1242     break;
1243
1244   default:
1245     // By default, just rely on the standard lib directories and the original
1246     // triple.
1247     break;
1248   }
1249
1250   // Always append the drivers target triple to the end, in case it doesn't
1251   // match any of our aliases.
1252   TripleAliases.push_back(TargetTriple.str());
1253
1254   // Also include the multiarch variant if it's different.
1255   if (TargetTriple.str() != MultiarchTriple.str())
1256     MultiarchTripleAliases.push_back(MultiarchTriple.str());
1257 }
1258
1259 // FIXME: There is the same routine in the Tools.cpp.
1260 static bool hasMipsN32ABIArg(const ArgList &Args) {
1261   Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1262   return A && (A->getValue() == StringRef("n32"));
1263 }
1264
1265 static StringRef getTargetMultiarchSuffix(llvm::Triple::ArchType TargetArch,
1266                                           const ArgList &Args) {
1267   if (TargetArch == llvm::Triple::x86_64 ||
1268       TargetArch == llvm::Triple::ppc64)
1269     return "/64";
1270
1271   if (TargetArch == llvm::Triple::mips64 ||
1272       TargetArch == llvm::Triple::mips64el) {
1273     if (hasMipsN32ABIArg(Args))
1274       return "/n32";
1275     else
1276       return "/64";
1277   }
1278
1279   return "/32";
1280 }
1281
1282 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
1283     llvm::Triple::ArchType TargetArch, const ArgList &Args,
1284     const std::string &LibDir,
1285     StringRef CandidateTriple, bool NeedsMultiarchSuffix) {
1286   // There are various different suffixes involving the triple we
1287   // check for. We also record what is necessary to walk from each back
1288   // up to the lib directory.
1289   const std::string LibSuffixes[] = {
1290     "/gcc/" + CandidateTriple.str(),
1291     "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
1292
1293     // The Freescale PPC SDK has the gcc libraries in
1294     // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well.
1295     "/" + CandidateTriple.str(),
1296
1297     // Ubuntu has a strange mis-matched pair of triples that this happens to
1298     // match.
1299     // FIXME: It may be worthwhile to generalize this and look for a second
1300     // triple.
1301     "/i386-linux-gnu/gcc/" + CandidateTriple.str()
1302   };
1303   const std::string InstallSuffixes[] = {
1304     "/../../..",
1305     "/../../../..",
1306     "/../..",
1307     "/../../../.."
1308   };
1309   // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
1310   const unsigned NumLibSuffixes = (llvm::array_lengthof(LibSuffixes) -
1311                                    (TargetArch != llvm::Triple::x86));
1312   for (unsigned i = 0; i < NumLibSuffixes; ++i) {
1313     StringRef LibSuffix = LibSuffixes[i];
1314     llvm::error_code EC;
1315     for (llvm::sys::fs::directory_iterator LI(LibDir + LibSuffix, EC), LE;
1316          !EC && LI != LE; LI = LI.increment(EC)) {
1317       StringRef VersionText = llvm::sys::path::filename(LI->path());
1318       GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1319       static const GCCVersion MinVersion = { "4.1.1", 4, 1, 1, "" };
1320       if (CandidateVersion < MinVersion)
1321         continue;
1322       if (CandidateVersion <= Version)
1323         continue;
1324
1325       // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1326       // in what would normally be GCCInstallPath and put the 64-bit
1327       // libs in a subdirectory named 64. The simple logic we follow is that
1328       // *if* there is a subdirectory of the right name with crtbegin.o in it,
1329       // we use that. If not, and if not a multiarch triple, we look for
1330       // crtbegin.o without the subdirectory.
1331       StringRef MultiarchSuffix = getTargetMultiarchSuffix(TargetArch, Args);
1332       if (llvm::sys::fs::exists(LI->path() + MultiarchSuffix + "/crtbegin.o")) {
1333         GCCMultiarchSuffix = MultiarchSuffix.str();
1334       } else {
1335         if (NeedsMultiarchSuffix ||
1336             !llvm::sys::fs::exists(LI->path() + "/crtbegin.o"))
1337           continue;
1338         GCCMultiarchSuffix.clear();
1339       }
1340
1341       Version = CandidateVersion;
1342       GCCTriple.setTriple(CandidateTriple);
1343       // FIXME: We hack together the directory name here instead of
1344       // using LI to ensure stable path separators across Windows and
1345       // Linux.
1346       GCCInstallPath = LibDir + LibSuffixes[i] + "/" + VersionText.str();
1347       GCCParentLibPath = GCCInstallPath + InstallSuffixes[i];
1348       IsValid = true;
1349     }
1350   }
1351 }
1352
1353 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple& Triple,
1354                          const ArgList &Args)
1355   : ToolChain(D, Triple, Args), GCCInstallation(getDriver(), Triple, Args) {
1356   getProgramPaths().push_back(getDriver().getInstalledDir());
1357   if (getDriver().getInstalledDir() != getDriver().Dir)
1358     getProgramPaths().push_back(getDriver().Dir);
1359 }
1360
1361 Generic_GCC::~Generic_GCC() {
1362 }
1363
1364 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
1365   switch (AC) {
1366   case Action::PreprocessJobClass:
1367     if (!Preprocess)
1368       Preprocess.reset(new tools::gcc::Preprocess(*this));
1369     return Preprocess.get();
1370   case Action::PrecompileJobClass:
1371     if (!Precompile)
1372       Precompile.reset(new tools::gcc::Precompile(*this));
1373     return Precompile.get();
1374   case Action::CompileJobClass:
1375     if (!Compile)
1376       Compile.reset(new tools::gcc::Compile(*this));
1377     return Compile.get();
1378   default:
1379     return ToolChain::getTool(AC);
1380   }
1381 }
1382
1383 Tool *Generic_GCC::buildAssembler() const {
1384   return new tools::gcc::Assemble(*this);
1385 }
1386
1387 Tool *Generic_GCC::buildLinker() const {
1388   return new tools::gcc::Link(*this);
1389 }
1390
1391 bool Generic_GCC::IsUnwindTablesDefault() const {
1392   return getArch() == llvm::Triple::x86_64;
1393 }
1394
1395 bool Generic_GCC::isPICDefault() const {
1396   return false;
1397 }
1398
1399 bool Generic_GCC::isPICDefaultForced() const {
1400   return false;
1401 }
1402
1403 /// Hexagon Toolchain
1404
1405 std::string Hexagon_TC::GetGnuDir(const std::string &InstalledDir) {
1406
1407   // Locate the rest of the toolchain ...
1408   if (strlen(GCC_INSTALL_PREFIX))
1409     return std::string(GCC_INSTALL_PREFIX);
1410
1411   std::string InstallRelDir = InstalledDir + "/../../gnu";
1412   if (llvm::sys::fs::exists(InstallRelDir))
1413     return InstallRelDir;
1414
1415   std::string PrefixRelDir = std::string(LLVM_PREFIX) + "/../gnu";
1416   if (llvm::sys::fs::exists(PrefixRelDir))
1417     return PrefixRelDir;
1418
1419   return InstallRelDir;
1420 }
1421
1422 static void GetHexagonLibraryPaths(
1423   const ArgList &Args,
1424   const std::string Ver,
1425   const std::string MarchString,
1426   const std::string &InstalledDir,
1427   ToolChain::path_list *LibPaths)
1428 {
1429   bool buildingLib = Args.hasArg(options::OPT_shared);
1430
1431   //----------------------------------------------------------------------------
1432   // -L Args
1433   //----------------------------------------------------------------------------
1434   for (arg_iterator
1435          it = Args.filtered_begin(options::OPT_L),
1436          ie = Args.filtered_end();
1437        it != ie;
1438        ++it) {
1439     for (unsigned i = 0, e = (*it)->getNumValues(); i != e; ++i)
1440       LibPaths->push_back((*it)->getValue(i));
1441   }
1442
1443   //----------------------------------------------------------------------------
1444   // Other standard paths
1445   //----------------------------------------------------------------------------
1446   const std::string MarchSuffix = "/" + MarchString;
1447   const std::string G0Suffix = "/G0";
1448   const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
1449   const std::string RootDir = Hexagon_TC::GetGnuDir(InstalledDir) + "/";
1450
1451   // lib/gcc/hexagon/...
1452   std::string LibGCCHexagonDir = RootDir + "lib/gcc/hexagon/";
1453   if (buildingLib) {
1454     LibPaths->push_back(LibGCCHexagonDir + Ver + MarchG0Suffix);
1455     LibPaths->push_back(LibGCCHexagonDir + Ver + G0Suffix);
1456   }
1457   LibPaths->push_back(LibGCCHexagonDir + Ver + MarchSuffix);
1458   LibPaths->push_back(LibGCCHexagonDir + Ver);
1459
1460   // lib/gcc/...
1461   LibPaths->push_back(RootDir + "lib/gcc");
1462
1463   // hexagon/lib/...
1464   std::string HexagonLibDir = RootDir + "hexagon/lib";
1465   if (buildingLib) {
1466     LibPaths->push_back(HexagonLibDir + MarchG0Suffix);
1467     LibPaths->push_back(HexagonLibDir + G0Suffix);
1468   }
1469   LibPaths->push_back(HexagonLibDir + MarchSuffix);
1470   LibPaths->push_back(HexagonLibDir);
1471 }
1472
1473 Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple,
1474                        const ArgList &Args)
1475   : Linux(D, Triple, Args) {
1476   const std::string InstalledDir(getDriver().getInstalledDir());
1477   const std::string GnuDir = Hexagon_TC::GetGnuDir(InstalledDir);
1478
1479   // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
1480   // program paths
1481   const std::string BinDir(GnuDir + "/bin");
1482   if (llvm::sys::fs::exists(BinDir))
1483     getProgramPaths().push_back(BinDir);
1484
1485   // Determine version of GCC libraries and headers to use.
1486   const std::string HexagonDir(GnuDir + "/lib/gcc/hexagon");
1487   llvm::error_code ec;
1488   GCCVersion MaxVersion= GCCVersion::Parse("0.0.0");
1489   for (llvm::sys::fs::directory_iterator di(HexagonDir, ec), de;
1490        !ec && di != de; di = di.increment(ec)) {
1491     GCCVersion cv = GCCVersion::Parse(llvm::sys::path::filename(di->path()));
1492     if (MaxVersion < cv)
1493       MaxVersion = cv;
1494   }
1495   GCCLibAndIncVersion = MaxVersion;
1496
1497   ToolChain::path_list *LibPaths= &getFilePaths();
1498
1499   // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
1500   // 'elf' OS type, so the Linux paths are not appropriate. When we actually
1501   // support 'linux' we'll need to fix this up
1502   LibPaths->clear();
1503
1504   GetHexagonLibraryPaths(
1505     Args,
1506     GetGCCLibAndIncVersion(),
1507     GetTargetCPU(Args),
1508     InstalledDir,
1509     LibPaths);
1510 }
1511
1512 Hexagon_TC::~Hexagon_TC() {
1513 }
1514
1515 Tool *Hexagon_TC::buildAssembler() const {
1516   return new tools::hexagon::Assemble(*this);
1517 }
1518
1519 Tool *Hexagon_TC::buildLinker() const {
1520   return new tools::hexagon::Link(*this);
1521 }
1522
1523 void Hexagon_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
1524                                            ArgStringList &CC1Args) const {
1525   const Driver &D = getDriver();
1526
1527   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
1528       DriverArgs.hasArg(options::OPT_nostdlibinc))
1529     return;
1530
1531   llvm::sys::Path InstallDir(D.InstalledDir);
1532   std::string Ver(GetGCCLibAndIncVersion());
1533   std::string GnuDir = Hexagon_TC::GetGnuDir(D.InstalledDir);
1534   std::string HexagonDir(GnuDir + "/lib/gcc/hexagon/" + Ver);
1535   addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include");
1536   addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include-fixed");
1537   addExternCSystemInclude(DriverArgs, CC1Args, GnuDir + "/hexagon/include");
1538 }
1539
1540 void Hexagon_TC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1541                                               ArgStringList &CC1Args) const {
1542
1543   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1544       DriverArgs.hasArg(options::OPT_nostdincxx))
1545     return;
1546
1547   const Driver &D = getDriver();
1548   std::string Ver(GetGCCLibAndIncVersion());
1549   llvm::sys::Path IncludeDir(Hexagon_TC::GetGnuDir(D.InstalledDir));
1550
1551   IncludeDir.appendComponent("hexagon/include/c++/");
1552   IncludeDir.appendComponent(Ver);
1553   addSystemInclude(DriverArgs, CC1Args, IncludeDir.str());
1554 }
1555
1556 ToolChain::CXXStdlibType
1557 Hexagon_TC::GetCXXStdlibType(const ArgList &Args) const {
1558   Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1559   if (!A)
1560     return ToolChain::CST_Libstdcxx;
1561
1562   StringRef Value = A->getValue();
1563   if (Value != "libstdc++") {
1564     getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1565       << A->getAsString(Args);
1566   }
1567
1568   return ToolChain::CST_Libstdcxx;
1569 }
1570
1571 static Arg *GetLastHexagonArchArg(const ArgList &Args)
1572 {
1573   Arg *A = NULL;
1574
1575   for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
1576        it != ie; ++it) {
1577     if ((*it)->getOption().matches(options::OPT_march_EQ) ||
1578         (*it)->getOption().matches(options::OPT_mcpu_EQ)) {
1579       A = *it;
1580       A->claim();
1581     } else if ((*it)->getOption().matches(options::OPT_m_Joined)) {
1582       StringRef Value = (*it)->getValue(0);
1583       if (Value.startswith("v")) {
1584         A = *it;
1585         A->claim();
1586       }
1587     }
1588   }
1589   return A;
1590 }
1591
1592 StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args)
1593 {
1594   // Select the default CPU (v4) if none was given or detection failed.
1595   Arg *A = GetLastHexagonArchArg (Args);
1596   if (A) {
1597     StringRef WhichHexagon = A->getValue();
1598     if (WhichHexagon.startswith("hexagon"))
1599       return WhichHexagon.substr(sizeof("hexagon") - 1);
1600     if (WhichHexagon != "")
1601       return WhichHexagon;
1602   }
1603
1604   return "v4";
1605 }
1606 // End Hexagon
1607
1608 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1609 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1610 /// Currently does not support anything else but compilation.
1611
1612 TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple,
1613                            const ArgList &Args)
1614   : ToolChain(D, Triple, Args) {
1615   // Path mangling to find libexec
1616   std::string Path(getDriver().Dir);
1617
1618   Path += "/../libexec";
1619   getProgramPaths().push_back(Path);
1620 }
1621
1622 TCEToolChain::~TCEToolChain() {
1623 }
1624
1625 bool TCEToolChain::IsMathErrnoDefault() const {
1626   return true;
1627 }
1628
1629 bool TCEToolChain::isPICDefault() const {
1630   return false;
1631 }
1632
1633 bool TCEToolChain::isPICDefaultForced() const {
1634   return false;
1635 }
1636
1637 /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1638
1639 OpenBSD::OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1640   : Generic_ELF(D, Triple, Args) {
1641   getFilePaths().push_back(getDriver().Dir + "/../lib");
1642   getFilePaths().push_back("/usr/lib");
1643 }
1644
1645 Tool *OpenBSD::buildAssembler() const {
1646   return new tools::openbsd::Assemble(*this);
1647 }
1648
1649 Tool *OpenBSD::buildLinker() const {
1650   return new tools::openbsd::Link(*this);
1651 }
1652
1653 /// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
1654
1655 Bitrig::Bitrig(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1656   : Generic_ELF(D, Triple, Args) {
1657   getFilePaths().push_back(getDriver().Dir + "/../lib");
1658   getFilePaths().push_back("/usr/lib");
1659 }
1660
1661 Tool *Bitrig::buildAssembler() const {
1662   return new tools::bitrig::Assemble(*this);
1663 }
1664
1665 Tool *Bitrig::buildLinker() const {
1666   return new tools::bitrig::Link(*this);
1667 }
1668
1669 void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1670                                           ArgStringList &CC1Args) const {
1671   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1672       DriverArgs.hasArg(options::OPT_nostdincxx))
1673     return;
1674
1675   switch (GetCXXStdlibType(DriverArgs)) {
1676   case ToolChain::CST_Libcxx:
1677     addSystemInclude(DriverArgs, CC1Args,
1678                      getDriver().SysRoot + "/usr/include/c++/");
1679     break;
1680   case ToolChain::CST_Libstdcxx:
1681     addSystemInclude(DriverArgs, CC1Args,
1682                      getDriver().SysRoot + "/usr/include/c++/stdc++");
1683     addSystemInclude(DriverArgs, CC1Args,
1684                      getDriver().SysRoot + "/usr/include/c++/stdc++/backward");
1685
1686     StringRef Triple = getTriple().str();
1687     if (Triple.startswith("amd64"))
1688       addSystemInclude(DriverArgs, CC1Args,
1689                        getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" +
1690                        Triple.substr(5));
1691     else
1692       addSystemInclude(DriverArgs, CC1Args,
1693                        getDriver().SysRoot + "/usr/include/c++/stdc++/" +
1694                        Triple);
1695     break;
1696   }
1697 }
1698
1699 void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
1700                                  ArgStringList &CmdArgs) const {
1701   switch (GetCXXStdlibType(Args)) {
1702   case ToolChain::CST_Libcxx:
1703     CmdArgs.push_back("-lc++");
1704     CmdArgs.push_back("-lcxxrt");
1705     // Include supc++ to provide Unwind until provided by libcxx.
1706     CmdArgs.push_back("-lgcc");
1707     break;
1708   case ToolChain::CST_Libstdcxx:
1709     CmdArgs.push_back("-lstdc++");
1710     break;
1711   }
1712 }
1713
1714 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1715
1716 FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1717   : Generic_ELF(D, Triple, Args) {
1718
1719   // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
1720   // back to '/usr/lib' if it doesn't exist.
1721   if ((Triple.getArch() == llvm::Triple::x86 ||
1722        Triple.getArch() == llvm::Triple::ppc) &&
1723       llvm::sys::fs::exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
1724     getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
1725   else
1726     getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
1727 }
1728
1729 Tool *FreeBSD::buildAssembler() const {
1730   return new tools::freebsd::Assemble(*this);
1731 }
1732
1733 Tool *FreeBSD::buildLinker() const {
1734   return new tools::freebsd::Link(*this);
1735 }
1736
1737 bool FreeBSD::UseSjLjExceptions() const {
1738   // FreeBSD uses SjLj exceptions on ARM oabi.
1739   switch (getTriple().getEnvironment()) {
1740   case llvm::Triple::GNUEABI:
1741   case llvm::Triple::EABI:
1742     return false;
1743
1744   default:
1745     return (getTriple().getArch() == llvm::Triple::arm ||
1746             getTriple().getArch() == llvm::Triple::thumb);
1747   }
1748 }
1749
1750 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
1751
1752 NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1753   : Generic_ELF(D, Triple, Args) {
1754
1755   if (getDriver().UseStdLib) {
1756     // When targeting a 32-bit platform, try the special directory used on
1757     // 64-bit hosts, and only fall back to the main library directory if that
1758     // doesn't work.
1759     // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
1760     // what all logic is needed to emulate the '=' prefix here.
1761     if (Triple.getArch() == llvm::Triple::x86)
1762       getFilePaths().push_back("=/usr/lib/i386");
1763
1764     getFilePaths().push_back("=/usr/lib");
1765   }
1766 }
1767
1768 Tool *NetBSD::buildAssembler() const {
1769   return new tools::netbsd::Assemble(*this);
1770 }
1771
1772 Tool *NetBSD::buildLinker() const {
1773   return new tools::netbsd::Link(*this);
1774 }
1775
1776 /// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1777
1778 Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1779   : Generic_ELF(D, Triple, Args) {
1780   getFilePaths().push_back(getDriver().Dir + "/../lib");
1781   getFilePaths().push_back("/usr/lib");
1782 }
1783
1784 Tool *Minix::buildAssembler() const {
1785   return new tools::minix::Assemble(*this);
1786 }
1787
1788 Tool *Minix::buildLinker() const {
1789   return new tools::minix::Link(*this);
1790 }
1791
1792 /// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1793
1794 AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple,
1795                    const ArgList &Args)
1796   : Generic_GCC(D, Triple, Args) {
1797
1798   getProgramPaths().push_back(getDriver().getInstalledDir());
1799   if (getDriver().getInstalledDir() != getDriver().Dir)
1800     getProgramPaths().push_back(getDriver().Dir);
1801
1802   getFilePaths().push_back(getDriver().Dir + "/../lib");
1803   getFilePaths().push_back("/usr/lib");
1804   getFilePaths().push_back("/usr/sfw/lib");
1805   getFilePaths().push_back("/opt/gcc4/lib");
1806   getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
1807
1808 }
1809
1810 Tool *AuroraUX::buildAssembler() const {
1811   return new tools::auroraux::Assemble(*this);
1812 }
1813
1814 Tool *AuroraUX::buildLinker() const {
1815   return new tools::auroraux::Link(*this);
1816 }
1817
1818 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
1819
1820 Solaris::Solaris(const Driver &D, const llvm::Triple& Triple,
1821                  const ArgList &Args)
1822   : Generic_GCC(D, Triple, Args) {
1823
1824   getProgramPaths().push_back(getDriver().getInstalledDir());
1825   if (getDriver().getInstalledDir() != getDriver().Dir)
1826     getProgramPaths().push_back(getDriver().Dir);
1827
1828   getFilePaths().push_back(getDriver().Dir + "/../lib");
1829   getFilePaths().push_back("/usr/lib");
1830 }
1831
1832 Tool *Solaris::buildAssembler() const {
1833   return new tools::solaris::Assemble(*this);
1834 }
1835
1836 Tool *Solaris::buildLinker() const {
1837   return new tools::solaris::Link(*this);
1838 }
1839
1840 /// Distribution (very bare-bones at the moment).
1841
1842 enum Distro {
1843   ArchLinux,
1844   DebianLenny,
1845   DebianSqueeze,
1846   DebianWheezy,
1847   DebianJessie,
1848   Exherbo,
1849   RHEL4,
1850   RHEL5,
1851   RHEL6,
1852   Fedora13,
1853   Fedora14,
1854   Fedora15,
1855   Fedora16,
1856   FedoraRawhide,
1857   OpenSuse11_3,
1858   OpenSuse11_4,
1859   OpenSuse12_1,
1860   OpenSuse12_2,
1861   UbuntuHardy,
1862   UbuntuIntrepid,
1863   UbuntuJaunty,
1864   UbuntuKarmic,
1865   UbuntuLucid,
1866   UbuntuMaverick,
1867   UbuntuNatty,
1868   UbuntuOneiric,
1869   UbuntuPrecise,
1870   UbuntuQuantal,
1871   UbuntuRaring,
1872   UnknownDistro
1873 };
1874
1875 static bool IsRedhat(enum Distro Distro) {
1876   return (Distro >= Fedora13 && Distro <= FedoraRawhide) ||
1877          (Distro >= RHEL4    && Distro <= RHEL6);
1878 }
1879
1880 static bool IsOpenSuse(enum Distro Distro) {
1881   return Distro >= OpenSuse11_3 && Distro <= OpenSuse12_2;
1882 }
1883
1884 static bool IsDebian(enum Distro Distro) {
1885   return Distro >= DebianLenny && Distro <= DebianJessie;
1886 }
1887
1888 static bool IsUbuntu(enum Distro Distro) {
1889   return Distro >= UbuntuHardy && Distro <= UbuntuRaring;
1890 }
1891
1892 static Distro DetectDistro(llvm::Triple::ArchType Arch) {
1893   OwningPtr<llvm::MemoryBuffer> File;
1894   if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
1895     StringRef Data = File.get()->getBuffer();
1896     SmallVector<StringRef, 8> Lines;
1897     Data.split(Lines, "\n");
1898     Distro Version = UnknownDistro;
1899     for (unsigned i = 0, s = Lines.size(); i != s; ++i)
1900       if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME="))
1901         Version = llvm::StringSwitch<Distro>(Lines[i].substr(17))
1902           .Case("hardy", UbuntuHardy)
1903           .Case("intrepid", UbuntuIntrepid)
1904           .Case("jaunty", UbuntuJaunty)
1905           .Case("karmic", UbuntuKarmic)
1906           .Case("lucid", UbuntuLucid)
1907           .Case("maverick", UbuntuMaverick)
1908           .Case("natty", UbuntuNatty)
1909           .Case("oneiric", UbuntuOneiric)
1910           .Case("precise", UbuntuPrecise)
1911           .Case("quantal", UbuntuQuantal)
1912           .Case("raring", UbuntuRaring)
1913           .Default(UnknownDistro);
1914     return Version;
1915   }
1916
1917   if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
1918     StringRef Data = File.get()->getBuffer();
1919     if (Data.startswith("Fedora release 16"))
1920       return Fedora16;
1921     else if (Data.startswith("Fedora release 15"))
1922       return Fedora15;
1923     else if (Data.startswith("Fedora release 14"))
1924       return Fedora14;
1925     else if (Data.startswith("Fedora release 13"))
1926       return Fedora13;
1927     else if (Data.startswith("Fedora release") &&
1928              Data.find("Rawhide") != StringRef::npos)
1929       return FedoraRawhide;
1930     else if (Data.startswith("Red Hat Enterprise Linux") &&
1931              Data.find("release 6") != StringRef::npos)
1932       return RHEL6;
1933     else if ((Data.startswith("Red Hat Enterprise Linux") ||
1934               Data.startswith("CentOS")) &&
1935              Data.find("release 5") != StringRef::npos)
1936       return RHEL5;
1937     else if ((Data.startswith("Red Hat Enterprise Linux") ||
1938               Data.startswith("CentOS")) &&
1939              Data.find("release 4") != StringRef::npos)
1940       return RHEL4;
1941     return UnknownDistro;
1942   }
1943
1944   if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
1945     StringRef Data = File.get()->getBuffer();
1946     if (Data[0] == '5')
1947       return DebianLenny;
1948     else if (Data.startswith("squeeze/sid") || Data[0] == '6')
1949       return DebianSqueeze;
1950     else if (Data.startswith("wheezy/sid")  || Data[0] == '7')
1951       return DebianWheezy;
1952     else if (Data.startswith("jessie/sid")  || Data[0] == '8')
1953       return DebianJessie;
1954     return UnknownDistro;
1955   }
1956
1957   if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File))
1958     return llvm::StringSwitch<Distro>(File.get()->getBuffer())
1959       .StartsWith("openSUSE 11.3", OpenSuse11_3)
1960       .StartsWith("openSUSE 11.4", OpenSuse11_4)
1961       .StartsWith("openSUSE 12.1", OpenSuse12_1)
1962       .StartsWith("openSUSE 12.2", OpenSuse12_2)
1963       .Default(UnknownDistro);
1964
1965   bool Exists;
1966   if (!llvm::sys::fs::exists("/etc/exherbo-release", Exists) && Exists)
1967     return Exherbo;
1968
1969   if (!llvm::sys::fs::exists("/etc/arch-release", Exists) && Exists)
1970     return ArchLinux;
1971
1972   return UnknownDistro;
1973 }
1974
1975 /// \brief Get our best guess at the multiarch triple for a target.
1976 ///
1977 /// Debian-based systems are starting to use a multiarch setup where they use
1978 /// a target-triple directory in the library and header search paths.
1979 /// Unfortunately, this triple does not align with the vanilla target triple,
1980 /// so we provide a rough mapping here.
1981 static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
1982                                       StringRef SysRoot) {
1983   // For most architectures, just use whatever we have rather than trying to be
1984   // clever.
1985   switch (TargetTriple.getArch()) {
1986   default:
1987     return TargetTriple.str();
1988
1989     // We use the existence of '/lib/<triple>' as a directory to detect some
1990     // common linux triples that don't quite match the Clang triple for both
1991     // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
1992     // regardless of what the actual target triple is.
1993   case llvm::Triple::arm:
1994   case llvm::Triple::thumb:
1995     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1996       if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabihf"))
1997         return "arm-linux-gnueabihf";
1998     } else {
1999       if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabi"))
2000         return "arm-linux-gnueabi";
2001     }
2002     return TargetTriple.str();
2003   case llvm::Triple::x86:
2004     if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
2005       return "i386-linux-gnu";
2006     return TargetTriple.str();
2007   case llvm::Triple::x86_64:
2008     if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
2009       return "x86_64-linux-gnu";
2010     return TargetTriple.str();
2011   case llvm::Triple::aarch64:
2012     if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64-linux-gnu"))
2013       return "aarch64-linux-gnu";
2014   case llvm::Triple::mips:
2015     if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu"))
2016       return "mips-linux-gnu";
2017     return TargetTriple.str();
2018   case llvm::Triple::mipsel:
2019     if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu"))
2020       return "mipsel-linux-gnu";
2021     return TargetTriple.str();
2022   case llvm::Triple::ppc:
2023     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
2024       return "powerpc-linux-gnuspe";
2025     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu"))
2026       return "powerpc-linux-gnu";
2027     return TargetTriple.str();
2028   case llvm::Triple::ppc64:
2029     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu"))
2030       return "powerpc64-linux-gnu";
2031     return TargetTriple.str();
2032   }
2033 }
2034
2035 static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) {
2036   if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str());
2037 }
2038
2039 static bool isMipsArch(llvm::Triple::ArchType Arch) {
2040   return Arch == llvm::Triple::mips ||
2041          Arch == llvm::Triple::mipsel ||
2042          Arch == llvm::Triple::mips64 ||
2043          Arch == llvm::Triple::mips64el;
2044 }
2045
2046 static bool isMipsR2Arch(llvm::Triple::ArchType Arch,
2047                          const ArgList &Args) {
2048   if (Arch != llvm::Triple::mips &&
2049       Arch != llvm::Triple::mipsel)
2050     return false;
2051
2052   Arg *A = Args.getLastArg(options::OPT_march_EQ,
2053                            options::OPT_mcpu_EQ,
2054                            options::OPT_mips_CPUs_Group);
2055
2056   if (!A)
2057     return false;
2058
2059   if (A->getOption().matches(options::OPT_mips_CPUs_Group))
2060     return A->getOption().matches(options::OPT_mips32r2);
2061
2062   return A->getValue() == StringRef("mips32r2");
2063 }
2064
2065 static StringRef getMultilibDir(const llvm::Triple &Triple,
2066                                 const ArgList &Args) {
2067   if (!isMipsArch(Triple.getArch()))
2068     return Triple.isArch32Bit() ? "lib32" : "lib64";
2069
2070   // lib32 directory has a special meaning on MIPS targets.
2071   // It contains N32 ABI binaries. Use this folder if produce
2072   // code for N32 ABI only.
2073   if (hasMipsN32ABIArg(Args))
2074     return "lib32";
2075
2076   return Triple.isArch32Bit() ? "lib" : "lib64";
2077 }
2078
2079 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2080   : Generic_ELF(D, Triple, Args) {
2081   llvm::Triple::ArchType Arch = Triple.getArch();
2082   const std::string &SysRoot = getDriver().SysRoot;
2083
2084   // OpenSuse stores the linker with the compiler, add that to the search
2085   // path.
2086   ToolChain::path_list &PPaths = getProgramPaths();
2087   PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
2088                          GCCInstallation.getTriple().str() + "/bin").str());
2089
2090   Linker = GetProgramPath("ld");
2091
2092   Distro Distro = DetectDistro(Arch);
2093
2094   if (IsOpenSuse(Distro) || IsUbuntu(Distro)) {
2095     ExtraOpts.push_back("-z");
2096     ExtraOpts.push_back("relro");
2097   }
2098
2099   if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
2100     ExtraOpts.push_back("-X");
2101
2102   const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::Android;
2103
2104   // Do not use 'gnu' hash style for Mips targets because .gnu.hash
2105   // and the MIPS ABI require .dynsym to be sorted in different ways.
2106   // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
2107   // ABI requires a mapping between the GOT and the symbol table.
2108   // Android loader does not support .gnu.hash.
2109   if (!isMipsArch(Arch) && !IsAndroid) {
2110     if (IsRedhat(Distro) || IsOpenSuse(Distro) ||
2111         (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
2112       ExtraOpts.push_back("--hash-style=gnu");
2113
2114     if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid ||
2115         Distro == UbuntuJaunty || Distro == UbuntuKarmic)
2116       ExtraOpts.push_back("--hash-style=both");
2117   }
2118
2119   if (IsRedhat(Distro))
2120     ExtraOpts.push_back("--no-add-needed");
2121
2122   if (Distro == DebianSqueeze || Distro == DebianWheezy ||
2123       Distro == DebianJessie || IsOpenSuse(Distro) ||
2124       (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
2125       (IsUbuntu(Distro) && Distro >= UbuntuKarmic))
2126     ExtraOpts.push_back("--build-id");
2127
2128   if (IsOpenSuse(Distro))
2129     ExtraOpts.push_back("--enable-new-dtags");
2130
2131   // The selection of paths to try here is designed to match the patterns which
2132   // the GCC driver itself uses, as this is part of the GCC-compatible driver.
2133   // This was determined by running GCC in a fake filesystem, creating all
2134   // possible permutations of these directories, and seeing which ones it added
2135   // to the link paths.
2136   path_list &Paths = getFilePaths();
2137
2138   const std::string Multilib = getMultilibDir(Triple, Args);
2139   const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
2140
2141   // Add the multilib suffixed paths where they are available.
2142   if (GCCInstallation.isValid()) {
2143     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2144     const std::string &LibPath = GCCInstallation.getParentLibPath();
2145
2146     if (IsAndroid && isMipsR2Arch(Triple.getArch(), Args))
2147       addPathIfExists(GCCInstallation.getInstallPath() +
2148                       GCCInstallation.getMultiarchSuffix() +
2149                       "/mips-r2",
2150                       Paths);
2151     else
2152       addPathIfExists((GCCInstallation.getInstallPath() +
2153                        GCCInstallation.getMultiarchSuffix()),
2154                       Paths);
2155
2156     // If the GCC installation we found is inside of the sysroot, we want to
2157     // prefer libraries installed in the parent prefix of the GCC installation.
2158     // It is important to *not* use these paths when the GCC installation is
2159     // outside of the system root as that can pick up unintended libraries.
2160     // This usually happens when there is an external cross compiler on the
2161     // host system, and a more minimal sysroot available that is the target of
2162     // the cross.
2163     if (StringRef(LibPath).startswith(SysRoot)) {
2164       addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + Multilib,
2165                       Paths);
2166       addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
2167       addPathIfExists(LibPath + "/../" + Multilib, Paths);
2168     }
2169     // On Android, libraries in the parent prefix of the GCC installation are
2170     // preferred to the ones under sysroot.
2171     if (IsAndroid) {
2172       addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths);
2173     }
2174   }
2175   addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
2176   addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
2177   addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
2178   addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
2179
2180   // Try walking via the GCC triple path in case of multiarch GCC
2181   // installations with strange symlinks.
2182   if (GCCInstallation.isValid())
2183     addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
2184                     "/../../" + Multilib, Paths);
2185
2186   // Add the non-multilib suffixed paths (if potentially different).
2187   if (GCCInstallation.isValid()) {
2188     const std::string &LibPath = GCCInstallation.getParentLibPath();
2189     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2190     if (!GCCInstallation.getMultiarchSuffix().empty())
2191       addPathIfExists(GCCInstallation.getInstallPath(), Paths);
2192
2193     if (StringRef(LibPath).startswith(SysRoot)) {
2194       addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths);
2195       addPathIfExists(LibPath, Paths);
2196     }
2197   }
2198   addPathIfExists(SysRoot + "/lib", Paths);
2199   addPathIfExists(SysRoot + "/usr/lib", Paths);
2200 }
2201
2202 bool Linux::HasNativeLLVMSupport() const {
2203   return true;
2204 }
2205
2206 Tool *Linux::buildLinker() const {
2207   return new tools::gnutools::Link(*this);
2208 }
2209
2210 Tool *Linux::buildAssembler() const {
2211   return new tools::gnutools::Assemble(*this);
2212 }
2213
2214 void Linux::addClangTargetOptions(const ArgList &DriverArgs,
2215                                   ArgStringList &CC1Args) const {
2216   const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2217   bool UseInitArrayDefault
2218     = V >= Generic_GCC::GCCVersion::Parse("4.7.0") ||
2219       getTriple().getArch() == llvm::Triple::aarch64 ||
2220       getTriple().getEnvironment() == llvm::Triple::Android;
2221   if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2222                          options::OPT_fno_use_init_array,
2223                          UseInitArrayDefault))
2224     CC1Args.push_back("-fuse-init-array");
2225 }
2226
2227 void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2228                                       ArgStringList &CC1Args) const {
2229   const Driver &D = getDriver();
2230
2231   if (DriverArgs.hasArg(options::OPT_nostdinc))
2232     return;
2233
2234   if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
2235     addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include");
2236
2237   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2238     llvm::sys::Path P(D.ResourceDir);
2239     P.appendComponent("include");
2240     addSystemInclude(DriverArgs, CC1Args, P.str());
2241   }
2242
2243   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2244     return;
2245
2246   // Check for configure-time C include directories.
2247   StringRef CIncludeDirs(C_INCLUDE_DIRS);
2248   if (CIncludeDirs != "") {
2249     SmallVector<StringRef, 5> dirs;
2250     CIncludeDirs.split(dirs, ":");
2251     for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
2252          I != E; ++I) {
2253       StringRef Prefix = llvm::sys::path::is_absolute(*I) ? D.SysRoot : "";
2254       addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
2255     }
2256     return;
2257   }
2258
2259   // Lacking those, try to detect the correct set of system includes for the
2260   // target triple.
2261
2262   // Implement generic Debian multiarch support.
2263   const StringRef X86_64MultiarchIncludeDirs[] = {
2264     "/usr/include/x86_64-linux-gnu",
2265
2266     // FIXME: These are older forms of multiarch. It's not clear that they're
2267     // in use in any released version of Debian, so we should consider
2268     // removing them.
2269     "/usr/include/i686-linux-gnu/64",
2270     "/usr/include/i486-linux-gnu/64"
2271   };
2272   const StringRef X86MultiarchIncludeDirs[] = {
2273     "/usr/include/i386-linux-gnu",
2274
2275     // FIXME: These are older forms of multiarch. It's not clear that they're
2276     // in use in any released version of Debian, so we should consider
2277     // removing them.
2278     "/usr/include/x86_64-linux-gnu/32",
2279     "/usr/include/i686-linux-gnu",
2280     "/usr/include/i486-linux-gnu"
2281   };
2282   const StringRef AArch64MultiarchIncludeDirs[] = {
2283     "/usr/include/aarch64-linux-gnu"
2284   };
2285   const StringRef ARMMultiarchIncludeDirs[] = {
2286     "/usr/include/arm-linux-gnueabi"
2287   };
2288   const StringRef ARMHFMultiarchIncludeDirs[] = {
2289     "/usr/include/arm-linux-gnueabihf"
2290   };
2291   const StringRef MIPSMultiarchIncludeDirs[] = {
2292     "/usr/include/mips-linux-gnu"
2293   };
2294   const StringRef MIPSELMultiarchIncludeDirs[] = {
2295     "/usr/include/mipsel-linux-gnu"
2296   };
2297   const StringRef PPCMultiarchIncludeDirs[] = {
2298     "/usr/include/powerpc-linux-gnu"
2299   };
2300   const StringRef PPC64MultiarchIncludeDirs[] = {
2301     "/usr/include/powerpc64-linux-gnu"
2302   };
2303   ArrayRef<StringRef> MultiarchIncludeDirs;
2304   if (getTriple().getArch() == llvm::Triple::x86_64) {
2305     MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
2306   } else if (getTriple().getArch() == llvm::Triple::x86) {
2307     MultiarchIncludeDirs = X86MultiarchIncludeDirs;
2308   } else if (getTriple().getArch() == llvm::Triple::aarch64) {
2309     MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
2310   } else if (getTriple().getArch() == llvm::Triple::arm) {
2311     if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
2312       MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
2313     else
2314       MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
2315   } else if (getTriple().getArch() == llvm::Triple::mips) {
2316     MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
2317   } else if (getTriple().getArch() == llvm::Triple::mipsel) {
2318     MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
2319   } else if (getTriple().getArch() == llvm::Triple::ppc) {
2320     MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
2321   } else if (getTriple().getArch() == llvm::Triple::ppc64) {
2322     MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
2323   }
2324   for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(),
2325                                      E = MultiarchIncludeDirs.end();
2326        I != E; ++I) {
2327     if (llvm::sys::fs::exists(D.SysRoot + *I)) {
2328       addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + *I);
2329       break;
2330     }
2331   }
2332
2333   if (getTriple().getOS() == llvm::Triple::RTEMS)
2334     return;
2335
2336   // Add an include of '/include' directly. This isn't provided by default by
2337   // system GCCs, but is often used with cross-compiling GCCs, and harmless to
2338   // add even when Clang is acting as-if it were a system compiler.
2339   addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/include");
2340
2341   addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include");
2342 }
2343
2344 /// \brief Helper to add the three variant paths for a libstdc++ installation.
2345 /*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
2346                                                 const ArgList &DriverArgs,
2347                                                 ArgStringList &CC1Args) {
2348   if (!llvm::sys::fs::exists(Base))
2349     return false;
2350   addSystemInclude(DriverArgs, CC1Args, Base);
2351   addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir);
2352   addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
2353   return true;
2354 }
2355
2356 /// \brief Helper to add an extra variant path for an (Ubuntu) multilib
2357 /// libstdc++ installation.
2358 /*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
2359                                                 Twine TargetArchDir,
2360                                                 Twine MultiLibSuffix,
2361                                                 const ArgList &DriverArgs,
2362                                                 ArgStringList &CC1Args) {
2363   if (!addLibStdCXXIncludePaths(Base+Suffix, TargetArchDir + MultiLibSuffix,
2364                                 DriverArgs, CC1Args))
2365     return false;
2366
2367   addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir + Suffix
2368                    + MultiLibSuffix);
2369   return true;
2370 }
2371
2372 void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2373                                          ArgStringList &CC1Args) const {
2374   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2375       DriverArgs.hasArg(options::OPT_nostdincxx))
2376     return;
2377
2378   // Check if libc++ has been enabled and provide its include paths if so.
2379   if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
2380     // libc++ is always installed at a fixed path on Linux currently.
2381     addSystemInclude(DriverArgs, CC1Args,
2382                      getDriver().SysRoot + "/usr/include/c++/v1");
2383     return;
2384   }
2385
2386   // We need a detected GCC installation on Linux to provide libstdc++'s
2387   // headers. We handled the libc++ case above.
2388   if (!GCCInstallation.isValid())
2389     return;
2390
2391   // By default, look for the C++ headers in an include directory adjacent to
2392   // the lib directory of the GCC installation. Note that this is expect to be
2393   // equivalent to '/usr/include/c++/X.Y' in almost all cases.
2394   StringRef LibDir = GCCInstallation.getParentLibPath();
2395   StringRef InstallDir = GCCInstallation.getInstallPath();
2396   StringRef Version = GCCInstallation.getVersion().Text;
2397   StringRef TripleStr = GCCInstallation.getTriple().str();
2398
2399   if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
2400                                "/c++/" + Version.str(),
2401                                TripleStr,
2402                                GCCInstallation.getMultiarchSuffix(),
2403                                DriverArgs, CC1Args))
2404     return;
2405
2406   const std::string IncludePathCandidates[] = {
2407     // Gentoo is weird and places its headers inside the GCC install, so if the
2408     // first attempt to find the headers fails, try this pattern.
2409     InstallDir.str() + "/include/g++-v4",
2410     // Android standalone toolchain has C++ headers in yet another place.
2411     LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.str(),
2412     // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
2413     // without a subdirectory corresponding to the gcc version.
2414     LibDir.str() + "/../include/c++",
2415   };
2416
2417   for (unsigned i = 0; i < llvm::array_lengthof(IncludePathCandidates); ++i) {
2418     if (addLibStdCXXIncludePaths(IncludePathCandidates[i], (TripleStr +
2419                 GCCInstallation.getMultiarchSuffix()),
2420             DriverArgs, CC1Args))
2421       break;
2422   }
2423 }
2424
2425 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2426
2427 DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2428   : Generic_ELF(D, Triple, Args) {
2429
2430   // Path mangling to find libexec
2431   getProgramPaths().push_back(getDriver().getInstalledDir());
2432   if (getDriver().getInstalledDir() != getDriver().Dir)
2433     getProgramPaths().push_back(getDriver().Dir);
2434
2435   getFilePaths().push_back(getDriver().Dir + "/../lib");
2436   getFilePaths().push_back("/usr/lib");
2437   getFilePaths().push_back("/usr/lib/gcc41");
2438 }
2439
2440 Tool *DragonFly::buildAssembler() const {
2441   return new tools::dragonfly::Assemble(*this);
2442 }
2443
2444 Tool *DragonFly::buildLinker() const {
2445   return new tools::dragonfly::Link(*this);
2446 }