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

   1 //===--- ToolChains.cpp - ToolChain Implementations -------------*- C++ -*-===//
   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 "clang/Basic/Cuda.h"
  12 #include "clang/Basic/ObjCRuntime.h"
  13 #include "clang/Basic/Version.h"
  14 #include "clang/Basic/VirtualFileSystem.h"
  15 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
  16 #include "clang/Driver/Compilation.h"
  17 #include "clang/Driver/Driver.h"
  18 #include "clang/Driver/DriverDiagnostic.h"
  19 #include "clang/Driver/Options.h"
  20 #include "clang/Driver/SanitizerArgs.h"
  21 #include "llvm/ADT/STLExtras.h"
  22 #include "llvm/ADT/SmallString.h"
  23 #include "llvm/ADT/StringExtras.h"
  24 #include "llvm/ADT/StringSwitch.h"
  25 #include "llvm/Option/Arg.h"
  26 #include "llvm/Option/ArgList.h"
  27 #include "llvm/Option/OptTable.h"
  28 #include "llvm/Option/Option.h"
  29 #include "llvm/ProfileData/InstrProf.h"
  30 #include "llvm/Support/ErrorHandling.h"
  31 #include "llvm/Support/FileSystem.h"
  32 #include "llvm/Support/MemoryBuffer.h"
  33 #include "llvm/Support/Path.h"
  34 #include "llvm/Support/Program.h"
  35 #include "llvm/Support/TargetParser.h"
  36 #include "llvm/Support/raw_ostream.h"
  37 #include <cstdlib> // ::getenv
  38 #include <system_error>
  39
  40 using namespace clang::driver;
  41 using namespace clang::driver::toolchains;
  42 using namespace clang;
  43 using namespace llvm::opt;
  44
  45 MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
  46     : ToolChain(D, Triple, Args) {
  47   // We expect 'as', 'ld', etc. to be adjacent to our install dir.
  48   getProgramPaths().push_back(getDriver().getInstalledDir());
  49   if (getDriver().getInstalledDir() != getDriver().Dir)
  50     getProgramPaths().push_back(getDriver().Dir);
  51 }
  52
  53 /// Darwin - Darwin tool chain for i386 and x86_64.
  54 Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
  55     : MachO(D, Triple, Args), TargetInitialized(false) {}
  56
  57 types::ID MachO::LookupTypeForExtension(const char *Ext) const {
  58   types::ID Ty = types::lookupTypeForExtension(Ext);
  59
  60   // Darwin always preprocesses assembly files (unless -x is used explicitly).
  61   if (Ty == types::TY_PP_Asm)
  62     return types::TY_Asm;
  63
  64   return Ty;
  65 }
  66
  67 bool MachO::HasNativeLLVMSupport() const { return true; }
  68
  69 ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const {
  70   // Default to use libc++ on OS X 10.9+ and iOS 7+.
  71   if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
  72        (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
  73        isTargetWatchOSBased())
  74     return ToolChain::CST_Libcxx;
  75
  76   return ToolChain::CST_Libstdcxx;
  77 }
  78
  79 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
  80 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
  81   if (isTargetWatchOSBased())
  82     return ObjCRuntime(ObjCRuntime::WatchOS, TargetVersion);
  83   if (isTargetIOSBased())
  84     return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
  85   if (isNonFragile)
  86     return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
  87   return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
  88 }
  89
  90 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
  91 bool Darwin::hasBlocksRuntime() const {
  92   if (isTargetWatchOSBased())
  93     return true;
  94   else if (isTargetIOSBased())
  95     return !isIPhoneOSVersionLT(3, 2);
  96   else {
  97     assert(isTargetMacOS() && "unexpected darwin target");
  98     return !isMacosxVersionLT(10, 6);
  99   }
 100 }
 101
 102 // This is just a MachO name translation routine and there's no
 103 // way to join this into ARMTargetParser without breaking all
 104 // other assumptions. Maybe MachO should consider standardising
 105 // their nomenclature.
 106 static const char *ArmMachOArchName(StringRef Arch) {
 107   return llvm::StringSwitch<const char *>(Arch)
 108       .Case("armv6k", "armv6")
 109       .Case("armv6m", "armv6m")
 110       .Case("armv5tej", "armv5")
 111       .Case("xscale", "xscale")
 112       .Case("armv4t", "armv4t")
 113       .Case("armv7", "armv7")
 114       .Cases("armv7a", "armv7-a", "armv7")
 115       .Cases("armv7r", "armv7-r", "armv7")
 116       .Cases("armv7em", "armv7e-m", "armv7em")
 117       .Cases("armv7k", "armv7-k", "armv7k")
 118       .Cases("armv7m", "armv7-m", "armv7m")
 119       .Cases("armv7s", "armv7-s", "armv7s")
 120       .Default(nullptr);
 121 }
 122
 123 static const char *ArmMachOArchNameCPU(StringRef CPU) {
 124   unsigned ArchKind = llvm::ARM::parseCPUArch(CPU);
 125   if (ArchKind == llvm::ARM::AK_INVALID)
 126     return nullptr;
 127   StringRef Arch = llvm::ARM::getArchName(ArchKind);
 128
 129   // FIXME: Make sure this MachO triple mangling is really necessary.
 130   // ARMv5* normalises to ARMv5.
 131   if (Arch.startswith("armv5"))
 132     Arch = Arch.substr(0, 5);
 133   // ARMv6*, except ARMv6M, normalises to ARMv6.
 134   else if (Arch.startswith("armv6") && !Arch.endswith("6m"))
 135     Arch = Arch.substr(0, 5);
 136   // ARMv7A normalises to ARMv7.
 137   else if (Arch.endswith("v7a"))
 138     Arch = Arch.substr(0, 5);
 139   return Arch.data();
 140 }
 141
 142 static bool isSoftFloatABI(const ArgList &Args) {
 143   Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
 144                            options::OPT_mfloat_abi_EQ);
 145   if (!A)
 146     return false;
 147
 148   return A->getOption().matches(options::OPT_msoft_float) ||
 149          (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
 150           A->getValue() == StringRef("soft"));
 151 }
 152
 153 StringRef MachO::getMachOArchName(const ArgList &Args) const {
 154   switch (getTriple().getArch()) {
 155   default:
 156     return getDefaultUniversalArchName();
 157
 158   case llvm::Triple::aarch64:
 159     return "arm64";
 160
 161   case llvm::Triple::thumb:
 162   case llvm::Triple::arm:
 163     if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
 164       if (const char *Arch = ArmMachOArchName(A->getValue()))
 165         return Arch;
 166
 167     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
 168       if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
 169         return Arch;
 170
 171     return "arm";
 172   }
 173 }
 174
 175 Darwin::~Darwin() {}
 176
 177 MachO::~MachO() {}
 178
 179 std::string MachO::ComputeEffectiveClangTriple(const ArgList &Args,
 180                                                types::ID InputType) const {
 181   llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
 182
 183   return Triple.getTriple();
 184 }
 185
 186 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
 187                                                 types::ID InputType) const {
 188   llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
 189
 190   // If the target isn't initialized (e.g., an unknown Darwin platform, return
 191   // the default triple).
 192   if (!isTargetInitialized())
 193     return Triple.getTriple();
 194
 195   SmallString<16> Str;
 196   if (isTargetWatchOSBased())
 197     Str += "watchos";
 198   else if (isTargetTvOSBased())
 199     Str += "tvos";
 200   else if (isTargetIOSBased())
 201     Str += "ios";
 202   else
 203     Str += "macosx";
 204   Str += getTargetVersion().getAsString();
 205   Triple.setOSName(Str);
 206
 207   return Triple.getTriple();
 208 }
 209
 210 void Generic_ELF::anchor() {}
 211
 212 Tool *MachO::getTool(Action::ActionClass AC) const {
 213   switch (AC) {
 214   case Action::LipoJobClass:
 215     if (!Lipo)
 216       Lipo.reset(new tools::darwin::Lipo(*this));
 217     return Lipo.get();
 218   case Action::DsymutilJobClass:
 219     if (!Dsymutil)
 220       Dsymutil.reset(new tools::darwin::Dsymutil(*this));
 221     return Dsymutil.get();
 222   case Action::VerifyDebugInfoJobClass:
 223     if (!VerifyDebug)
 224       VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
 225     return VerifyDebug.get();
 226   default:
 227     return ToolChain::getTool(AC);
 228   }
 229 }
 230
 231 Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
 232
 233 Tool *MachO::buildAssembler() const {
 234   return new tools::darwin::Assembler(*this);
 235 }
 236
 237 DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple,
 238                          const ArgList &Args)
 239     : Darwin(D, Triple, Args) {}
 240
 241 void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const {
 242   // For modern targets, promote certain warnings to errors.
 243   if (isTargetWatchOSBased() || getTriple().isArch64Bit()) {
 244     // Always enable -Wdeprecated-objc-isa-usage and promote it
 245     // to an error.
 246     CC1Args.push_back("-Wdeprecated-objc-isa-usage");
 247     CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
 248
 249     // For iOS and watchOS, also error about implicit function declarations,
 250     // as that can impact calling conventions.
 251     if (!isTargetMacOS())
 252       CC1Args.push_back("-Werror=implicit-function-declaration");
 253   }
 254 }
 255
 256 /// \brief Determine whether Objective-C automated reference counting is
 257 /// enabled.
 258 static bool isObjCAutoRefCount(const ArgList &Args) {
 259   return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
 260 }
 261
 262 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
 263                                  ArgStringList &CmdArgs) const {
 264   // Avoid linking compatibility stubs on i386 mac.
 265   if (isTargetMacOS() && getArch() == llvm::Triple::x86)
 266     return;
 267
 268   ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
 269
 270   if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) &&
 271       runtime.hasSubscripting())
 272     return;
 273
 274   CmdArgs.push_back("-force_load");
 275   SmallString<128> P(getDriver().ClangExecutable);
 276   llvm::sys::path::remove_filename(P); // 'clang'
 277   llvm::sys::path::remove_filename(P); // 'bin'
 278   llvm::sys::path::append(P, "lib", "arc", "libarclite_");
 279   // Mash in the platform.
 280   if (isTargetWatchOSSimulator())
 281     P += "watchsimulator";
 282   else if (isTargetWatchOS())
 283     P += "watchos";
 284   else if (isTargetTvOSSimulator())
 285     P += "appletvsimulator";
 286   else if (isTargetTvOS())
 287     P += "appletvos";
 288   else if (isTargetIOSSimulator())
 289     P += "iphonesimulator";
 290   else if (isTargetIPhoneOS())
 291     P += "iphoneos";
 292   else
 293     P += "macosx";
 294   P += ".a";
 295
 296   CmdArgs.push_back(Args.MakeArgString(P));
 297 }
 298
 299 void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
 300                               StringRef DarwinLibName, bool AlwaysLink,
 301                               bool IsEmbedded, bool AddRPath) const {
 302   SmallString<128> Dir(getDriver().ResourceDir);
 303   llvm::sys::path::append(Dir, "lib", IsEmbedded ? "macho_embedded" : "darwin");
 304
 305   SmallString<128> P(Dir);
 306   llvm::sys::path::append(P, DarwinLibName);
 307
 308   // For now, allow missing resource libraries to support developers who may
 309   // not have compiler-rt checked out or integrated into their build (unless
 310   // we explicitly force linking with this library).
 311   if (AlwaysLink || getVFS().exists(P))
 312     CmdArgs.push_back(Args.MakeArgString(P));
 313
 314   // Adding the rpaths might negatively interact when other rpaths are involved,
 315   // so we should make sure we add the rpaths last, after all user-specified
 316   // rpaths. This is currently true from this place, but we need to be
 317   // careful if this function is ever called before user's rpaths are emitted.
 318   if (AddRPath) {
 319     assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library");
 320
 321     // Add @executable_path to rpath to support having the dylib copied with
 322     // the executable.
 323     CmdArgs.push_back("-rpath");
 324     CmdArgs.push_back("@executable_path");
 325
 326     // Add the path to the resource dir to rpath to support using the dylib
 327     // from the default location without copying.
 328     CmdArgs.push_back("-rpath");
 329     CmdArgs.push_back(Args.MakeArgString(Dir));
 330   }
 331 }
 332
 333 StringRef Darwin::getPlatformFamily() const {
 334   switch (TargetPlatform) {
 335     case DarwinPlatformKind::MacOS:
 336       return "MacOSX";
 337     case DarwinPlatformKind::IPhoneOS:
 338     case DarwinPlatformKind::IPhoneOSSimulator:
 339       return "iPhone";
 340     case DarwinPlatformKind::TvOS:
 341     case DarwinPlatformKind::TvOSSimulator:
 342       return "AppleTV";
 343     case DarwinPlatformKind::WatchOS:
 344     case DarwinPlatformKind::WatchOSSimulator:
 345       return "Watch";
 346   }
 347   llvm_unreachable("Unsupported platform");
 348 }
 349
 350 StringRef Darwin::getSDKName(StringRef isysroot) {
 351   // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
 352   llvm::sys::path::const_iterator SDKDir;
 353   auto BeginSDK = llvm::sys::path::begin(isysroot);
 354   auto EndSDK = llvm::sys::path::end(isysroot);
 355   for (auto IT = BeginSDK; IT != EndSDK; ++IT) {
 356     StringRef SDK = *IT;
 357     if (SDK.endswith(".sdk"))
 358       return SDK.slice(0, SDK.size() - 4);
 359   }
 360   return "";
 361 }
 362
 363 StringRef Darwin::getOSLibraryNameSuffix() const {
 364   switch(TargetPlatform) {
 365   case DarwinPlatformKind::MacOS:
 366     return "osx";
 367   case DarwinPlatformKind::IPhoneOS:
 368     return "ios";
 369   case DarwinPlatformKind::IPhoneOSSimulator:
 370     return "iossim";
 371   case DarwinPlatformKind::TvOS:
 372     return "tvos";
 373   case DarwinPlatformKind::TvOSSimulator:
 374     return "tvossim";
 375   case DarwinPlatformKind::WatchOS:
 376     return "watchos";
 377   case DarwinPlatformKind::WatchOSSimulator:
 378     return "watchossim";
 379   }
 380   llvm_unreachable("Unsupported platform");
 381 }
 382
 383 void Darwin::addProfileRTLibs(const ArgList &Args,
 384                               ArgStringList &CmdArgs) const {
 385   if (!needsProfileRT(Args)) return;
 386
 387   AddLinkRuntimeLib(Args, CmdArgs, (Twine("libclang_rt.profile_") +
 388        getOSLibraryNameSuffix() + ".a").str(),
 389                     /*AlwaysLink*/ true);
 390 }
 391
 392 void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
 393                                           ArgStringList &CmdArgs,
 394                                           StringRef Sanitizer) const {
 395   AddLinkRuntimeLib(
 396       Args, CmdArgs,
 397       (Twine("libclang_rt.") + Sanitizer + "_" +
 398        getOSLibraryNameSuffix() + "_dynamic.dylib").str(),
 399       /*AlwaysLink*/ true, /*IsEmbedded*/ false,
 400       /*AddRPath*/ true);
 401 }
 402
 403 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
 404                                         ArgStringList &CmdArgs) const {
 405   // Darwin only supports the compiler-rt based runtime libraries.
 406   switch (GetRuntimeLibType(Args)) {
 407   case ToolChain::RLT_CompilerRT:
 408     break;
 409   default:
 410     getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
 411         << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "darwin";
 412     return;
 413   }
 414
 415   // Darwin doesn't support real static executables, don't link any runtime
 416   // libraries with -static.
 417   if (Args.hasArg(options::OPT_static) ||
 418       Args.hasArg(options::OPT_fapple_kext) ||
 419       Args.hasArg(options::OPT_mkernel))
 420     return;
 421
 422   // Reject -static-libgcc for now, we can deal with this when and if someone
 423   // cares. This is useful in situations where someone wants to statically link
 424   // something like libstdc++, and needs its runtime support routines.
 425   if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
 426     getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
 427     return;
 428   }
 429
 430   const SanitizerArgs &Sanitize = getSanitizerArgs();
 431   if (Sanitize.needsAsanRt())
 432     AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
 433   if (Sanitize.needsUbsanRt())
 434     AddLinkSanitizerLibArgs(Args, CmdArgs, "ubsan");
 435   if (Sanitize.needsTsanRt())
 436     AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan");
 437   if (Sanitize.needsStatsRt()) {
 438     StringRef OS = isTargetMacOS() ? "osx" : "iossim";
 439     AddLinkRuntimeLib(Args, CmdArgs,
 440                       (Twine("libclang_rt.stats_client_") + OS + ".a").str(),
 441                       /*AlwaysLink=*/true);
 442     AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
 443   }
 444   if (Sanitize.needsEsanRt())
 445     AddLinkSanitizerLibArgs(Args, CmdArgs, "esan");
 446
 447   // Otherwise link libSystem, then the dynamic runtime library, and finally any
 448   // target specific static runtime library.
 449   CmdArgs.push_back("-lSystem");
 450
 451   // Select the dynamic runtime library and the target specific static library.
 452   if (isTargetWatchOSBased()) {
 453     // We currently always need a static runtime library for watchOS.
 454     AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.watchos.a");
 455   } else if (isTargetTvOSBased()) {
 456     // We currently always need a static runtime library for tvOS.
 457     AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.tvos.a");
 458   } else if (isTargetIOSBased()) {
 459     // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
 460     // it never went into the SDK.
 461     // Linking against libgcc_s.1 isn't needed for iOS 5.0+
 462     if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
 463         getTriple().getArch() != llvm::Triple::aarch64)
 464       CmdArgs.push_back("-lgcc_s.1");
 465
 466     // We currently always need a static runtime library for iOS.
 467     AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
 468   } else {
 469     assert(isTargetMacOS() && "unexpected non MacOS platform");
 470     // The dynamic runtime library was merged with libSystem for 10.6 and
 471     // beyond; only 10.4 and 10.5 need an additional runtime library.
 472     if (isMacosxVersionLT(10, 5))
 473       CmdArgs.push_back("-lgcc_s.10.4");
 474     else if (isMacosxVersionLT(10, 6))
 475       CmdArgs.push_back("-lgcc_s.10.5");
 476
 477     // Originally for OS X, we thought we would only need a static runtime
 478     // library when targeting 10.4, to provide versions of the static functions
 479     // which were omitted from 10.4.dylib. This led to the creation of the 10.4
 480     // builtins library.
 481     //
 482     // Unfortunately, that turned out to not be true, because Darwin system
 483     // headers can still use eprintf on i386, and it is not exported from
 484     // libSystem. Therefore, we still must provide a runtime library just for
 485     // the tiny tiny handful of projects that *might* use that symbol.
 486     //
 487     // Then over time, we figured out it was useful to add more things to the
 488     // runtime so we created libclang_rt.osx.a to provide new functions when
 489     // deploying to old OS builds, and for a long time we had both eprintf and
 490     // osx builtin libraries. Which just seems excessive. So with PR 28855, we
 491     // are removing the eprintf library and expecting eprintf to be provided by
 492     // the OS X builtins library.
 493     if (isMacosxVersionLT(10, 5))
 494       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
 495     else
 496       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
 497   }
 498 }
 499
 500 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
 501   const OptTable &Opts = getDriver().getOpts();
 502
 503   // Support allowing the SDKROOT environment variable used by xcrun and other
 504   // Xcode tools to define the default sysroot, by making it the default for
 505   // isysroot.
 506   if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
 507     // Warn if the path does not exist.
 508     if (!getVFS().exists(A->getValue()))
 509       getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
 510   } else {
 511     if (char *env = ::getenv("SDKROOT")) {
 512       // We only use this value as the default if it is an absolute path,
 513       // exists, and it is not the root path.
 514       if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
 515           StringRef(env) != "/") {
 516         Args.append(Args.MakeSeparateArg(
 517             nullptr, Opts.getOption(options::OPT_isysroot), env));
 518       }
 519     }
 520   }
 521
 522   Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
 523   Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
 524   Arg *TvOSVersion = Args.getLastArg(options::OPT_mtvos_version_min_EQ);
 525   Arg *WatchOSVersion = Args.getLastArg(options::OPT_mwatchos_version_min_EQ);
 526
 527   if (OSXVersion && (iOSVersion || TvOSVersion || WatchOSVersion)) {
 528     getDriver().Diag(diag::err_drv_argument_not_allowed_with)
 529         << OSXVersion->getAsString(Args)
 530         << (iOSVersion ? iOSVersion :
 531             TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
 532     iOSVersion = TvOSVersion = WatchOSVersion = nullptr;
 533   } else if (iOSVersion && (TvOSVersion || WatchOSVersion)) {
 534     getDriver().Diag(diag::err_drv_argument_not_allowed_with)
 535         << iOSVersion->getAsString(Args)
 536         << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
 537     TvOSVersion = WatchOSVersion = nullptr;
 538   } else if (TvOSVersion && WatchOSVersion) {
 539      getDriver().Diag(diag::err_drv_argument_not_allowed_with)
 540         << TvOSVersion->getAsString(Args)
 541         << WatchOSVersion->getAsString(Args);
 542     WatchOSVersion = nullptr;
 543   } else if (!OSXVersion && !iOSVersion && !TvOSVersion && !WatchOSVersion) {
 544     // If no deployment target was specified on the command line, check for
 545     // environment defines.
 546     std::string OSXTarget;
 547     std::string iOSTarget;
 548     std::string TvOSTarget;
 549     std::string WatchOSTarget;
 550
 551     if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
 552       OSXTarget = env;
 553     if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
 554       iOSTarget = env;
 555     if (char *env = ::getenv("TVOS_DEPLOYMENT_TARGET"))
 556       TvOSTarget = env;
 557     if (char *env = ::getenv("WATCHOS_DEPLOYMENT_TARGET"))
 558       WatchOSTarget = env;
 559
 560     // If there is no command-line argument to specify the Target version and
 561     // no environment variable defined, see if we can set the default based
 562     // on -isysroot.
 563     if (OSXTarget.empty() && iOSTarget.empty() && WatchOSTarget.empty() &&
 564         TvOSTarget.empty() && Args.hasArg(options::OPT_isysroot)) {
 565       if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
 566         StringRef isysroot = A->getValue();
 567         StringRef SDK = getSDKName(isysroot);
 568         if (SDK.size() > 0) {
 569           // Slice the version number out.
 570           // Version number is between the first and the last number.
 571           size_t StartVer = SDK.find_first_of("0123456789");
 572           size_t EndVer = SDK.find_last_of("0123456789");
 573           if (StartVer != StringRef::npos && EndVer > StartVer) {
 574             StringRef Version = SDK.slice(StartVer, EndVer + 1);
 575             if (SDK.startswith("iPhoneOS") ||
 576                 SDK.startswith("iPhoneSimulator"))
 577               iOSTarget = Version;
 578             else if (SDK.startswith("MacOSX"))
 579               OSXTarget = Version;
 580             else if (SDK.startswith("WatchOS") ||
 581                      SDK.startswith("WatchSimulator"))
 582               WatchOSTarget = Version;
 583             else if (SDK.startswith("AppleTVOS") ||
 584                      SDK.startswith("AppleTVSimulator"))
 585               TvOSTarget = Version;
 586           }
 587         }
 588       }
 589     }
 590
 591     // If no OSX or iOS target has been specified, try to guess platform
 592     // from arch name and compute the version from the triple.
 593     if (OSXTarget.empty() && iOSTarget.empty() && TvOSTarget.empty() &&
 594         WatchOSTarget.empty()) {
 595       StringRef MachOArchName = getMachOArchName(Args);
 596       unsigned Major, Minor, Micro;
 597       if (MachOArchName == "armv7" || MachOArchName == "armv7s" ||
 598           MachOArchName == "arm64") {
 599         getTriple().getiOSVersion(Major, Minor, Micro);
 600         llvm::raw_string_ostream(iOSTarget) << Major << '.' << Minor << '.'
 601                                             << Micro;
 602       } else if (MachOArchName == "armv7k") {
 603         getTriple().getWatchOSVersion(Major, Minor, Micro);
 604         llvm::raw_string_ostream(WatchOSTarget) << Major << '.' << Minor << '.'
 605                                                 << Micro;
 606       } else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
 607                  MachOArchName != "armv7em") {
 608         if (!getTriple().getMacOSXVersion(Major, Minor, Micro)) {
 609           getDriver().Diag(diag::err_drv_invalid_darwin_version)
 610               << getTriple().getOSName();
 611         }
 612         llvm::raw_string_ostream(OSXTarget) << Major << '.' << Minor << '.'
 613                                             << Micro;
 614       }
 615     }
 616
 617     // Do not allow conflicts with the watchOS target.
 618     if (!WatchOSTarget.empty() && (!iOSTarget.empty() || !TvOSTarget.empty())) {
 619       getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
 620         << "WATCHOS_DEPLOYMENT_TARGET"
 621         << (!iOSTarget.empty() ? "IPHONEOS_DEPLOYMENT_TARGET" :
 622             "TVOS_DEPLOYMENT_TARGET");
 623     }
 624
 625     // Do not allow conflicts with the tvOS target.
 626     if (!TvOSTarget.empty() && !iOSTarget.empty()) {
 627       getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
 628         << "TVOS_DEPLOYMENT_TARGET"
 629         << "IPHONEOS_DEPLOYMENT_TARGET";
 630     }
 631
 632     // Allow conflicts among OSX and iOS for historical reasons, but choose the
 633     // default platform.
 634     if (!OSXTarget.empty() && (!iOSTarget.empty() ||
 635                                !WatchOSTarget.empty() ||
 636                                !TvOSTarget.empty())) {
 637       if (getTriple().getArch() == llvm::Triple::arm ||
 638           getTriple().getArch() == llvm::Triple::aarch64 ||
 639           getTriple().getArch() == llvm::Triple::thumb)
 640         OSXTarget = "";
 641       else
 642         iOSTarget = WatchOSTarget = TvOSTarget = "";
 643     }
 644
 645     if (!OSXTarget.empty()) {
 646       const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
 647       OSXVersion = Args.MakeJoinedArg(nullptr, O, OSXTarget);
 648       Args.append(OSXVersion);
 649     } else if (!iOSTarget.empty()) {
 650       const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
 651       iOSVersion = Args.MakeJoinedArg(nullptr, O, iOSTarget);
 652       Args.append(iOSVersion);
 653     } else if (!TvOSTarget.empty()) {
 654       const Option O = Opts.getOption(options::OPT_mtvos_version_min_EQ);
 655       TvOSVersion = Args.MakeJoinedArg(nullptr, O, TvOSTarget);
 656       Args.append(TvOSVersion);
 657     } else if (!WatchOSTarget.empty()) {
 658       const Option O = Opts.getOption(options::OPT_mwatchos_version_min_EQ);
 659       WatchOSVersion = Args.MakeJoinedArg(nullptr, O, WatchOSTarget);
 660       Args.append(WatchOSVersion);
 661     }
 662   }
 663
 664   DarwinPlatformKind Platform;
 665   if (OSXVersion)
 666     Platform = MacOS;
 667   else if (iOSVersion)
 668     Platform = IPhoneOS;
 669   else if (TvOSVersion)
 670     Platform = TvOS;
 671   else if (WatchOSVersion)
 672     Platform = WatchOS;
 673   else
 674     llvm_unreachable("Unable to infer Darwin variant");
 675
 676   // Set the tool chain target information.
 677   unsigned Major, Minor, Micro;
 678   bool HadExtra;
 679   if (Platform == MacOS) {
 680     assert((!iOSVersion && !TvOSVersion && !WatchOSVersion) &&
 681            "Unknown target platform!");
 682     if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor, Micro,
 683                                    HadExtra) ||
 684         HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
 685       getDriver().Diag(diag::err_drv_invalid_version_number)
 686           << OSXVersion->getAsString(Args);
 687   } else if (Platform == IPhoneOS) {
 688     assert(iOSVersion && "Unknown target platform!");
 689     if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, Micro,
 690                                    HadExtra) ||
 691         HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
 692       getDriver().Diag(diag::err_drv_invalid_version_number)
 693           << iOSVersion->getAsString(Args);
 694   } else if (Platform == TvOS) {
 695     if (!Driver::GetReleaseVersion(TvOSVersion->getValue(), Major, Minor,
 696                                    Micro, HadExtra) || HadExtra ||
 697         Major >= 100 || Minor >= 100 || Micro >= 100)
 698       getDriver().Diag(diag::err_drv_invalid_version_number)
 699           << TvOSVersion->getAsString(Args);
 700   } else if (Platform == WatchOS) {
 701     if (!Driver::GetReleaseVersion(WatchOSVersion->getValue(), Major, Minor,
 702                                    Micro, HadExtra) || HadExtra ||
 703         Major >= 10 || Minor >= 100 || Micro >= 100)
 704       getDriver().Diag(diag::err_drv_invalid_version_number)
 705           << WatchOSVersion->getAsString(Args);
 706   } else
 707     llvm_unreachable("unknown kind of Darwin platform");
 708
 709   // Recognize iOS targets with an x86 architecture as the iOS simulator.
 710   if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
 711                      getTriple().getArch() == llvm::Triple::x86_64))
 712     Platform = IPhoneOSSimulator;
 713   if (TvOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
 714                       getTriple().getArch() == llvm::Triple::x86_64))
 715     Platform = TvOSSimulator;
 716   if (WatchOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
 717                          getTriple().getArch() == llvm::Triple::x86_64))
 718     Platform = WatchOSSimulator;
 719
 720   setTarget(Platform, Major, Minor, Micro);
 721
 722   if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
 723     StringRef SDK = getSDKName(A->getValue());
 724     if (SDK.size() > 0) {
 725       size_t StartVer = SDK.find_first_of("0123456789");
 726       StringRef SDKName = SDK.slice(0, StartVer);
 727       if (!SDKName.startswith(getPlatformFamily()))
 728         getDriver().Diag(diag::warn_incompatible_sysroot)
 729             << SDKName << getPlatformFamily();
 730     }
 731   }
 732 }
 733
 734 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
 735                                       ArgStringList &CmdArgs) const {
 736   CXXStdlibType Type = GetCXXStdlibType(Args);
 737
 738   switch (Type) {
 739   case ToolChain::CST_Libcxx:
 740     CmdArgs.push_back("-lc++");
 741     break;
 742
 743   case ToolChain::CST_Libstdcxx:
 744     // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
 745     // it was previously found in the gcc lib dir. However, for all the Darwin
 746     // platforms we care about it was -lstdc++.6, so we search for that
 747     // explicitly if we can't see an obvious -lstdc++ candidate.
 748
 749     // Check in the sysroot first.
 750     if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
 751       SmallString<128> P(A->getValue());
 752       llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
 753
 754       if (!getVFS().exists(P)) {
 755         llvm::sys::path::remove_filename(P);
 756         llvm::sys::path::append(P, "libstdc++.6.dylib");
 757         if (getVFS().exists(P)) {
 758           CmdArgs.push_back(Args.MakeArgString(P));
 759           return;
 760         }
 761       }
 762     }
 763
 764     // Otherwise, look in the root.
 765     // FIXME: This should be removed someday when we don't have to care about
 766     // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
 767     if (!getVFS().exists("/usr/lib/libstdc++.dylib") &&
 768         getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
 769       CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
 770       return;
 771     }
 772
 773     // Otherwise, let the linker search.
 774     CmdArgs.push_back("-lstdc++");
 775     break;
 776   }
 777 }
 778
 779 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
 780                                    ArgStringList &CmdArgs) const {
 781   // For Darwin platforms, use the compiler-rt-based support library
 782   // instead of the gcc-provided one (which is also incidentally
 783   // only present in the gcc lib dir, which makes it hard to find).
 784
 785   SmallString<128> P(getDriver().ResourceDir);
 786   llvm::sys::path::append(P, "lib", "darwin");
 787
 788   // Use the newer cc_kext for iOS ARM after 6.0.
 789   if (isTargetWatchOS()) {
 790     llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
 791   } else if (isTargetTvOS()) {
 792     llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
 793   } else if (isTargetIPhoneOS()) {
 794     llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
 795   } else {
 796     llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
 797   }
 798
 799   // For now, allow missing resource libraries to support developers who may
 800   // not have compiler-rt checked out or integrated into their build.
 801   if (getVFS().exists(P))
 802     CmdArgs.push_back(Args.MakeArgString(P));
 803 }
 804
 805 DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,
 806                                      const char *BoundArch) const {
 807   DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
 808   const OptTable &Opts = getDriver().getOpts();
 809
 810   // FIXME: We really want to get out of the tool chain level argument
 811   // translation business, as it makes the driver functionality much
 812   // more opaque. For now, we follow gcc closely solely for the
 813   // purpose of easily achieving feature parity & testability. Once we
 814   // have something that works, we should reevaluate each translation
 815   // and try to push it down into tool specific logic.
 816
 817   for (Arg *A : Args) {
 818     if (A->getOption().matches(options::OPT_Xarch__)) {
 819       // Skip this argument unless the architecture matches either the toolchain
 820       // triple arch, or the arch being bound.
 821       llvm::Triple::ArchType XarchArch =
 822           tools::darwin::getArchTypeForMachOArchName(A->getValue(0));
 823       if (!(XarchArch == getArch() ||
 824             (BoundArch &&
 825              XarchArch ==
 826                  tools::darwin::getArchTypeForMachOArchName(BoundArch))))
 827         continue;
 828
 829       Arg *OriginalArg = A;
 830       unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
 831       unsigned Prev = Index;
 832       std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
 833
 834       // If the argument parsing failed or more than one argument was
 835       // consumed, the -Xarch_ argument's parameter tried to consume
 836       // extra arguments. Emit an error and ignore.
 837       //
 838       // We also want to disallow any options which would alter the
 839       // driver behavior; that isn't going to work in our model. We
 840       // use isDriverOption() as an approximation, although things
 841       // like -O4 are going to slip through.
 842       if (!XarchArg || Index > Prev + 1) {
 843         getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
 844             << A->getAsString(Args);
 845         continue;
 846       } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
 847         getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
 848             << A->getAsString(Args);
 849         continue;
 850       }
 851
 852       XarchArg->setBaseArg(A);
 853
 854       A = XarchArg.release();
 855       DAL->AddSynthesizedArg(A);
 856
 857       // Linker input arguments require custom handling. The problem is that we
 858       // have already constructed the phase actions, so we can not treat them as
 859       // "input arguments".
 860       if (A->getOption().hasFlag(options::LinkerInput)) {
 861         // Convert the argument into individual Zlinker_input_args.
 862         for (const char *Value : A->getValues()) {
 863           DAL->AddSeparateArg(
 864               OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
 865         }
 866         continue;
 867       }
 868     }
 869
 870     // Sob. These is strictly gcc compatible for the time being. Apple
 871     // gcc translates options twice, which means that self-expanding
 872     // options add duplicates.
 873     switch ((options::ID)A->getOption().getID()) {
 874     default:
 875       DAL->append(A);
 876       break;
 877
 878     case options::OPT_mkernel:
 879     case options::OPT_fapple_kext:
 880       DAL->append(A);
 881       DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
 882       break;
 883
 884     case options::OPT_dependency_file:
 885       DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
 886       break;
 887
 888     case options::OPT_gfull:
 889       DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
 890       DAL->AddFlagArg(
 891           A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
 892       break;
 893
 894     case options::OPT_gused:
 895       DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
 896       DAL->AddFlagArg(
 897           A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
 898       break;
 899
 900     case options::OPT_shared:
 901       DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
 902       break;
 903
 904     case options::OPT_fconstant_cfstrings:
 905       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
 906       break;
 907
 908     case options::OPT_fno_constant_cfstrings:
 909       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
 910       break;
 911
 912     case options::OPT_Wnonportable_cfstrings:
 913       DAL->AddFlagArg(A,
 914                       Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
 915       break;
 916
 917     case options::OPT_Wno_nonportable_cfstrings:
 918       DAL->AddFlagArg(
 919           A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
 920       break;
 921
 922     case options::OPT_fpascal_strings:
 923       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
 924       break;
 925
 926     case options::OPT_fno_pascal_strings:
 927       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
 928       break;
 929     }
 930   }
 931
 932   if (getTriple().getArch() == llvm::Triple::x86 ||
 933       getTriple().getArch() == llvm::Triple::x86_64)
 934     if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
 935       DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mtune_EQ),
 936                         "core2");
 937
 938   // Add the arch options based on the particular spelling of -arch, to match
 939   // how the driver driver works.
 940   if (BoundArch) {
 941     StringRef Name = BoundArch;
 942     const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
 943     const Option MArch = Opts.getOption(options::OPT_march_EQ);
 944
 945     // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
 946     // which defines the list of which architectures we accept.
 947     if (Name == "ppc")
 948       ;
 949     else if (Name == "ppc601")
 950       DAL->AddJoinedArg(nullptr, MCpu, "601");
 951     else if (Name == "ppc603")
 952       DAL->AddJoinedArg(nullptr, MCpu, "603");
 953     else if (Name == "ppc604")
 954       DAL->AddJoinedArg(nullptr, MCpu, "604");
 955     else if (Name == "ppc604e")
 956       DAL->AddJoinedArg(nullptr, MCpu, "604e");
 957     else if (Name == "ppc750")
 958       DAL->AddJoinedArg(nullptr, MCpu, "750");
 959     else if (Name == "ppc7400")
 960       DAL->AddJoinedArg(nullptr, MCpu, "7400");
 961     else if (Name == "ppc7450")
 962       DAL->AddJoinedArg(nullptr, MCpu, "7450");
 963     else if (Name == "ppc970")
 964       DAL->AddJoinedArg(nullptr, MCpu, "970");
 965
 966     else if (Name == "ppc64" || Name == "ppc64le")
 967       DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
 968
 969     else if (Name == "i386")
 970       ;
 971     else if (Name == "i486")
 972       DAL->AddJoinedArg(nullptr, MArch, "i486");
 973     else if (Name == "i586")
 974       DAL->AddJoinedArg(nullptr, MArch, "i586");
 975     else if (Name == "i686")
 976       DAL->AddJoinedArg(nullptr, MArch, "i686");
 977     else if (Name == "pentium")
 978       DAL->AddJoinedArg(nullptr, MArch, "pentium");
 979     else if (Name == "pentium2")
 980       DAL->AddJoinedArg(nullptr, MArch, "pentium2");
 981     else if (Name == "pentpro")
 982       DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
 983     else if (Name == "pentIIm3")
 984       DAL->AddJoinedArg(nullptr, MArch, "pentium2");
 985
 986     else if (Name == "x86_64")
 987       DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
 988     else if (Name == "x86_64h") {
 989       DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
 990       DAL->AddJoinedArg(nullptr, MArch, "x86_64h");
 991     }
 992
 993     else if (Name == "arm")
 994       DAL->AddJoinedArg(nullptr, MArch, "armv4t");
 995     else if (Name == "armv4t")
 996       DAL->AddJoinedArg(nullptr, MArch, "armv4t");
 997     else if (Name == "armv5")
 998       DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
 999     else if (Name == "xscale")
1000       DAL->AddJoinedArg(nullptr, MArch, "xscale");
1001     else if (Name == "armv6")
1002       DAL->AddJoinedArg(nullptr, MArch, "armv6k");
1003     else if (Name == "armv6m")
1004       DAL->AddJoinedArg(nullptr, MArch, "armv6m");
1005     else if (Name == "armv7")
1006       DAL->AddJoinedArg(nullptr, MArch, "armv7a");
1007     else if (Name == "armv7em")
1008       DAL->AddJoinedArg(nullptr, MArch, "armv7em");
1009     else if (Name == "armv7k")
1010       DAL->AddJoinedArg(nullptr, MArch, "armv7k");
1011     else if (Name == "armv7m")
1012       DAL->AddJoinedArg(nullptr, MArch, "armv7m");
1013     else if (Name == "armv7s")
1014       DAL->AddJoinedArg(nullptr, MArch, "armv7s");
1015   }
1016
1017   return DAL;
1018 }
1019
1020 void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
1021                                   ArgStringList &CmdArgs) const {
1022   // Embedded targets are simple at the moment, not supporting sanitizers and
1023   // with different libraries for each member of the product { static, PIC } x
1024   // { hard-float, soft-float }
1025   llvm::SmallString<32> CompilerRT = StringRef("libclang_rt.");
1026   CompilerRT +=
1027       (tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard)
1028           ? "hard"
1029           : "soft";
1030   CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a";
1031
1032   AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, false, true);
1033 }
1034
1035 DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
1036                                       const char *BoundArch) const {
1037   // First get the generic Apple args, before moving onto Darwin-specific ones.
1038   DerivedArgList *DAL = MachO::TranslateArgs(Args, BoundArch);
1039   const OptTable &Opts = getDriver().getOpts();
1040
1041   // If no architecture is bound, none of the translations here are relevant.
1042   if (!BoundArch)
1043     return DAL;
1044
1045   // Add an explicit version min argument for the deployment target. We do this
1046   // after argument translation because -Xarch_ arguments may add a version min
1047   // argument.
1048   AddDeploymentTarget(*DAL);
1049
1050   // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
1051   // FIXME: It would be far better to avoid inserting those -static arguments,
1052   // but we can't check the deployment target in the translation code until
1053   // it is set here.
1054   if (isTargetWatchOSBased() ||
1055       (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) {
1056     for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
1057       Arg *A = *it;
1058       ++it;
1059       if (A->getOption().getID() != options::OPT_mkernel &&
1060           A->getOption().getID() != options::OPT_fapple_kext)
1061         continue;
1062       assert(it != ie && "unexpected argument translation");
1063       A = *it;
1064       assert(A->getOption().getID() == options::OPT_static &&
1065              "missing expected -static argument");
1066       it = DAL->getArgs().erase(it);
1067     }
1068   }
1069
1070   if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
1071       GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
1072     DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ),
1073                       "libc++");
1074
1075   // Validate the C++ standard library choice.
1076   CXXStdlibType Type = GetCXXStdlibType(*DAL);
1077   if (Type == ToolChain::CST_Libcxx) {
1078     // Check whether the target provides libc++.
1079     StringRef where;
1080
1081     // Complain about targeting iOS < 5.0 in any way.
1082     if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0))
1083       where = "iOS 5.0";
1084
1085     if (where != StringRef()) {
1086       getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
1087     }
1088   }
1089
1090   return DAL;
1091 }
1092
1093 bool MachO::IsUnwindTablesDefault() const {
1094   return getArch() == llvm::Triple::x86_64;
1095 }
1096
1097 bool MachO::UseDwarfDebugFlags() const {
1098   if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
1099     return S[0] != '\0';
1100   return false;
1101 }
1102
1103 bool Darwin::UseSjLjExceptions(const ArgList &Args) const {
1104   // Darwin uses SjLj exceptions on ARM.
1105   if (getTriple().getArch() != llvm::Triple::arm &&
1106       getTriple().getArch() != llvm::Triple::thumb)
1107     return false;
1108
1109   // Only watchOS uses the new DWARF/Compact unwinding method.
1110   llvm::Triple Triple(ComputeLLVMTriple(Args));
1111   return !Triple.isWatchABI();
1112 }
1113
1114 bool Darwin::SupportsEmbeddedBitcode() const {
1115   assert(TargetInitialized && "Target not initialized!");
1116   if (isTargetIPhoneOS() && isIPhoneOSVersionLT(6, 0))
1117     return false;
1118   return true;
1119 }
1120
1121 bool MachO::isPICDefault() const { return true; }
1122
1123 bool MachO::isPIEDefault() const { return false; }
1124
1125 bool MachO::isPICDefaultForced() const {
1126   return (getArch() == llvm::Triple::x86_64 ||
1127           getArch() == llvm::Triple::aarch64);
1128 }
1129
1130 bool MachO::SupportsProfiling() const {
1131   // Profiling instrumentation is only supported on x86.
1132   return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
1133 }
1134
1135 void Darwin::addMinVersionArgs(const ArgList &Args,
1136                                ArgStringList &CmdArgs) const {
1137   VersionTuple TargetVersion = getTargetVersion();
1138
1139   if (isTargetWatchOS())
1140     CmdArgs.push_back("-watchos_version_min");
1141   else if (isTargetWatchOSSimulator())
1142     CmdArgs.push_back("-watchos_simulator_version_min");
1143   else if (isTargetTvOS())
1144     CmdArgs.push_back("-tvos_version_min");
1145   else if (isTargetTvOSSimulator())
1146     CmdArgs.push_back("-tvos_simulator_version_min");
1147   else if (isTargetIOSSimulator())
1148     CmdArgs.push_back("-ios_simulator_version_min");
1149   else if (isTargetIOSBased())
1150     CmdArgs.push_back("-iphoneos_version_min");
1151   else {
1152     assert(isTargetMacOS() && "unexpected target");
1153     CmdArgs.push_back("-macosx_version_min");
1154   }
1155
1156   CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
1157 }
1158
1159 void Darwin::addStartObjectFileArgs(const ArgList &Args,
1160                                     ArgStringList &CmdArgs) const {
1161   // Derived from startfile spec.
1162   if (Args.hasArg(options::OPT_dynamiclib)) {
1163     // Derived from darwin_dylib1 spec.
1164     if (isTargetWatchOSBased()) {
1165       ; // watchOS does not need dylib1.o.
1166     } else if (isTargetIOSSimulator()) {
1167       ; // iOS simulator does not need dylib1.o.
1168     } else if (isTargetIPhoneOS()) {
1169       if (isIPhoneOSVersionLT(3, 1))
1170         CmdArgs.push_back("-ldylib1.o");
1171     } else {
1172       if (isMacosxVersionLT(10, 5))
1173         CmdArgs.push_back("-ldylib1.o");
1174       else if (isMacosxVersionLT(10, 6))
1175         CmdArgs.push_back("-ldylib1.10.5.o");
1176     }
1177   } else {
1178     if (Args.hasArg(options::OPT_bundle)) {
1179       if (!Args.hasArg(options::OPT_static)) {
1180         // Derived from darwin_bundle1 spec.
1181         if (isTargetWatchOSBased()) {
1182           ; // watchOS does not need bundle1.o.
1183         } else if (isTargetIOSSimulator()) {
1184           ; // iOS simulator does not need bundle1.o.
1185         } else if (isTargetIPhoneOS()) {
1186           if (isIPhoneOSVersionLT(3, 1))
1187             CmdArgs.push_back("-lbundle1.o");
1188         } else {
1189           if (isMacosxVersionLT(10, 6))
1190             CmdArgs.push_back("-lbundle1.o");
1191         }
1192       }
1193     } else {
1194       if (Args.hasArg(options::OPT_pg) && SupportsProfiling()) {
1195         if (Args.hasArg(options::OPT_static) ||
1196             Args.hasArg(options::OPT_object) ||
1197             Args.hasArg(options::OPT_preload)) {
1198           CmdArgs.push_back("-lgcrt0.o");
1199         } else {
1200           CmdArgs.push_back("-lgcrt1.o");
1201
1202           // darwin_crt2 spec is empty.
1203         }
1204         // By default on OS X 10.8 and later, we don't link with a crt1.o
1205         // file and the linker knows to use _main as the entry point.  But,
1206         // when compiling with -pg, we need to link with the gcrt1.o file,
1207         // so pass the -no_new_main option to tell the linker to use the
1208         // "start" symbol as the entry point.
1209         if (isTargetMacOS() && !isMacosxVersionLT(10, 8))
1210           CmdArgs.push_back("-no_new_main");
1211       } else {
1212         if (Args.hasArg(options::OPT_static) ||
1213             Args.hasArg(options::OPT_object) ||
1214             Args.hasArg(options::OPT_preload)) {
1215           CmdArgs.push_back("-lcrt0.o");
1216         } else {
1217           // Derived from darwin_crt1 spec.
1218           if (isTargetWatchOSBased()) {
1219             ; // watchOS does not need crt1.o.
1220           } else if (isTargetIOSSimulator()) {
1221             ; // iOS simulator does not need crt1.o.
1222           } else if (isTargetIPhoneOS()) {
1223             if (getArch() == llvm::Triple::aarch64)
1224               ; // iOS does not need any crt1 files for arm64
1225             else if (isIPhoneOSVersionLT(3, 1))
1226               CmdArgs.push_back("-lcrt1.o");
1227             else if (isIPhoneOSVersionLT(6, 0))
1228               CmdArgs.push_back("-lcrt1.3.1.o");
1229           } else {
1230             if (isMacosxVersionLT(10, 5))
1231               CmdArgs.push_back("-lcrt1.o");
1232             else if (isMacosxVersionLT(10, 6))
1233               CmdArgs.push_back("-lcrt1.10.5.o");
1234             else if (isMacosxVersionLT(10, 8))
1235               CmdArgs.push_back("-lcrt1.10.6.o");
1236
1237             // darwin_crt2 spec is empty.
1238           }
1239         }
1240       }
1241     }
1242   }
1243
1244   if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) &&
1245       !isTargetWatchOS() &&
1246       isMacosxVersionLT(10, 5)) {
1247     const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
1248     CmdArgs.push_back(Str);
1249   }
1250 }
1251
1252 bool Darwin::SupportsObjCGC() const { return isTargetMacOS(); }
1253
1254 void Darwin::CheckObjCARC() const {
1255   if (isTargetIOSBased() || isTargetWatchOSBased() ||
1256       (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
1257     return;
1258   getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
1259 }
1260
1261 SanitizerMask Darwin::getSupportedSanitizers() const {
1262   const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
1263   SanitizerMask Res = ToolChain::getSupportedSanitizers();
1264   Res |= SanitizerKind::Address;
1265   if (isTargetMacOS()) {
1266     if (!isMacosxVersionLT(10, 9))
1267       Res |= SanitizerKind::Vptr;
1268     Res |= SanitizerKind::SafeStack;
1269     if (IsX86_64)
1270       Res |= SanitizerKind::Thread;
1271   } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) {
1272     if (IsX86_64)
1273       Res |= SanitizerKind::Thread;
1274   }
1275   return Res;
1276 }
1277
1278 /// Generic_GCC - A tool chain using the 'gcc' command to perform
1279 /// all subcommands; this relies on gcc translating the majority of
1280 /// command line options.
1281
1282 /// \brief Parse a GCCVersion object out of a string of text.
1283 ///
1284 /// This is the primary means of forming GCCVersion objects.
1285 /*static*/
1286 Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) {
1287   const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1288   std::pair<StringRef, StringRef> First = VersionText.split('.');
1289   std::pair<StringRef, StringRef> Second = First.second.split('.');
1290
1291   GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1292   if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
1293     return BadVersion;
1294   GoodVersion.MajorStr = First.first.str();
1295   if (First.second.empty())
1296     return GoodVersion;
1297   if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
1298     return BadVersion;
1299   GoodVersion.MinorStr = Second.first.str();
1300
1301   // First look for a number prefix and parse that if present. Otherwise just
1302   // stash the entire patch string in the suffix, and leave the number
1303   // unspecified. This covers versions strings such as:
1304   //   5        (handled above)
1305   //   4.4
1306   //   4.4.0
1307   //   4.4.x
1308   //   4.4.2-rc4
1309   //   4.4.x-patched
1310   // And retains any patch number it finds.
1311   StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
1312   if (!PatchText.empty()) {
1313     if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
1314       // Try to parse the number and any suffix.
1315       if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1316           GoodVersion.Patch < 0)
1317         return BadVersion;
1318       GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
1319     }
1320   }
1321
1322   return GoodVersion;
1323 }
1324
1325 /// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering.
1326 bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor,
1327                                           int RHSPatch,
1328                                           StringRef RHSPatchSuffix) const {
1329   if (Major != RHSMajor)
1330     return Major < RHSMajor;
1331   if (Minor != RHSMinor)
1332     return Minor < RHSMinor;
1333   if (Patch != RHSPatch) {
1334     // Note that versions without a specified patch sort higher than those with
1335     // a patch.
1336     if (RHSPatch == -1)
1337       return true;
1338     if (Patch == -1)
1339       return false;
1340
1341     // Otherwise just sort on the patch itself.
1342     return Patch < RHSPatch;
1343   }
1344   if (PatchSuffix != RHSPatchSuffix) {
1345     // Sort empty suffixes higher.
1346     if (RHSPatchSuffix.empty())
1347       return true;
1348     if (PatchSuffix.empty())
1349       return false;
1350
1351     // Provide a lexicographic sort to make this a total ordering.
1352     return PatchSuffix < RHSPatchSuffix;
1353   }
1354
1355   // The versions are equal.
1356   return false;
1357 }
1358
1359 static llvm::StringRef getGCCToolchainDir(const ArgList &Args) {
1360   const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
1361   if (A)
1362     return A->getValue();
1363   return GCC_INSTALL_PREFIX;
1364 }
1365
1366 /// \brief Initialize a GCCInstallationDetector from the driver.
1367 ///
1368 /// This performs all of the autodetection and sets up the various paths.
1369 /// Once constructed, a GCCInstallationDetector is essentially immutable.
1370 ///
1371 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
1372 /// should instead pull the target out of the driver. This is currently
1373 /// necessary because the driver doesn't store the final version of the target
1374 /// triple.
1375 void Generic_GCC::GCCInstallationDetector::init(
1376     const llvm::Triple &TargetTriple, const ArgList &Args,
1377     ArrayRef<std::string> ExtraTripleAliases) {
1378   llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1379                                          ? TargetTriple.get64BitArchVariant()
1380                                          : TargetTriple.get32BitArchVariant();
1381   // The library directories which may contain GCC installations.
1382   SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
1383   // The compatible GCC triples for this particular architecture.
1384   SmallVector<StringRef, 16> CandidateTripleAliases;
1385   SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
1386   CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1387                            CandidateTripleAliases, CandidateBiarchLibDirs,
1388                            CandidateBiarchTripleAliases);
1389
1390   // Compute the set of prefixes for our search.
1391   SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1392                                        D.PrefixDirs.end());
1393
1394   StringRef GCCToolchainDir = getGCCToolchainDir(Args);
1395   if (GCCToolchainDir != "") {
1396     if (GCCToolchainDir.back() == '/')
1397       GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1398
1399     Prefixes.push_back(GCCToolchainDir);
1400   } else {
1401     // If we have a SysRoot, try that first.
1402     if (!D.SysRoot.empty()) {
1403       Prefixes.push_back(D.SysRoot);
1404       Prefixes.push_back(D.SysRoot + "/usr");
1405     }
1406
1407     // Then look for gcc installed alongside clang.
1408     Prefixes.push_back(D.InstalledDir + "/..");
1409
1410     // Then look for distribution supplied gcc installations.
1411     if (D.SysRoot.empty()) {
1412       // Look for RHEL devtoolsets.
1413       Prefixes.push_back("/opt/rh/devtoolset-4/root/usr");
1414       Prefixes.push_back("/opt/rh/devtoolset-3/root/usr");
1415       Prefixes.push_back("/opt/rh/devtoolset-2/root/usr");
1416       Prefixes.push_back("/opt/rh/devtoolset-1.1/root/usr");
1417       Prefixes.push_back("/opt/rh/devtoolset-1.0/root/usr");
1418       // And finally in /usr.
1419       Prefixes.push_back("/usr");
1420     }
1421   }
1422
1423   // Loop over the various components which exist and select the best GCC
1424   // installation available. GCC installs are ranked by version number.
1425   Version = GCCVersion::Parse("0.0.0");
1426   for (const std::string &Prefix : Prefixes) {
1427     if (!D.getVFS().exists(Prefix))
1428       continue;
1429     for (StringRef Suffix : CandidateLibDirs) {
1430       const std::string LibDir = Prefix + Suffix.str();
1431       if (!D.getVFS().exists(LibDir))
1432         continue;
1433       for (StringRef Candidate : ExtraTripleAliases) // Try these first.
1434         ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1435       for (StringRef Candidate : CandidateTripleAliases)
1436         ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1437     }
1438     for (StringRef Suffix : CandidateBiarchLibDirs) {
1439       const std::string LibDir = Prefix + Suffix.str();
1440       if (!D.getVFS().exists(LibDir))
1441         continue;
1442       for (StringRef Candidate : CandidateBiarchTripleAliases)
1443         ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1444                                /*NeedsBiarchSuffix=*/ true);
1445     }
1446   }
1447 }
1448
1449 void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
1450   for (const auto &InstallPath : CandidateGCCInstallPaths)
1451     OS << "Found candidate GCC installation: " << InstallPath << "\n";
1452
1453   if (!GCCInstallPath.empty())
1454     OS << "Selected GCC installation: " << GCCInstallPath << "\n";
1455
1456   for (const auto &Multilib : Multilibs)
1457     OS << "Candidate multilib: " << Multilib << "\n";
1458
1459   if (Multilibs.size() != 0 || !SelectedMultilib.isDefault())
1460     OS << "Selected multilib: " << SelectedMultilib << "\n";
1461 }
1462
1463 bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
1464   if (BiarchSibling.hasValue()) {
1465     M = BiarchSibling.getValue();
1466     return true;
1467   }
1468   return false;
1469 }
1470
1471 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1472     const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
1473     SmallVectorImpl<StringRef> &LibDirs,
1474     SmallVectorImpl<StringRef> &TripleAliases,
1475     SmallVectorImpl<StringRef> &BiarchLibDirs,
1476     SmallVectorImpl<StringRef> &BiarchTripleAliases) {
1477   // Declare a bunch of static data sets that we'll select between below. These
1478   // are specifically designed to always refer to string literals to avoid any
1479   // lifetime or initialization issues.
1480   static const char *const AArch64LibDirs[] = {"/lib64", "/lib"};
1481   static const char *const AArch64Triples[] = {
1482       "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-linux-android",
1483       "aarch64-redhat-linux"};
1484   static const char *const AArch64beLibDirs[] = {"/lib"};
1485   static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu",
1486                                                  "aarch64_be-linux-gnu"};
1487
1488   static const char *const ARMLibDirs[] = {"/lib"};
1489   static const char *const ARMTriples[] = {"arm-linux-gnueabi",
1490                                            "arm-linux-androideabi"};
1491   static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf",
1492                                              "armv7hl-redhat-linux-gnueabi"};
1493   static const char *const ARMebLibDirs[] = {"/lib"};
1494   static const char *const ARMebTriples[] = {"armeb-linux-gnueabi",
1495                                              "armeb-linux-androideabi"};
1496   static const char *const ARMebHFTriples[] = {
1497       "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"};
1498
1499   static const char *const X86_64LibDirs[] = {"/lib64", "/lib"};
1500   static const char *const X86_64Triples[] = {
1501       "x86_64-linux-gnu",       "x86_64-unknown-linux-gnu",
1502       "x86_64-pc-linux-gnu",    "x86_64-redhat-linux6E",
1503       "x86_64-redhat-linux",    "x86_64-suse-linux",
1504       "x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
1505       "x86_64-slackware-linux", "x86_64-linux-android",
1506       "x86_64-unknown-linux"};
1507   static const char *const X32LibDirs[] = {"/libx32"};
1508   static const char *const X86LibDirs[] = {"/lib32", "/lib"};
1509   static const char *const X86Triples[] = {
1510       "i686-linux-gnu",       "i686-pc-linux-gnu",     "i486-linux-gnu",
1511       "i386-linux-gnu",       "i386-redhat-linux6E",   "i686-redhat-linux",
1512       "i586-redhat-linux",    "i386-redhat-linux",     "i586-suse-linux",
1513       "i486-slackware-linux", "i686-montavista-linux", "i686-linux-android",
1514       "i586-linux-gnu"};
1515
1516   static const char *const MIPSLibDirs[] = {"/lib"};
1517   static const char *const MIPSTriples[] = {"mips-linux-gnu", "mips-mti-linux",
1518                                             "mips-mti-linux-gnu",
1519                                             "mips-img-linux-gnu"};
1520   static const char *const MIPSELLibDirs[] = {"/lib"};
1521   static const char *const MIPSELTriples[] = {
1522       "mipsel-linux-gnu", "mipsel-linux-android", "mips-img-linux-gnu"};
1523
1524   static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"};
1525   static const char *const MIPS64Triples[] = {
1526       "mips64-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu",
1527       "mips64-linux-gnuabi64"};
1528   static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"};
1529   static const char *const MIPS64ELTriples[] = {
1530       "mips64el-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu",
1531       "mips64el-linux-android", "mips64el-linux-gnuabi64"};
1532
1533   static const char *const PPCLibDirs[] = {"/lib32", "/lib"};
1534   static const char *const PPCTriples[] = {
1535       "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
1536       "powerpc-suse-linux", "powerpc-montavista-linuxspe"};
1537   static const char *const PPC64LibDirs[] = {"/lib64", "/lib"};
1538   static const char *const PPC64Triples[] = {
1539       "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu",
1540       "powerpc64-suse-linux", "ppc64-redhat-linux"};
1541   static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"};
1542   static const char *const PPC64LETriples[] = {
1543       "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu",
1544       "powerpc64le-suse-linux", "ppc64le-redhat-linux"};
1545
1546   static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"};
1547   static const char *const SPARCv8Triples[] = {"sparc-linux-gnu",
1548                                                "sparcv8-linux-gnu"};
1549   static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"};
1550   static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",
1551                                                "sparcv9-linux-gnu"};
1552
1553   static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};
1554   static const char *const SystemZTriples[] = {
1555       "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
1556       "s390x-suse-linux", "s390x-redhat-linux"};
1557
1558   // Solaris.
1559   static const char *const SolarisSPARCLibDirs[] = {"/gcc"};
1560   static const char *const SolarisSPARCTriples[] = {"sparc-sun-solaris2.11",
1561                                                     "i386-pc-solaris2.11"};
1562
1563   using std::begin;
1564   using std::end;
1565
1566   if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1567     LibDirs.append(begin(SolarisSPARCLibDirs), end(SolarisSPARCLibDirs));
1568     TripleAliases.append(begin(SolarisSPARCTriples), end(SolarisSPARCTriples));
1569     return;
1570   }
1571
1572   switch (TargetTriple.getArch()) {
1573   case llvm::Triple::aarch64:
1574     LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1575     TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1576     BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1577     BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1578     break;
1579   case llvm::Triple::aarch64_be:
1580     LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1581     TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1582     BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1583     BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1584     break;
1585   case llvm::Triple::arm:
1586   case llvm::Triple::thumb:
1587     LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
1588     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1589       TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
1590     } else {
1591       TripleAliases.append(begin(ARMTriples), end(ARMTriples));
1592     }
1593     break;
1594   case llvm::Triple::armeb:
1595   case llvm::Triple::thumbeb:
1596     LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
1597     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1598       TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
1599     } else {
1600       TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
1601     }
1602     break;
1603   case llvm::Triple::x86_64:
1604     LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1605     TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1606     // x32 is always available when x86_64 is available, so adding it as
1607     // secondary arch with x86_64 triples
1608     if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
1609       BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
1610       BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1611     } else {
1612       BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1613       BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
1614     }
1615     break;
1616   case llvm::Triple::x86:
1617     LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1618     // MCU toolchain is 32 bit only and its triple alias is TargetTriple
1619     // itself, which will be appended below.
1620     if (!TargetTriple.isOSIAMCU()) {
1621       TripleAliases.append(begin(X86Triples), end(X86Triples));
1622       BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1623       BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1624     }
1625     break;
1626   case llvm::Triple::mips:
1627     LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1628     TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1629     BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1630     BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1631     break;
1632   case llvm::Triple::mipsel:
1633     LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1634     TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1635     TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1636     BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1637     BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1638     break;
1639   case llvm::Triple::mips64:
1640     LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1641     TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1642     BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1643     BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1644     break;
1645   case llvm::Triple::mips64el:
1646     LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1647     TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1648     BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1649     BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1650     BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1651     break;
1652   case llvm::Triple::ppc:
1653     LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1654     TripleAliases.append(begin(PPCTriples), end(PPCTriples));
1655     BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1656     BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1657     break;
1658   case llvm::Triple::ppc64:
1659     LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1660     TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1661     BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1662     BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
1663     break;
1664   case llvm::Triple::ppc64le:
1665     LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
1666     TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
1667     break;
1668   case llvm::Triple::sparc:
1669   case llvm::Triple::sparcel:
1670     LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1671     TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1672     BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1673     BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1674     break;
1675   case llvm::Triple::sparcv9:
1676     LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1677     TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1678     BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1679     BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1680     break;
1681   case llvm::Triple::systemz:
1682     LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
1683     TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
1684     break;
1685   default:
1686     // By default, just rely on the standard lib directories and the original
1687     // triple.
1688     break;
1689   }
1690
1691   // Always append the drivers target triple to the end, in case it doesn't
1692   // match any of our aliases.
1693   TripleAliases.push_back(TargetTriple.str());
1694
1695   // Also include the multiarch variant if it's different.
1696   if (TargetTriple.str() != BiarchTriple.str())
1697     BiarchTripleAliases.push_back(BiarchTriple.str());
1698 }
1699
1700 // Parses the contents of version.txt in an CUDA installation.  It should
1701 // contain one line of the from e.g. "CUDA Version 7.5.2".
1702 static CudaVersion ParseCudaVersionFile(llvm::StringRef V) {
1703   if (!V.startswith("CUDA Version "))
1704     return CudaVersion::UNKNOWN;
1705   V = V.substr(strlen("CUDA Version "));
1706   int Major = -1, Minor = -1;
1707   auto First = V.split('.');
1708   auto Second = First.second.split('.');
1709   if (!First.first.getAsInteger(10, Major) ||
1710       !Second.first.getAsInteger(10, Minor))
1711     return CudaVersion::UNKNOWN;
1712
1713   if (Major == 7 && Minor == 0) {
1714     // This doesn't appear to ever happen -- version.txt doesn't exist in the
1715     // CUDA 7 installs I've seen.  But no harm in checking.
1716     return CudaVersion::CUDA_70;
1717   }
1718   if (Major == 7 && Minor == 5)
1719     return CudaVersion::CUDA_75;
1720   if (Major == 8 && Minor == 0)
1721     return CudaVersion::CUDA_80;
1722   return CudaVersion::UNKNOWN;
1723 }
1724
1725 // \brief -- try common CUDA installation paths looking for files we need for
1726 // CUDA compilation.
1727 void Generic_GCC::CudaInstallationDetector::init(
1728     const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args) {
1729   SmallVector<std::string, 4> CudaPathCandidates;
1730
1731   if (Args.hasArg(options::OPT_cuda_path_EQ))
1732     CudaPathCandidates.push_back(
1733         Args.getLastArgValue(options::OPT_cuda_path_EQ));
1734   else {
1735     CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda");
1736     // FIXME: Uncomment this once we can compile the cuda 8 headers.
1737     // CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-8.0");
1738     CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-7.5");
1739     CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-7.0");
1740   }
1741
1742   for (const auto &CudaPath : CudaPathCandidates) {
1743     if (CudaPath.empty() || !D.getVFS().exists(CudaPath))
1744       continue;
1745
1746     InstallPath = CudaPath;
1747     BinPath = CudaPath + "/bin";
1748     IncludePath = InstallPath + "/include";
1749     LibDevicePath = InstallPath + "/nvvm/libdevice";
1750     LibPath = InstallPath + (TargetTriple.isArch64Bit() ? "/lib64" : "/lib");
1751
1752     auto &FS = D.getVFS();
1753     if (!(FS.exists(IncludePath) && FS.exists(BinPath) && FS.exists(LibPath) &&
1754           FS.exists(LibDevicePath)))
1755       continue;
1756
1757     std::error_code EC;
1758     for (llvm::sys::fs::directory_iterator LI(LibDevicePath, EC), LE;
1759          !EC && LI != LE; LI = LI.increment(EC)) {
1760       StringRef FilePath = LI->path();
1761       StringRef FileName = llvm::sys::path::filename(FilePath);
1762       // Process all bitcode filenames that look like libdevice.compute_XX.YY.bc
1763       const StringRef LibDeviceName = "libdevice.";
1764       if (!(FileName.startswith(LibDeviceName) && FileName.endswith(".bc")))
1765         continue;
1766       StringRef GpuArch = FileName.slice(
1767           LibDeviceName.size(), FileName.find('.', LibDeviceName.size()));
1768       LibDeviceMap[GpuArch] = FilePath.str();
1769       // Insert map entries for specifc devices with this compute capability.
1770       if (GpuArch == "compute_20") {
1771         LibDeviceMap["sm_20"] = FilePath;
1772         LibDeviceMap["sm_21"] = FilePath;
1773       } else if (GpuArch == "compute_30") {
1774         LibDeviceMap["sm_30"] = FilePath;
1775         LibDeviceMap["sm_32"] = FilePath;
1776       } else if (GpuArch == "compute_35") {
1777         LibDeviceMap["sm_35"] = FilePath;
1778         LibDeviceMap["sm_37"] = FilePath;
1779       } else if (GpuArch == "compute_50") {
1780         LibDeviceMap["sm_50"] = FilePath;
1781         LibDeviceMap["sm_52"] = FilePath;
1782         LibDeviceMap["sm_53"] = FilePath;
1783         LibDeviceMap["sm_60"] = FilePath;
1784         LibDeviceMap["sm_61"] = FilePath;
1785         LibDeviceMap["sm_62"] = FilePath;
1786       }
1787     }
1788
1789     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> VersionFile =
1790         FS.getBufferForFile(InstallPath + "/version.txt");
1791     if (!VersionFile) {
1792       // CUDA 7.0 doesn't have a version.txt, so guess that's our version if
1793       // version.txt isn't present.
1794       Version = CudaVersion::CUDA_70;
1795     } else {
1796       Version = ParseCudaVersionFile((*VersionFile)->getBuffer());
1797     }
1798
1799     IsValid = true;
1800     break;
1801   }
1802 }
1803
1804 void Generic_GCC::CudaInstallationDetector::CheckCudaVersionSupportsArch(
1805     CudaArch Arch) const {
1806   if (Arch == CudaArch::UNKNOWN || Version == CudaVersion::UNKNOWN ||
1807       ArchsWithVersionTooLowErrors.count(Arch) > 0)
1808     return;
1809
1810   auto RequiredVersion = MinVersionForCudaArch(Arch);
1811   if (Version < RequiredVersion) {
1812     ArchsWithVersionTooLowErrors.insert(Arch);
1813     D.Diag(diag::err_drv_cuda_version_too_low)
1814         << InstallPath << CudaArchToString(Arch) << CudaVersionToString(Version)
1815         << CudaVersionToString(RequiredVersion);
1816   }
1817 }
1818
1819 void Generic_GCC::CudaInstallationDetector::print(raw_ostream &OS) const {
1820   if (isValid())
1821     OS << "Found CUDA installation: " << InstallPath << ", version "
1822        << CudaVersionToString(Version) << "\n";
1823 }
1824
1825 namespace {
1826 // Filter to remove Multilibs that don't exist as a suffix to Path
1827 class FilterNonExistent {
1828   StringRef Base, File;
1829   vfs::FileSystem &VFS;
1830
1831 public:
1832   FilterNonExistent(StringRef Base, StringRef File, vfs::FileSystem &VFS)
1833       : Base(Base), File(File), VFS(VFS) {}
1834   bool operator()(const Multilib &M) {
1835     return !VFS.exists(Base + M.gccSuffix() + File);
1836   }
1837 };
1838 } // end anonymous namespace
1839
1840 static void addMultilibFlag(bool Enabled, const char *const Flag,
1841                             std::vector<std::string> &Flags) {
1842   if (Enabled)
1843     Flags.push_back(std::string("+") + Flag);
1844   else
1845     Flags.push_back(std::string("-") + Flag);
1846 }
1847
1848 static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) {
1849   return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
1850 }
1851
1852 static bool isMipsArch(llvm::Triple::ArchType Arch) {
1853   return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
1854          Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1855 }
1856
1857 static bool isMips32(llvm::Triple::ArchType Arch) {
1858   return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel;
1859 }
1860
1861 static bool isMips64(llvm::Triple::ArchType Arch) {
1862   return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1863 }
1864
1865 static bool isMipsEL(llvm::Triple::ArchType Arch) {
1866   return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1867 }
1868
1869 static bool isMips16(const ArgList &Args) {
1870   Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
1871   return A && A->getOption().matches(options::OPT_mips16);
1872 }
1873
1874 static bool isMicroMips(const ArgList &Args) {
1875   Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
1876   return A && A->getOption().matches(options::OPT_mmicromips);
1877 }
1878
1879 namespace {
1880 struct DetectedMultilibs {
1881   /// The set of multilibs that the detected installation supports.
1882   MultilibSet Multilibs;
1883
1884   /// The primary multilib appropriate for the given flags.
1885   Multilib SelectedMultilib;
1886
1887   /// On Biarch systems, this corresponds to the default multilib when
1888   /// targeting the non-default multilib. Otherwise, it is empty.
1889   llvm::Optional<Multilib> BiarchSibling;
1890 };
1891 } // end anonymous namespace
1892
1893 static Multilib makeMultilib(StringRef commonSuffix) {
1894   return Multilib(commonSuffix, commonSuffix, commonSuffix);
1895 }
1896
1897 static bool findMipsCsMultilibs(const Multilib::flags_list &Flags,
1898                                 FilterNonExistent &NonExistent,
1899                                 DetectedMultilibs &Result) {
1900   // Check for Code Sourcery toolchain multilibs
1901   MultilibSet CSMipsMultilibs;
1902   {
1903     auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16");
1904
1905     auto MArchMicroMips =
1906         makeMultilib("/micromips").flag("+m32").flag("+mmicromips");
1907
1908     auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips");
1909
1910     auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
1911
1912     auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float");
1913
1914     auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
1915
1916     auto DefaultFloat =
1917         makeMultilib("").flag("-msoft-float").flag("-mnan=2008");
1918
1919     auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
1920
1921     auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1922
1923     // Note that this one's osSuffix is ""
1924     auto MAbi64 = makeMultilib("")
1925                       .gccSuffix("/64")
1926                       .includeSuffix("/64")
1927                       .flag("+mabi=n64")
1928                       .flag("-mabi=n32")
1929                       .flag("-m32");
1930
1931     CSMipsMultilibs =
1932         MultilibSet()
1933             .Either(MArchMips16, MArchMicroMips, MArchDefault)
1934             .Maybe(UCLibc)
1935             .Either(SoftFloat, Nan2008, DefaultFloat)
1936             .FilterOut("/micromips/nan2008")
1937             .FilterOut("/mips16/nan2008")
1938             .Either(BigEndian, LittleEndian)
1939             .Maybe(MAbi64)
1940             .FilterOut("/mips16.*/64")
1941             .FilterOut("/micromips.*/64")
1942             .FilterOut(NonExistent)
1943             .setIncludeDirsCallback([](const Multilib &M) {
1944               std::vector<std::string> Dirs({"/include"});
1945               if (StringRef(M.includeSuffix()).startswith("/uclibc"))
1946                 Dirs.push_back(
1947                     "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1948               else
1949                 Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include");
1950               return Dirs;
1951             });
1952   }
1953
1954   MultilibSet DebianMipsMultilibs;
1955   {
1956     Multilib MAbiN32 =
1957         Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32");
1958
1959     Multilib M64 = Multilib()
1960                        .gccSuffix("/64")
1961                        .includeSuffix("/64")
1962                        .flag("+m64")
1963                        .flag("-m32")
1964                        .flag("-mabi=n32");
1965
1966     Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32");
1967
1968     DebianMipsMultilibs =
1969         MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent);
1970   }
1971
1972   // Sort candidates. Toolchain that best meets the directories tree goes first.
1973   // Then select the first toolchains matches command line flags.
1974   MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1975   if (CSMipsMultilibs.size() < DebianMipsMultilibs.size())
1976     std::iter_swap(Candidates, Candidates + 1);
1977   for (const MultilibSet *Candidate : Candidates) {
1978     if (Candidate->select(Flags, Result.SelectedMultilib)) {
1979       if (Candidate == &DebianMipsMultilibs)
1980         Result.BiarchSibling = Multilib();
1981       Result.Multilibs = *Candidate;
1982       return true;
1983     }
1984   }
1985   return false;
1986 }
1987
1988 static bool findMipsAndroidMultilibs(const Multilib::flags_list &Flags,
1989                                      FilterNonExistent &NonExistent,
1990                                      DetectedMultilibs &Result) {
1991
1992   MultilibSet AndroidMipsMultilibs =
1993       MultilibSet()
1994           .Maybe(Multilib("/mips-r2").flag("+march=mips32r2"))
1995           .Maybe(Multilib("/mips-r6").flag("+march=mips32r6"))
1996           .FilterOut(NonExistent);
1997
1998   if (AndroidMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
1999     Result.Multilibs = AndroidMipsMultilibs;
2000     return true;
2001   }
2002   return false;
2003 }
2004
2005 static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags,
2006                                   FilterNonExistent &NonExistent,
2007                                   DetectedMultilibs &Result) {
2008   // Musl toolchain multilibs
2009   MultilibSet MuslMipsMultilibs;
2010   {
2011     auto MArchMipsR2 = makeMultilib("")
2012                            .osSuffix("/mips-r2-hard-musl")
2013                            .flag("+EB")
2014                            .flag("-EL")
2015                            .flag("+march=mips32r2");
2016
2017     auto MArchMipselR2 = makeMultilib("/mipsel-r2-hard-musl")
2018                              .flag("-EB")
2019                              .flag("+EL")
2020                              .flag("+march=mips32r2");
2021
2022     MuslMipsMultilibs = MultilibSet().Either(MArchMipsR2, MArchMipselR2);
2023
2024     // Specify the callback that computes the include directories.
2025     MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) {
2026       return std::vector<std::string>(
2027           {"/../sysroot" + M.osSuffix() + "/usr/include"});
2028     });
2029   }
2030   if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
2031     Result.Multilibs = MuslMipsMultilibs;
2032     return true;
2033   }
2034   return false;
2035 }
2036
2037 static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags,
2038                                  FilterNonExistent &NonExistent,
2039                                  DetectedMultilibs &Result) {
2040   // CodeScape MTI toolchain v1.2 and early.
2041   MultilibSet MtiMipsMultilibsV1;
2042   {
2043     auto MArchMips32 = makeMultilib("/mips32")
2044                            .flag("+m32")
2045                            .flag("-m64")
2046                            .flag("-mmicromips")
2047                            .flag("+march=mips32");
2048
2049     auto MArchMicroMips = makeMultilib("/micromips")
2050                               .flag("+m32")
2051                               .flag("-m64")
2052                               .flag("+mmicromips");
2053
2054     auto MArchMips64r2 = makeMultilib("/mips64r2")
2055                              .flag("-m32")
2056                              .flag("+m64")
2057                              .flag("+march=mips64r2");
2058
2059     auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag(
2060         "-march=mips64r2");
2061
2062     auto MArchDefault = makeMultilib("")
2063                             .flag("+m32")
2064                             .flag("-m64")
2065                             .flag("-mmicromips")
2066                             .flag("+march=mips32r2");
2067
2068     auto Mips16 = makeMultilib("/mips16").flag("+mips16");
2069
2070     auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
2071
2072     auto MAbi64 =
2073         makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
2074
2075     auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
2076
2077     auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
2078
2079     auto SoftFloat = makeMultilib("/sof").flag("+msoft-float");
2080
2081     auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
2082
2083     MtiMipsMultilibsV1 =
2084         MultilibSet()
2085             .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
2086                     MArchDefault)
2087             .Maybe(UCLibc)
2088             .Maybe(Mips16)
2089             .FilterOut("/mips64/mips16")
2090             .FilterOut("/mips64r2/mips16")
2091             .FilterOut("/micromips/mips16")
2092             .Maybe(MAbi64)
2093             .FilterOut("/micromips/64")
2094             .FilterOut("/mips32/64")
2095             .FilterOut("^/64")
2096             .FilterOut("/mips16/64")
2097             .Either(BigEndian, LittleEndian)
2098             .Maybe(SoftFloat)
2099             .Maybe(Nan2008)
2100             .FilterOut(".*sof/nan2008")
2101             .FilterOut(NonExistent)
2102             .setIncludeDirsCallback([](const Multilib &M) {
2103               std::vector<std::string> Dirs({"/include"});
2104               if (StringRef(M.includeSuffix()).startswith("/uclibc"))
2105                 Dirs.push_back("/../../../../sysroot/uclibc/usr/include");
2106               else
2107                 Dirs.push_back("/../../../../sysroot/usr/include");
2108               return Dirs;
2109             });
2110   }
2111
2112   // CodeScape IMG toolchain starting from v1.3.
2113   MultilibSet MtiMipsMultilibsV2;
2114   {
2115     auto BeHard = makeMultilib("/mips-r2-hard")
2116                       .flag("+EB")
2117                       .flag("-msoft-float")
2118                       .flag("-mnan=2008")
2119                       .flag("-muclibc");
2120     auto BeSoft = makeMultilib("/mips-r2-soft")
2121                       .flag("+EB")
2122                       .flag("+msoft-float")
2123                       .flag("-mnan=2008");
2124     auto ElHard = makeMultilib("/mipsel-r2-hard")
2125                       .flag("+EL")
2126                       .flag("-msoft-float")
2127                       .flag("-mnan=2008")
2128                       .flag("-muclibc");
2129     auto ElSoft = makeMultilib("/mipsel-r2-soft")
2130                       .flag("+EL")
2131                       .flag("+msoft-float")
2132                       .flag("-mnan=2008")
2133                       .flag("-mmicromips");
2134     auto BeHardNan = makeMultilib("/mips-r2-hard-nan2008")
2135                          .flag("+EB")
2136                          .flag("-msoft-float")
2137                          .flag("+mnan=2008")
2138                          .flag("-muclibc");
2139     auto ElHardNan = makeMultilib("/mipsel-r2-hard-nan2008")
2140                          .flag("+EL")
2141                          .flag("-msoft-float")
2142                          .flag("+mnan=2008")
2143                          .flag("-muclibc")
2144                          .flag("-mmicromips");
2145     auto BeHardNanUclibc = makeMultilib("/mips-r2-hard-nan2008-uclibc")
2146                                .flag("+EB")
2147                                .flag("-msoft-float")
2148                                .flag("+mnan=2008")
2149                                .flag("+muclibc");
2150     auto ElHardNanUclibc = makeMultilib("/mipsel-r2-hard-nan2008-uclibc")
2151                                .flag("+EL")
2152                                .flag("-msoft-float")
2153                                .flag("+mnan=2008")
2154                                .flag("+muclibc");
2155     auto BeHardUclibc = makeMultilib("/mips-r2-hard-uclibc")
2156                             .flag("+EB")
2157                             .flag("-msoft-float")
2158                             .flag("-mnan=2008")
2159                             .flag("+muclibc");
2160     auto ElHardUclibc = makeMultilib("/mipsel-r2-hard-uclibc")
2161                             .flag("+EL")
2162                             .flag("-msoft-float")
2163                             .flag("-mnan=2008")
2164                             .flag("+muclibc");
2165     auto ElMicroHardNan = makeMultilib("/micromipsel-r2-hard-nan2008")
2166                               .flag("+EL")
2167                               .flag("-msoft-float")
2168                               .flag("+mnan=2008")
2169                               .flag("+mmicromips");
2170     auto ElMicroSoft = makeMultilib("/micromipsel-r2-soft")
2171                            .flag("+EL")
2172                            .flag("+msoft-float")
2173                            .flag("-mnan=2008")
2174                            .flag("+mmicromips");
2175
2176     auto O32 =
2177         makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
2178     auto N32 =
2179         makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
2180     auto N64 =
2181         makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
2182
2183     MtiMipsMultilibsV2 =
2184         MultilibSet()
2185             .Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
2186                      BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
2187                      ElHardUclibc, ElMicroHardNan, ElMicroSoft})
2188             .Either(O32, N32, N64)
2189             .FilterOut(NonExistent)
2190             .setIncludeDirsCallback([](const Multilib &M) {
2191               return std::vector<std::string>({"/../../../../sysroot" +
2192                                                M.includeSuffix() +
2193                                                "/../usr/include"});
2194             })
2195             .setFilePathsCallback([](const Multilib &M) {
2196               return std::vector<std::string>(
2197                   {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()});
2198             });
2199   }
2200   for (auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
2201     if (Candidate->select(Flags, Result.SelectedMultilib)) {
2202       Result.Multilibs = *Candidate;
2203       return true;
2204     }
2205   }
2206   return false;
2207 }
2208
2209 static bool findMipsImgMultilibs(const Multilib::flags_list &Flags,
2210                                  FilterNonExistent &NonExistent,
2211                                  DetectedMultilibs &Result) {
2212   // CodeScape IMG toolchain v1.2 and early.
2213   MultilibSet ImgMultilibsV1;
2214   {
2215     auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32");
2216
2217     auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
2218
2219     auto MAbi64 =
2220         makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
2221
2222     ImgMultilibsV1 =
2223         MultilibSet()
2224             .Maybe(Mips64r6)
2225             .Maybe(MAbi64)
2226             .Maybe(LittleEndian)
2227             .FilterOut(NonExistent)
2228             .setIncludeDirsCallback([](const Multilib &M) {
2229               return std::vector<std::string>(
2230                   {"/include", "/../../../../sysroot/usr/include"});
2231             });
2232   }
2233
2234   // CodeScape IMG toolchain starting from v1.3.
2235   MultilibSet ImgMultilibsV2;
2236   {
2237     auto BeHard = makeMultilib("/mips-r6-hard")
2238                       .flag("+EB")
2239                       .flag("-msoft-float")
2240                       .flag("-mmicromips");
2241     auto BeSoft = makeMultilib("/mips-r6-soft")
2242                       .flag("+EB")
2243                       .flag("+msoft-float")
2244                       .flag("-mmicromips");
2245     auto ElHard = makeMultilib("/mipsel-r6-hard")
2246                       .flag("+EL")
2247                       .flag("-msoft-float")
2248                       .flag("-mmicromips");
2249     auto ElSoft = makeMultilib("/mipsel-r6-soft")
2250                       .flag("+EL")
2251                       .flag("+msoft-float")
2252                       .flag("-mmicromips");
2253     auto BeMicroHard = makeMultilib("/micromips-r6-hard")
2254                            .flag("+EB")
2255                            .flag("-msoft-float")
2256                            .flag("+mmicromips");
2257     auto BeMicroSoft = makeMultilib("/micromips-r6-soft")
2258                            .flag("+EB")
2259                            .flag("+msoft-float")
2260                            .flag("+mmicromips");
2261     auto ElMicroHard = makeMultilib("/micromipsel-r6-hard")
2262                            .flag("+EL")
2263                            .flag("-msoft-float")
2264                            .flag("+mmicromips");
2265     auto ElMicroSoft = makeMultilib("/micromipsel-r6-soft")
2266                            .flag("+EL")
2267                            .flag("+msoft-float")
2268                            .flag("+mmicromips");
2269
2270     auto O32 =
2271         makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
2272     auto N32 =
2273         makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
2274     auto N64 =
2275         makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
2276
2277     ImgMultilibsV2 =
2278         MultilibSet()
2279             .Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
2280                      ElMicroHard, ElMicroSoft})
2281             .Either(O32, N32, N64)
2282             .FilterOut(NonExistent)
2283             .setIncludeDirsCallback([](const Multilib &M) {
2284               return std::vector<std::string>({"/../../../../sysroot" +
2285                                                M.includeSuffix() +
2286                                                "/../usr/include"});
2287             })
2288             .setFilePathsCallback([](const Multilib &M) {
2289               return std::vector<std::string>(
2290                   {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()});
2291             });
2292   }
2293   for (auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
2294     if (Candidate->select(Flags, Result.SelectedMultilib)) {
2295       Result.Multilibs = *Candidate;
2296       return true;
2297     }
2298   }
2299   return false;
2300 }
2301
2302 static bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
2303                               StringRef Path, const ArgList &Args,
2304                               DetectedMultilibs &Result) {
2305   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
2306
2307   StringRef CPUName;
2308   StringRef ABIName;
2309   tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName);
2310
2311   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2312
2313   Multilib::flags_list Flags;
2314   addMultilibFlag(isMips32(TargetArch), "m32", Flags);
2315   addMultilibFlag(isMips64(TargetArch), "m64", Flags);
2316   addMultilibFlag(isMips16(Args), "mips16", Flags);
2317   addMultilibFlag(CPUName == "mips32", "march=mips32", Flags);
2318   addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" ||
2319                       CPUName == "mips32r5" || CPUName == "p5600",
2320                   "march=mips32r2", Flags);
2321   addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags);
2322   addMultilibFlag(CPUName == "mips64", "march=mips64", Flags);
2323   addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" ||
2324                       CPUName == "mips64r5" || CPUName == "octeon",
2325                   "march=mips64r2", Flags);
2326   addMultilibFlag(isMicroMips(Args), "mmicromips", Flags);
2327   addMultilibFlag(tools::mips::isUCLibc(Args), "muclibc", Flags);
2328   addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple), "mnan=2008",
2329                   Flags);
2330   addMultilibFlag(ABIName == "n32", "mabi=n32", Flags);
2331   addMultilibFlag(ABIName == "n64", "mabi=n64", Flags);
2332   addMultilibFlag(isSoftFloatABI(Args), "msoft-float", Flags);
2333   addMultilibFlag(!isSoftFloatABI(Args), "mhard-float", Flags);
2334   addMultilibFlag(isMipsEL(TargetArch), "EL", Flags);
2335   addMultilibFlag(!isMipsEL(TargetArch), "EB", Flags);
2336
2337   if (TargetTriple.isAndroid())
2338     return findMipsAndroidMultilibs(Flags, NonExistent, Result);
2339
2340   if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
2341       TargetTriple.getOS() == llvm::Triple::Linux &&
2342       TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
2343     return findMipsMuslMultilibs(Flags, NonExistent, Result);
2344
2345   if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
2346       TargetTriple.getOS() == llvm::Triple::Linux &&
2347       TargetTriple.getEnvironment() == llvm::Triple::GNU)
2348     return findMipsMtiMultilibs(Flags, NonExistent, Result);
2349
2350   if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
2351       TargetTriple.getOS() == llvm::Triple::Linux &&
2352       TargetTriple.getEnvironment() == llvm::Triple::GNU)
2353     return findMipsImgMultilibs(Flags, NonExistent, Result);
2354
2355   if (findMipsCsMultilibs(Flags, NonExistent, Result))
2356     return true;
2357
2358   // Fallback to the regular toolchain-tree structure.
2359   Multilib Default;
2360   Result.Multilibs.push_back(Default);
2361   Result.Multilibs.FilterOut(NonExistent);
2362
2363   if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
2364     Result.BiarchSibling = Multilib();
2365     return true;
2366   }
2367
2368   return false;
2369 }
2370
2371 static void findAndroidArmMultilibs(const Driver &D,
2372                                     const llvm::Triple &TargetTriple,
2373                                     StringRef Path, const ArgList &Args,
2374                                     DetectedMultilibs &Result) {
2375   // Find multilibs with subdirectories like armv7-a, thumb, armv7-a/thumb.
2376   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
2377   Multilib ArmV7Multilib = makeMultilib("/armv7-a")
2378                                .flag("+armv7")
2379                                .flag("-thumb");
2380   Multilib ThumbMultilib = makeMultilib("/thumb")
2381                                .flag("-armv7")
2382                                .flag("+thumb");
2383   Multilib ArmV7ThumbMultilib = makeMultilib("/armv7-a/thumb")
2384                                .flag("+armv7")
2385                                .flag("+thumb");
2386   Multilib DefaultMultilib = makeMultilib("")
2387                                .flag("-armv7")
2388                                .flag("-thumb");
2389   MultilibSet AndroidArmMultilibs =
2390       MultilibSet()
2391           .Either(ThumbMultilib, ArmV7Multilib,
2392                   ArmV7ThumbMultilib, DefaultMultilib)
2393           .FilterOut(NonExistent);
2394
2395   Multilib::flags_list Flags;
2396   llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
2397   bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
2398   bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
2399   bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
2400   bool IsThumbMode = IsThumbArch ||
2401       Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) ||
2402       (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::IK_THUMB);
2403   bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
2404       (llvm::ARM::parseArchVersion(Arch) == 7 ||
2405        (IsArmArch && Arch == "" && IsV7SubArch));
2406   addMultilibFlag(IsArmV7Mode, "armv7", Flags);
2407   addMultilibFlag(IsThumbMode, "thumb", Flags);
2408
2409   if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib))
2410     Result.Multilibs = AndroidArmMultilibs;
2411 }
2412
2413 static bool findBiarchMultilibs(const Driver &D,
2414                                 const llvm::Triple &TargetTriple,
2415                                 StringRef Path, const ArgList &Args,
2416                                 bool NeedsBiarchSuffix,
2417                                 DetectedMultilibs &Result) {
2418   // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
2419   // in what would normally be GCCInstallPath and put the 64-bit
2420   // libs in a subdirectory named 64. The simple logic we follow is that
2421   // *if* there is a subdirectory of the right name with crtbegin.o in it,
2422   // we use that. If not, and if not a biarch triple alias, we look for
2423   // crtbegin.o without the subdirectory.
2424
2425   Multilib Default;
2426   Multilib Alt64 = Multilib()
2427                        .gccSuffix("/64")
2428                        .includeSuffix("/64")
2429                        .flag("-m32")
2430                        .flag("+m64")
2431                        .flag("-mx32");
2432   Multilib Alt32 = Multilib()
2433                        .gccSuffix("/32")
2434                        .includeSuffix("/32")
2435                        .flag("+m32")
2436                        .flag("-m64")
2437                        .flag("-mx32");
2438   Multilib Altx32 = Multilib()
2439                         .gccSuffix("/x32")
2440                         .includeSuffix("/x32")
2441                         .flag("-m32")
2442                         .flag("-m64")
2443                         .flag("+mx32");
2444
2445   // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a.
2446   FilterNonExistent NonExistent(
2447       Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS());
2448
2449   // Determine default multilib from: 32, 64, x32
2450   // Also handle cases such as 64 on 32, 32 on 64, etc.
2451   enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
2452   const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
2453   if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
2454     Want = WANT64;
2455   else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
2456     Want = WANT64;
2457   else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
2458     Want = WANT32;
2459   else {
2460     if (TargetTriple.isArch32Bit())
2461       Want = NeedsBiarchSuffix ? WANT64 : WANT32;
2462     else if (IsX32)
2463       Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
2464     else
2465       Want = NeedsBiarchSuffix ? WANT32 : WANT64;
2466   }
2467
2468   if (Want == WANT32)
2469     Default.flag("+m32").flag("-m64").flag("-mx32");
2470   else if (Want == WANT64)
2471     Default.flag("-m32").flag("+m64").flag("-mx32");
2472   else if (Want == WANTX32)
2473     Default.flag("-m32").flag("-m64").flag("+mx32");
2474   else
2475     return false;
2476
2477   Result.Multilibs.push_back(Default);
2478   Result.Multilibs.push_back(Alt64);
2479   Result.Multilibs.push_back(Alt32);
2480   Result.Multilibs.push_back(Altx32);
2481
2482   Result.Multilibs.FilterOut(NonExistent);
2483
2484   Multilib::flags_list Flags;
2485   addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "m64", Flags);
2486   addMultilibFlag(TargetTriple.isArch32Bit(), "m32", Flags);
2487   addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "mx32", Flags);
2488
2489   if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
2490     return false;
2491
2492   if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
2493       Result.SelectedMultilib == Altx32)
2494     Result.BiarchSibling = Default;
2495
2496   return true;
2497 }
2498
2499 void Generic_GCC::GCCInstallationDetector::scanLibDirForGCCTripleSolaris(
2500     const llvm::Triple &TargetArch, const llvm::opt::ArgList &Args,
2501     const std::string &LibDir, StringRef CandidateTriple,
2502     bool NeedsBiarchSuffix) {
2503   // Solaris is a special case. The GCC installation is under
2504   // /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/, so we
2505   // need to iterate twice.
2506   std::error_code EC;
2507   for (vfs::directory_iterator LI = D.getVFS().dir_begin(LibDir, EC), LE;
2508        !EC && LI != LE; LI = LI.increment(EC)) {
2509     StringRef VersionText = llvm::sys::path::filename(LI->getName());
2510     GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2511
2512     if (CandidateVersion.Major != -1) // Filter obviously bad entries.
2513       if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2514         continue; // Saw this path before; no need to look at it again.
2515     if (CandidateVersion.isOlderThan(4, 1, 1))
2516       continue;
2517     if (CandidateVersion <= Version)
2518       continue;
2519
2520     GCCInstallPath =
2521         LibDir + "/" + VersionText.str() + "/lib/gcc/" + CandidateTriple.str();
2522     if (!D.getVFS().exists(GCCInstallPath))
2523       continue;
2524
2525     // If we make it here there has to be at least one GCC version, let's just
2526     // use the latest one.
2527     std::error_code EEC;
2528     for (vfs::directory_iterator
2529              LLI = D.getVFS().dir_begin(GCCInstallPath, EEC),
2530              LLE;
2531          !EEC && LLI != LLE; LLI = LLI.increment(EEC)) {
2532
2533       StringRef SubVersionText = llvm::sys::path::filename(LLI->getName());
2534       GCCVersion CandidateSubVersion = GCCVersion::Parse(SubVersionText);
2535
2536       if (CandidateSubVersion > Version)
2537         Version = CandidateSubVersion;
2538     }
2539
2540     GCCTriple.setTriple(CandidateTriple);
2541
2542     GCCInstallPath += "/" + Version.Text;
2543     GCCParentLibPath = GCCInstallPath + "/../../../../";
2544
2545     IsValid = true;
2546   }
2547 }
2548
2549 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2550     const llvm::Triple &TargetTriple, const ArgList &Args,
2551     const std::string &LibDir, StringRef CandidateTriple,
2552     bool NeedsBiarchSuffix) {
2553   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2554   // There are various different suffixes involving the triple we
2555   // check for. We also record what is necessary to walk from each back
2556   // up to the lib directory. Specifically, the number of "up" steps
2557   // in the second half of each row is 1 + the number of path separators
2558   // in the first half.
2559   const std::string LibAndInstallSuffixes[][2] = {
2560       {"/gcc/" + CandidateTriple.str(), "/../../.."},
2561
2562       // Debian puts cross-compilers in gcc-cross
2563       {"/gcc-cross/" + CandidateTriple.str(), "/../../.."},
2564
2565       {"/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
2566        "/../../../.."},
2567
2568       // The Freescale PPC SDK has the gcc libraries in
2569       // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well.
2570       {"/" + CandidateTriple.str(), "/../.."},
2571
2572       // Ubuntu has a strange mis-matched pair of triples that this happens to
2573       // match.
2574       // FIXME: It may be worthwhile to generalize this and look for a second
2575       // triple.
2576       {"/i386-linux-gnu/gcc/" + CandidateTriple.str(), "/../../../.."}};
2577
2578   if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2579     scanLibDirForGCCTripleSolaris(TargetTriple, Args, LibDir, CandidateTriple,
2580                                   NeedsBiarchSuffix);
2581     return;
2582   }
2583
2584   // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
2585   const unsigned NumLibSuffixes = (llvm::array_lengthof(LibAndInstallSuffixes) -
2586                                    (TargetArch != llvm::Triple::x86));
2587   for (unsigned i = 0; i < NumLibSuffixes; ++i) {
2588     StringRef LibSuffix = LibAndInstallSuffixes[i][0];
2589     std::error_code EC;
2590     for (vfs::directory_iterator
2591              LI = D.getVFS().dir_begin(LibDir + LibSuffix, EC),
2592              LE;
2593          !EC && LI != LE; LI = LI.increment(EC)) {
2594       StringRef VersionText = llvm::sys::path::filename(LI->getName());
2595       GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2596       if (CandidateVersion.Major != -1) // Filter obviously bad entries.
2597         if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2598           continue; // Saw this path before; no need to look at it again.
2599       if (CandidateVersion.isOlderThan(4, 1, 1))
2600         continue;
2601       if (CandidateVersion <= Version)
2602         continue;
2603
2604       DetectedMultilibs Detected;
2605
2606       // Android standalone toolchain could have multilibs for ARM and Thumb.
2607       // Debian mips multilibs behave more like the rest of the biarch ones,
2608       // so handle them there
2609       if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) {
2610         // It should also work without multilibs in a simplified toolchain.
2611         findAndroidArmMultilibs(D, TargetTriple, LI->getName(), Args, Detected);
2612       } else if (isMipsArch(TargetArch)) {
2613         if (!findMIPSMultilibs(D, TargetTriple, LI->getName(), Args, Detected))
2614           continue;
2615       } else if (!findBiarchMultilibs(D, TargetTriple, LI->getName(), Args,
2616                                       NeedsBiarchSuffix, Detected)) {
2617         continue;
2618       }
2619
2620       Multilibs = Detected.Multilibs;
2621       SelectedMultilib = Detected.SelectedMultilib;
2622       BiarchSibling = Detected.BiarchSibling;
2623       Version = CandidateVersion;
2624       GCCTriple.setTriple(CandidateTriple);
2625       // FIXME: We hack together the directory name here instead of
2626       // using LI to ensure stable path separators across Windows and
2627       // Linux.
2628       GCCInstallPath =
2629           LibDir + LibAndInstallSuffixes[i][0] + "/" + VersionText.str();
2630       GCCParentLibPath = GCCInstallPath + LibAndInstallSuffixes[i][1];
2631       IsValid = true;
2632     }
2633   }
2634 }
2635
2636 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
2637                          const ArgList &Args)
2638     : ToolChain(D, Triple, Args), GCCInstallation(D), CudaInstallation(D) {
2639   getProgramPaths().push_back(getDriver().getInstalledDir());
2640   if (getDriver().getInstalledDir() != getDriver().Dir)
2641     getProgramPaths().push_back(getDriver().Dir);
2642 }
2643
2644 Generic_GCC::~Generic_GCC() {}
2645
2646 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
2647   switch (AC) {
2648   case Action::PreprocessJobClass:
2649     if (!Preprocess)
2650       Preprocess.reset(new tools::gcc::Preprocessor(*this));
2651     return Preprocess.get();
2652   case Action::CompileJobClass:
2653     if (!Compile)
2654       Compile.reset(new tools::gcc::Compiler(*this));
2655     return Compile.get();
2656   default:
2657     return ToolChain::getTool(AC);
2658   }
2659 }
2660
2661 Tool *Generic_GCC::buildAssembler() const {
2662   return new tools::gnutools::Assembler(*this);
2663 }
2664
2665 Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); }
2666
2667 void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
2668   // Print the information about how we detected the GCC installation.
2669   GCCInstallation.print(OS);
2670   CudaInstallation.print(OS);
2671 }
2672
2673 bool Generic_GCC::IsUnwindTablesDefault() const {
2674   return getArch() == llvm::Triple::x86_64;
2675 }
2676
2677 bool Generic_GCC::isPICDefault() const {
2678   return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2679 }
2680
2681 bool Generic_GCC::isPIEDefault() const { return false; }
2682
2683 bool Generic_GCC::isPICDefaultForced() const {
2684   return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2685 }
2686
2687 bool Generic_GCC::IsIntegratedAssemblerDefault() const {
2688   switch (getTriple().getArch()) {
2689   case llvm::Triple::x86:
2690   case llvm::Triple::x86_64:
2691   case llvm::Triple::aarch64:
2692   case llvm::Triple::aarch64_be:
2693   case llvm::Triple::arm:
2694   case llvm::Triple::armeb:
2695   case llvm::Triple::bpfel:
2696   case llvm::Triple::bpfeb:
2697   case llvm::Triple::thumb:
2698   case llvm::Triple::thumbeb:
2699   case llvm::Triple::ppc:
2700   case llvm::Triple::ppc64:
2701   case llvm::Triple::ppc64le:
2702   case llvm::Triple::systemz:
2703   case llvm::Triple::mips:
2704   case llvm::Triple::mipsel:
2705     return true;
2706   default:
2707     return false;
2708   }
2709 }
2710
2711 /// \brief Helper to add the variant paths of a libstdc++ installation.
2712 bool Generic_GCC::addLibStdCXXIncludePaths(
2713     Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2714     StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2715     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2716   if (!getVFS().exists(Base + Suffix))
2717     return false;
2718
2719   addSystemInclude(DriverArgs, CC1Args, Base + Suffix);
2720
2721   // The vanilla GCC layout of libstdc++ headers uses a triple subdirectory. If
2722   // that path exists or we have neither a GCC nor target multiarch triple, use
2723   // this vanilla search path.
2724   if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2725       getVFS().exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) {
2726     addSystemInclude(DriverArgs, CC1Args,
2727                      Base + Suffix + "/" + GCCTriple + IncludeSuffix);
2728   } else {
2729     // Otherwise try to use multiarch naming schemes which have normalized the
2730     // triples and put the triple before the suffix.
2731     //
2732     // GCC surprisingly uses *both* the GCC triple with a multilib suffix and
2733     // the target triple, so we support that here.
2734     addSystemInclude(DriverArgs, CC1Args,
2735                      Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2736     addSystemInclude(DriverArgs, CC1Args,
2737                      Base + "/" + TargetMultiarchTriple + Suffix);
2738   }
2739
2740   addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward");
2741   return true;
2742 }
2743
2744 void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs,
2745                                         ArgStringList &CC1Args) const {
2746   const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2747   bool UseInitArrayDefault =
2748       getTriple().getArch() == llvm::Triple::aarch64 ||
2749       getTriple().getArch() == llvm::Triple::aarch64_be ||
2750       (getTriple().getOS() == llvm::Triple::Linux &&
2751        (!V.isOlderThan(4, 7, 0) || getTriple().isAndroid())) ||
2752       getTriple().getOS() == llvm::Triple::NaCl ||
2753       (getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2754        !getTriple().hasEnvironment());
2755
2756   if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2757                          options::OPT_fno_use_init_array, UseInitArrayDefault))
2758     CC1Args.push_back("-fuse-init-array");
2759 }
2760
2761 /// Mips Toolchain
2762 MipsLLVMToolChain::MipsLLVMToolChain(const Driver &D,
2763                                      const llvm::Triple &Triple,
2764                                      const ArgList &Args)
2765     : Linux(D, Triple, Args) {
2766   // Select the correct multilib according to the given arguments.
2767   DetectedMultilibs Result;
2768   findMIPSMultilibs(D, Triple, "", Args, Result);
2769   Multilibs = Result.Multilibs;
2770   SelectedMultilib = Result.SelectedMultilib;
2771
2772   // Find out the library suffix based on the ABI.
2773   LibSuffix = tools::mips::getMipsABILibSuffix(Args, Triple);
2774   getFilePaths().clear();
2775   getFilePaths().push_back(computeSysRoot() + "/usr/lib" + LibSuffix);
2776
2777   // Use LLD by default.
2778   DefaultLinker = "lld";
2779 }
2780
2781 void MipsLLVMToolChain::AddClangSystemIncludeArgs(
2782     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2783   if (DriverArgs.hasArg(options::OPT_nostdinc))
2784     return;
2785
2786   const Driver &D = getDriver();
2787
2788   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2789     SmallString<128> P(D.ResourceDir);
2790     llvm::sys::path::append(P, "include");
2791     addSystemInclude(DriverArgs, CC1Args, P);
2792   }
2793
2794   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2795     return;
2796
2797   const auto &Callback = Multilibs.includeDirsCallback();
2798   if (Callback) {
2799     for (const auto &Path : Callback(SelectedMultilib))
2800       addExternCSystemIncludeIfExists(DriverArgs, CC1Args,
2801                                       D.getInstalledDir() + Path);
2802   }
2803 }
2804
2805 Tool *MipsLLVMToolChain::buildLinker() const {
2806   return new tools::gnutools::Linker(*this);
2807 }
2808
2809 std::string MipsLLVMToolChain::computeSysRoot() const {
2810   if (!getDriver().SysRoot.empty())
2811     return getDriver().SysRoot + SelectedMultilib.osSuffix();
2812
2813   const std::string InstalledDir(getDriver().getInstalledDir());
2814   std::string SysRootPath =
2815       InstalledDir + "/../sysroot" + SelectedMultilib.osSuffix();
2816   if (llvm::sys::fs::exists(SysRootPath))
2817     return SysRootPath;
2818
2819   return std::string();
2820 }
2821
2822 ToolChain::CXXStdlibType
2823 MipsLLVMToolChain::GetCXXStdlibType(const ArgList &Args) const {
2824   Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
2825   if (A) {
2826     StringRef Value = A->getValue();
2827     if (Value != "libc++")
2828       getDriver().Diag(diag::err_drv_invalid_stdlib_name)
2829           << A->getAsString(Args);
2830   }
2831
2832   return ToolChain::CST_Libcxx;
2833 }
2834
2835 void MipsLLVMToolChain::AddClangCXXStdlibIncludeArgs(
2836     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2837   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2838       DriverArgs.hasArg(options::OPT_nostdincxx))
2839     return;
2840
2841   assert((GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) &&
2842          "Only -lc++ (aka libcxx) is suported in this toolchain.");
2843
2844   const auto &Callback = Multilibs.includeDirsCallback();
2845   if (Callback) {
2846     for (std::string Path : Callback(SelectedMultilib)) {
2847       Path = getDriver().getInstalledDir() + Path + "/c++/v1";
2848       if (llvm::sys::fs::exists(Path)) {
2849         addSystemInclude(DriverArgs, CC1Args, Path);
2850         break;
2851       }
2852     }
2853   }
2854 }
2855
2856 void MipsLLVMToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
2857                                             ArgStringList &CmdArgs) const {
2858   assert((GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) &&
2859          "Only -lc++ (aka libxx) is suported in this toolchain.");
2860
2861   CmdArgs.push_back("-lc++");
2862   CmdArgs.push_back("-lc++abi");
2863   CmdArgs.push_back("-lunwind");
2864 }
2865
2866 std::string MipsLLVMToolChain::getCompilerRT(const ArgList &Args,
2867                                              StringRef Component,
2868                                              bool Shared) const {
2869   SmallString<128> Path(getDriver().ResourceDir);
2870   llvm::sys::path::append(Path, SelectedMultilib.osSuffix(), "lib" + LibSuffix,
2871                           getOS());
2872   llvm::sys::path::append(Path, Twine("libclang_rt." + Component + "-" +
2873                                       "mips" + (Shared ? ".so" : ".a")));
2874   return Path.str();
2875 }
2876
2877 /// Hexagon Toolchain
2878
2879 std::string HexagonToolChain::getHexagonTargetDir(
2880       const std::string &InstalledDir,
2881       const SmallVectorImpl<std::string> &PrefixDirs) const {
2882   std::string InstallRelDir;
2883   const Driver &D = getDriver();
2884
2885   // Locate the rest of the toolchain ...
2886   for (auto &I : PrefixDirs)
2887     if (D.getVFS().exists(I))
2888       return I;
2889
2890   if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))
2891     return InstallRelDir;
2892
2893   return InstallRelDir;
2894 }
2895
2896 Optional<unsigned> HexagonToolChain::getSmallDataThreshold(
2897       const ArgList &Args) {
2898   StringRef Gn = "";
2899   if (Arg *A = Args.getLastArg(options::OPT_G, options::OPT_G_EQ,
2900                                options::OPT_msmall_data_threshold_EQ)) {
2901     Gn = A->getValue();
2902   } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2903                              options::OPT_fPIC)) {
2904     Gn = "0";
2905   }
2906
2907   unsigned G;
2908   if (!Gn.getAsInteger(10, G))
2909     return G;
2910
2911   return None;
2912 }
2913
2914 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
2915       ToolChain::path_list &LibPaths) const {
2916   const Driver &D = getDriver();
2917
2918   //----------------------------------------------------------------------------
2919   // -L Args
2920   //----------------------------------------------------------------------------
2921   for (Arg *A : Args.filtered(options::OPT_L))
2922     for (const char *Value : A->getValues())
2923       LibPaths.push_back(Value);
2924
2925   //----------------------------------------------------------------------------
2926   // Other standard paths
2927   //----------------------------------------------------------------------------
2928   std::vector<std::string> RootDirs;
2929   std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
2930             std::back_inserter(RootDirs));
2931
2932   std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
2933                                               D.PrefixDirs);
2934   if (std::find(RootDirs.begin(), RootDirs.end(), TargetDir) == RootDirs.end())
2935     RootDirs.push_back(TargetDir);
2936
2937   bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
2938   // Assume G0 with -shared.
2939   bool HasG0 = Args.hasArg(options::OPT_shared);
2940   if (auto G = getSmallDataThreshold(Args))
2941     HasG0 = G.getValue() == 0;
2942
2943   const std::string CpuVer = GetTargetCPUVersion(Args).str();
2944   for (auto &Dir : RootDirs) {
2945     std::string LibDir = Dir + "/hexagon/lib";
2946     std::string LibDirCpu = LibDir + '/' + CpuVer;
2947     if (HasG0) {
2948       if (HasPIC)
2949         LibPaths.push_back(LibDirCpu + "/G0/pic");
2950       LibPaths.push_back(LibDirCpu + "/G0");
2951     }
2952     LibPaths.push_back(LibDirCpu);
2953     LibPaths.push_back(LibDir);
2954   }
2955 }
2956
2957 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
2958                                    const llvm::opt::ArgList &Args)
2959     : Linux(D, Triple, Args) {
2960   const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
2961                                                     D.PrefixDirs);
2962
2963   // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
2964   // program paths
2965   const std::string BinDir(TargetDir + "/bin");
2966   if (D.getVFS().exists(BinDir))
2967     getProgramPaths().push_back(BinDir);
2968
2969   ToolChain::path_list &LibPaths = getFilePaths();
2970
2971   // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
2972   // 'elf' OS type, so the Linux paths are not appropriate. When we actually
2973   // support 'linux' we'll need to fix this up
2974   LibPaths.clear();
2975   getHexagonLibraryPaths(Args, LibPaths);
2976 }
2977
2978 HexagonToolChain::~HexagonToolChain() {}
2979
2980 Tool *HexagonToolChain::buildAssembler() const {
2981   return new tools::hexagon::Assembler(*this);
2982 }
2983
2984 Tool *HexagonToolChain::buildLinker() const {
2985   return new tools::hexagon::Linker(*this);
2986 }
2987
2988 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2989                                                  ArgStringList &CC1Args) const {
2990   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2991       DriverArgs.hasArg(options::OPT_nostdlibinc))
2992     return;
2993
2994   const Driver &D = getDriver();
2995   std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
2996                                               D.PrefixDirs);
2997   addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include");
2998 }
2999
3000 void HexagonToolChain::AddClangCXXStdlibIncludeArgs(
3001     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
3002   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3003       DriverArgs.hasArg(options::OPT_nostdincxx))
3004     return;
3005
3006   const Driver &D = getDriver();
3007   std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
3008   addSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include/c++");
3009 }
3010
3011 ToolChain::CXXStdlibType
3012 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
3013   Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
3014   if (!A)
3015     return ToolChain::CST_Libstdcxx;
3016
3017   StringRef Value = A->getValue();
3018   if (Value != "libstdc++")
3019     getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3020
3021   return ToolChain::CST_Libstdcxx;
3022 }
3023
3024 //
3025 // Returns the default CPU for Hexagon. This is the default compilation target
3026 // if no Hexagon processor is selected at the command-line.
3027 //
3028 const StringRef HexagonToolChain::GetDefaultCPU() {
3029   return "hexagonv60";
3030 }
3031
3032 const StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
3033   Arg *CpuArg = nullptr;
3034   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ, options::OPT_march_EQ))
3035     CpuArg = A;
3036
3037   StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
3038   if (CPU.startswith("hexagon"))
3039     return CPU.substr(sizeof("hexagon") - 1);
3040   return CPU;
3041 }
3042 // End Hexagon
3043
3044 /// AMDGPU Toolchain
3045 AMDGPUToolChain::AMDGPUToolChain(const Driver &D, const llvm::Triple &Triple,
3046                                  const ArgList &Args)
3047   : Generic_ELF(D, Triple, Args) { }
3048
3049 Tool *AMDGPUToolChain::buildLinker() const {
3050   return new tools::amdgpu::Linker(*this);
3051 }
3052 // End AMDGPU
3053
3054 /// NaCl Toolchain
3055 NaClToolChain::NaClToolChain(const Driver &D, const llvm::Triple &Triple,
3056                              const ArgList &Args)
3057     : Generic_ELF(D, Triple, Args) {
3058
3059   // Remove paths added by Generic_GCC. NaCl Toolchain cannot use the
3060   // default paths, and must instead only use the paths provided
3061   // with this toolchain based on architecture.
3062   path_list &file_paths = getFilePaths();
3063   path_list &prog_paths = getProgramPaths();
3064
3065   file_paths.clear();
3066   prog_paths.clear();
3067
3068   // Path for library files (libc.a, ...)
3069   std::string FilePath(getDriver().Dir + "/../");
3070
3071   // Path for tools (clang, ld, etc..)
3072   std::string ProgPath(getDriver().Dir + "/../");
3073
3074   // Path for toolchain libraries (libgcc.a, ...)
3075   std::string ToolPath(getDriver().ResourceDir + "/lib/");
3076
3077   switch (Triple.getArch()) {
3078   case llvm::Triple::x86:
3079     file_paths.push_back(FilePath + "x86_64-nacl/lib32");
3080     file_paths.push_back(FilePath + "i686-nacl/usr/lib");
3081     prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
3082     file_paths.push_back(ToolPath + "i686-nacl");
3083     break;
3084   case llvm::Triple::x86_64:
3085     file_paths.push_back(FilePath + "x86_64-nacl/lib");
3086     file_paths.push_back(FilePath + "x86_64-nacl/usr/lib");
3087     prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
3088     file_paths.push_back(ToolPath + "x86_64-nacl");
3089     break;
3090   case llvm::Triple::arm:
3091     file_paths.push_back(FilePath + "arm-nacl/lib");
3092     file_paths.push_back(FilePath + "arm-nacl/usr/lib");
3093     prog_paths.push_back(ProgPath + "arm-nacl/bin");
3094     file_paths.push_back(ToolPath + "arm-nacl");
3095     break;
3096   case llvm::Triple::mipsel:
3097     file_paths.push_back(FilePath + "mipsel-nacl/lib");
3098     file_paths.push_back(FilePath + "mipsel-nacl/usr/lib");
3099     prog_paths.push_back(ProgPath + "bin");
3100     file_paths.push_back(ToolPath + "mipsel-nacl");
3101     break;
3102   default:
3103     break;
3104   }
3105
3106   NaClArmMacrosPath = GetFilePath("nacl-arm-macros.s");
3107 }
3108
3109 void NaClToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
3110                                               ArgStringList &CC1Args) const {
3111   const Driver &D = getDriver();
3112   if (DriverArgs.hasArg(options::OPT_nostdinc))
3113     return;
3114
3115   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
3116     SmallString<128> P(D.ResourceDir);
3117     llvm::sys::path::append(P, "include");
3118     addSystemInclude(DriverArgs, CC1Args, P.str());
3119   }
3120
3121   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
3122     return;
3123
3124   SmallString<128> P(D.Dir + "/../");
3125   switch (getTriple().getArch()) {
3126   case llvm::Triple::x86:
3127     // x86 is special because multilib style uses x86_64-nacl/include for libc
3128     // headers but the SDK wants i686-nacl/usr/include. The other architectures
3129     // have the same substring.
3130     llvm::sys::path::append(P, "i686-nacl/usr/include");
3131     addSystemInclude(DriverArgs, CC1Args, P.str());
3132     llvm::sys::path::remove_filename(P);
3133     llvm::sys::path::remove_filename(P);
3134     llvm::sys::path::remove_filename(P);
3135     llvm::sys::path::append(P, "x86_64-nacl/include");
3136     addSystemInclude(DriverArgs, CC1Args, P.str());
3137     return;
3138   case llvm::Triple::arm:
3139     llvm::sys::path::append(P, "arm-nacl/usr/include");
3140     break;
3141   case llvm::Triple::x86_64:
3142     llvm::sys::path::append(P, "x86_64-nacl/usr/include");
3143     break;
3144   case llvm::Triple::mipsel:
3145     llvm::sys::path::append(P, "mipsel-nacl/usr/include");
3146     break;
3147   default:
3148     return;
3149   }
3150
3151   addSystemInclude(DriverArgs, CC1Args, P.str());
3152   llvm::sys::path::remove_filename(P);
3153   llvm::sys::path::remove_filename(P);
3154   llvm::sys::path::append(P, "include");
3155   addSystemInclude(DriverArgs, CC1Args, P.str());
3156 }
3157
3158 void NaClToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
3159                                         ArgStringList &CmdArgs) const {
3160   // Check for -stdlib= flags. We only support libc++ but this consumes the arg
3161   // if the value is libc++, and emits an error for other values.
3162   GetCXXStdlibType(Args);
3163   CmdArgs.push_back("-lc++");
3164 }
3165
3166 void NaClToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3167                                                  ArgStringList &CC1Args) const {
3168   const Driver &D = getDriver();
3169   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3170       DriverArgs.hasArg(options::OPT_nostdincxx))
3171     return;
3172
3173   // Check for -stdlib= flags. We only support libc++ but this consumes the arg
3174   // if the value is libc++, and emits an error for other values.
3175   GetCXXStdlibType(DriverArgs);
3176
3177   SmallString<128> P(D.Dir + "/../");
3178   switch (getTriple().getArch()) {
3179   case llvm::Triple::arm:
3180     llvm::sys::path::append(P, "arm-nacl/include/c++/v1");
3181     addSystemInclude(DriverArgs, CC1Args, P.str());
3182     break;
3183   case llvm::Triple::x86:
3184     llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
3185     addSystemInclude(DriverArgs, CC1Args, P.str());
3186     break;
3187   case llvm::Triple::x86_64:
3188     llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
3189     addSystemInclude(DriverArgs, CC1Args, P.str());
3190     break;
3191   case llvm::Triple::mipsel:
3192     llvm::sys::path::append(P, "mipsel-nacl/include/c++/v1");
3193     addSystemInclude(DriverArgs, CC1Args, P.str());
3194     break;
3195   default:
3196     break;
3197   }
3198 }
3199
3200 ToolChain::CXXStdlibType
3201 NaClToolChain::GetCXXStdlibType(const ArgList &Args) const {
3202   if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
3203     StringRef Value = A->getValue();
3204     if (Value == "libc++")
3205       return ToolChain::CST_Libcxx;
3206     getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3207   }
3208
3209   return ToolChain::CST_Libcxx;
3210 }
3211
3212 std::string
3213 NaClToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
3214                                            types::ID InputType) const {
3215   llvm::Triple TheTriple(ComputeLLVMTriple(Args, InputType));
3216   if (TheTriple.getArch() == llvm::Triple::arm &&
3217       TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
3218     TheTriple.setEnvironment(llvm::Triple::GNUEABIHF);
3219   return TheTriple.getTriple();
3220 }
3221
3222 Tool *NaClToolChain::buildLinker() const {
3223   return new tools::nacltools::Linker(*this);
3224 }
3225
3226 Tool *NaClToolChain::buildAssembler() const {
3227   if (getTriple().getArch() == llvm::Triple::arm)
3228     return new tools::nacltools::AssemblerARM(*this);
3229   return new tools::gnutools::Assembler(*this);
3230 }
3231 // End NaCl
3232
3233 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
3234 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
3235 /// Currently does not support anything else but compilation.
3236
3237 TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple &Triple,
3238                            const ArgList &Args)
3239     : ToolChain(D, Triple, Args) {
3240   // Path mangling to find libexec
3241   std::string Path(getDriver().Dir);
3242
3243   Path += "/../libexec";
3244   getProgramPaths().push_back(Path);
3245 }
3246
3247 TCEToolChain::~TCEToolChain() {}
3248
3249 bool TCEToolChain::IsMathErrnoDefault() const { return true; }
3250
3251 bool TCEToolChain::isPICDefault() const { return false; }
3252
3253 bool TCEToolChain::isPIEDefault() const { return false; }
3254
3255 bool TCEToolChain::isPICDefaultForced() const { return false; }
3256
3257 // CloudABI - CloudABI tool chain which can call ld(1) directly.
3258
3259 CloudABI::CloudABI(const Driver &D, const llvm::Triple &Triple,
3260                    const ArgList &Args)
3261     : Generic_ELF(D, Triple, Args) {
3262   SmallString<128> P(getDriver().Dir);
3263   llvm::sys::path::append(P, "..", getTriple().str(), "lib");
3264   getFilePaths().push_back(P.str());
3265 }
3266
3267 void CloudABI::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3268                                             ArgStringList &CC1Args) const {
3269   if (DriverArgs.hasArg(options::OPT_nostdlibinc) &&
3270       DriverArgs.hasArg(options::OPT_nostdincxx))
3271     return;
3272
3273   SmallString<128> P(getDriver().Dir);
3274   llvm::sys::path::append(P, "..", getTriple().str(), "include/c++/v1");
3275   addSystemInclude(DriverArgs, CC1Args, P.str());
3276 }
3277
3278 void CloudABI::AddCXXStdlibLibArgs(const ArgList &Args,
3279                                    ArgStringList &CmdArgs) const {
3280   CmdArgs.push_back("-lc++");
3281   CmdArgs.push_back("-lc++abi");
3282   CmdArgs.push_back("-lunwind");
3283 }
3284
3285 Tool *CloudABI::buildLinker() const {
3286   return new tools::cloudabi::Linker(*this);
3287 }
3288
3289 bool CloudABI::isPIEDefault() const {
3290   // Only enable PIE on architectures that support PC-relative
3291   // addressing. PC-relative addressing is required, as the process
3292   // startup code must be able to relocate itself.
3293   switch (getTriple().getArch()) {
3294   case llvm::Triple::aarch64:
3295   case llvm::Triple::x86_64:
3296     return true;
3297   default:
3298     return false;
3299   }
3300 }
3301
3302 SanitizerMask CloudABI::getSupportedSanitizers() const {
3303   SanitizerMask Res = ToolChain::getSupportedSanitizers();
3304   Res |= SanitizerKind::SafeStack;
3305   return Res;
3306 }
3307
3308 SanitizerMask CloudABI::getDefaultSanitizers() const {
3309   return SanitizerKind::SafeStack;
3310 }
3311
3312 /// Haiku - Haiku tool chain which can call as(1) and ld(1) directly.
3313
3314 Haiku::Haiku(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
3315   : Generic_ELF(D, Triple, Args) {
3316
3317 }
3318
3319 void Haiku::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3320                                           ArgStringList &CC1Args) const {
3321   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3322       DriverArgs.hasArg(options::OPT_nostdincxx))
3323     return;
3324
3325   switch (GetCXXStdlibType(DriverArgs)) {
3326   case ToolChain::CST_Libcxx:
3327     addSystemInclude(DriverArgs, CC1Args,
3328                      getDriver().SysRoot + "/system/develop/headers/c++/v1");
3329     break;
3330   case ToolChain::CST_Libstdcxx:
3331     addSystemInclude(DriverArgs, CC1Args,
3332                      getDriver().SysRoot + "/system/develop/headers/c++");
3333     addSystemInclude(DriverArgs, CC1Args,
3334                      getDriver().SysRoot + "/system/develop/headers/c++/backward");
3335
3336     StringRef Triple = getTriple().str();
3337     addSystemInclude(DriverArgs, CC1Args,
3338                      getDriver().SysRoot + "/system/develop/headers/c++/" +
3339                      Triple);
3340     break;
3341   }
3342 }
3343
3344 /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
3345
3346 OpenBSD::OpenBSD(const Driver &D, const llvm::Triple &Triple,
3347                  const ArgList &Args)
3348     : Generic_ELF(D, Triple, Args) {
3349   getFilePaths().push_back(getDriver().Dir + "/../lib");
3350   getFilePaths().push_back("/usr/lib");
3351 }
3352
3353 Tool *OpenBSD::buildAssembler() const {
3354   return new tools::openbsd::Assembler(*this);
3355 }
3356
3357 Tool *OpenBSD::buildLinker() const { return new tools::openbsd::Linker(*this); }
3358
3359 /// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
3360
3361 Bitrig::Bitrig(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3362     : Generic_ELF(D, Triple, Args) {
3363   getFilePaths().push_back(getDriver().Dir + "/../lib");
3364   getFilePaths().push_back("/usr/lib");
3365 }
3366
3367 Tool *Bitrig::buildAssembler() const {
3368   return new tools::bitrig::Assembler(*this);
3369 }
3370
3371 Tool *Bitrig::buildLinker() const { return new tools::bitrig::Linker(*this); }
3372
3373 ToolChain::CXXStdlibType Bitrig::GetDefaultCXXStdlibType() const {
3374   return ToolChain::CST_Libcxx;
3375 }
3376
3377 void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3378                                           ArgStringList &CC1Args) const {
3379   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3380       DriverArgs.hasArg(options::OPT_nostdincxx))
3381     return;
3382
3383   switch (GetCXXStdlibType(DriverArgs)) {
3384   case ToolChain::CST_Libcxx:
3385     addSystemInclude(DriverArgs, CC1Args,
3386                      getDriver().SysRoot + "/usr/include/c++/v1");
3387     break;
3388   case ToolChain::CST_Libstdcxx:
3389     addSystemInclude(DriverArgs, CC1Args,
3390                      getDriver().SysRoot + "/usr/include/c++/stdc++");
3391     addSystemInclude(DriverArgs, CC1Args,
3392                      getDriver().SysRoot + "/usr/include/c++/stdc++/backward");
3393
3394     StringRef Triple = getTriple().str();
3395     if (Triple.startswith("amd64"))
3396       addSystemInclude(DriverArgs, CC1Args,
3397                        getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" +
3398                            Triple.substr(5));
3399     else
3400       addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot +
3401                                                 "/usr/include/c++/stdc++/" +
3402                                                 Triple);
3403     break;
3404   }
3405 }
3406
3407 void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
3408                                  ArgStringList &CmdArgs) const {
3409   switch (GetCXXStdlibType(Args)) {
3410   case ToolChain::CST_Libcxx:
3411     CmdArgs.push_back("-lc++");
3412     CmdArgs.push_back("-lc++abi");
3413     CmdArgs.push_back("-lpthread");
3414     break;
3415   case ToolChain::CST_Libstdcxx:
3416     CmdArgs.push_back("-lstdc++");
3417     break;
3418   }
3419 }
3420
3421 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
3422
3423 FreeBSD::FreeBSD(const Driver &D, const llvm::Triple &Triple,
3424                  const ArgList &Args)
3425     : Generic_ELF(D, Triple, Args) {
3426
3427   // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
3428   // back to '/usr/lib' if it doesn't exist.
3429   if ((Triple.getArch() == llvm::Triple::x86 ||
3430        Triple.getArch() == llvm::Triple::ppc) &&
3431       D.getVFS().exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
3432     getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
3433   else
3434     getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
3435 }
3436
3437 ToolChain::CXXStdlibType FreeBSD::GetDefaultCXXStdlibType() const {
3438   if (getTriple().getOSMajorVersion() >= 10)
3439     return ToolChain::CST_Libcxx;
3440   return ToolChain::CST_Libstdcxx;
3441 }
3442
3443 void FreeBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3444                                            ArgStringList &CC1Args) const {
3445   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3446       DriverArgs.hasArg(options::OPT_nostdincxx))
3447     return;
3448
3449   switch (GetCXXStdlibType(DriverArgs)) {
3450   case ToolChain::CST_Libcxx:
3451     addSystemInclude(DriverArgs, CC1Args,
3452                      getDriver().SysRoot + "/usr/include/c++/v1");
3453     break;
3454   case ToolChain::CST_Libstdcxx:
3455     addSystemInclude(DriverArgs, CC1Args,
3456                      getDriver().SysRoot + "/usr/include/c++/4.2");
3457     addSystemInclude(DriverArgs, CC1Args,
3458                      getDriver().SysRoot + "/usr/include/c++/4.2/backward");
3459     break;
3460   }
3461 }
3462
3463 void FreeBSD::AddCXXStdlibLibArgs(const ArgList &Args,
3464                                   ArgStringList &CmdArgs) const {
3465   CXXStdlibType Type = GetCXXStdlibType(Args);
3466   bool Profiling = Args.hasArg(options::OPT_pg);
3467
3468   switch (Type) {
3469   case ToolChain::CST_Libcxx:
3470     CmdArgs.push_back(Profiling ? "-lc++_p" : "-lc++");
3471     break;
3472
3473   case ToolChain::CST_Libstdcxx:
3474     CmdArgs.push_back(Profiling ? "-lstdc++_p" : "-lstdc++");
3475     break;
3476   }
3477 }
3478
3479 Tool *FreeBSD::buildAssembler() const {
3480   return new tools::freebsd::Assembler(*this);
3481 }
3482
3483 Tool *FreeBSD::buildLinker() const { return new tools::freebsd::Linker(*this); }
3484
3485 bool FreeBSD::UseSjLjExceptions(const ArgList &Args) const {
3486   // FreeBSD uses SjLj exceptions on ARM oabi.
3487   switch (getTriple().getEnvironment()) {
3488   case llvm::Triple::GNUEABIHF:
3489   case llvm::Triple::GNUEABI:
3490   case llvm::Triple::EABI:
3491     return false;
3492
3493   default:
3494     return (getTriple().getArch() == llvm::Triple::arm ||
3495             getTriple().getArch() == llvm::Triple::thumb);
3496   }
3497 }
3498
3499 bool FreeBSD::HasNativeLLVMSupport() const { return true; }
3500
3501 bool FreeBSD::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); }
3502
3503 SanitizerMask FreeBSD::getSupportedSanitizers() const {
3504   const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
3505   const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
3506   const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 ||
3507                         getTriple().getArch() == llvm::Triple::mips64el;
3508   SanitizerMask Res = ToolChain::getSupportedSanitizers();
3509   Res |= SanitizerKind::Address;
3510   Res |= SanitizerKind::Vptr;
3511   if (IsX86_64 || IsMIPS64) {
3512     Res |= SanitizerKind::Leak;
3513     Res |= SanitizerKind::Thread;
3514   }
3515   if (IsX86 || IsX86_64) {
3516     Res |= SanitizerKind::SafeStack;
3517   }
3518   return Res;
3519 }
3520
3521 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
3522
3523 NetBSD::NetBSD(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3524     : Generic_ELF(D, Triple, Args) {
3525   if (getDriver().UseStdLib) {
3526     // When targeting a 32-bit platform, try the special directory used on
3527     // 64-bit hosts, and only fall back to the main library directory if that
3528     // doesn't work.
3529     // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
3530     // what all logic is needed to emulate the '=' prefix here.
3531     switch (Triple.getArch()) {
3532     case llvm::Triple::x86:
3533       getFilePaths().push_back("=/usr/lib/i386");
3534       break;
3535     case llvm::Triple::arm:
3536     case llvm::Triple::armeb:
3537     case llvm::Triple::thumb:
3538     case llvm::Triple::thumbeb:
3539       switch (Triple.getEnvironment()) {
3540       case llvm::Triple::EABI:
3541       case llvm::Triple::GNUEABI:
3542         getFilePaths().push_back("=/usr/lib/eabi");
3543         break;
3544       case llvm::Triple::EABIHF:
3545       case llvm::Triple::GNUEABIHF:
3546         getFilePaths().push_back("=/usr/lib/eabihf");
3547         break;
3548       default:
3549         getFilePaths().push_back("=/usr/lib/oabi");
3550         break;
3551       }
3552       break;
3553     case llvm::Triple::mips64:
3554     case llvm::Triple::mips64el:
3555       if (tools::mips::hasMipsAbiArg(Args, "o32"))
3556         getFilePaths().push_back("=/usr/lib/o32");
3557       else if (tools::mips::hasMipsAbiArg(Args, "64"))
3558         getFilePaths().push_back("=/usr/lib/64");
3559       break;
3560     case llvm::Triple::ppc:
3561       getFilePaths().push_back("=/usr/lib/powerpc");
3562       break;
3563     case llvm::Triple::sparc:
3564       getFilePaths().push_back("=/usr/lib/sparc");
3565       break;
3566     default:
3567       break;
3568     }
3569
3570     getFilePaths().push_back("=/usr/lib");
3571   }
3572 }
3573
3574 Tool *NetBSD::buildAssembler() const {
3575   return new tools::netbsd::Assembler(*this);
3576 }
3577
3578 Tool *NetBSD::buildLinker() const { return new tools::netbsd::Linker(*this); }
3579
3580 ToolChain::CXXStdlibType NetBSD::GetDefaultCXXStdlibType() const {
3581   unsigned Major, Minor, Micro;
3582   getTriple().getOSVersion(Major, Minor, Micro);
3583   if (Major >= 7 || Major == 0) {
3584     switch (getArch()) {
3585     case llvm::Triple::aarch64:
3586     case llvm::Triple::arm:
3587     case llvm::Triple::armeb:
3588     case llvm::Triple::thumb:
3589     case llvm::Triple::thumbeb:
3590     case llvm::Triple::ppc:
3591     case llvm::Triple::ppc64:
3592     case llvm::Triple::ppc64le:
3593     case llvm::Triple::sparc:
3594     case llvm::Triple::sparcv9:
3595     case llvm::Triple::x86:
3596     case llvm::Triple::x86_64:
3597       return ToolChain::CST_Libcxx;
3598     default:
3599       break;
3600     }
3601   }
3602   return ToolChain::CST_Libstdcxx;
3603 }
3604
3605 void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3606                                           ArgStringList &CC1Args) const {
3607   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3608       DriverArgs.hasArg(options::OPT_nostdincxx))
3609     return;
3610
3611   switch (GetCXXStdlibType(DriverArgs)) {
3612   case ToolChain::CST_Libcxx:
3613     addSystemInclude(DriverArgs, CC1Args,
3614                      getDriver().SysRoot + "/usr/include/c++/");
3615     break;
3616   case ToolChain::CST_Libstdcxx:
3617     addSystemInclude(DriverArgs, CC1Args,
3618                      getDriver().SysRoot + "/usr/include/g++");
3619     addSystemInclude(DriverArgs, CC1Args,
3620                      getDriver().SysRoot + "/usr/include/g++/backward");
3621     break;
3622   }
3623 }
3624
3625 /// Minix - Minix tool chain which can call as(1) and ld(1) directly.
3626
3627 Minix::Minix(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3628     : Generic_ELF(D, Triple, Args) {
3629   getFilePaths().push_back(getDriver().Dir + "/../lib");
3630   getFilePaths().push_back("/usr/lib");
3631 }
3632
3633 Tool *Minix::buildAssembler() const {
3634   return new tools::minix::Assembler(*this);
3635 }
3636
3637 Tool *Minix::buildLinker() const { return new tools::minix::Linker(*this); }
3638
3639 static void addPathIfExists(const Driver &D, const Twine &Path,
3640                             ToolChain::path_list &Paths) {
3641   if (D.getVFS().exists(Path))
3642     Paths.push_back(Path.str());
3643 }
3644
3645 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
3646
3647 Solaris::Solaris(const Driver &D, const llvm::Triple &Triple,
3648                  const ArgList &Args)
3649     : Generic_GCC(D, Triple, Args) {
3650
3651   GCCInstallation.init(Triple, Args);
3652
3653   path_list &Paths = getFilePaths();
3654   if (GCCInstallation.isValid())
3655     addPathIfExists(D, GCCInstallation.getInstallPath(), Paths);
3656
3657   addPathIfExists(D, getDriver().getInstalledDir(), Paths);
3658   if (getDriver().getInstalledDir() != getDriver().Dir)
3659     addPathIfExists(D, getDriver().Dir, Paths);
3660
3661   addPathIfExists(D, getDriver().SysRoot + getDriver().Dir + "/../lib", Paths);
3662
3663   std::string LibPath = "/usr/lib/";
3664   switch (Triple.getArch()) {
3665   case llvm::Triple::x86:
3666   case llvm::Triple::sparc:
3667     break;
3668   case llvm::Triple::x86_64:
3669     LibPath += "amd64/";
3670     break;
3671   case llvm::Triple::sparcv9:
3672     LibPath += "sparcv9/";
3673     break;
3674   default:
3675     llvm_unreachable("Unsupported architecture");
3676   }
3677
3678   addPathIfExists(D, getDriver().SysRoot + LibPath, Paths);
3679 }
3680
3681 Tool *Solaris::buildAssembler() const {
3682   return new tools::solaris::Assembler(*this);
3683 }
3684
3685 Tool *Solaris::buildLinker() const { return new tools::solaris::Linker(*this); }
3686
3687 void Solaris::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3688                                            ArgStringList &CC1Args) const {
3689   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3690       DriverArgs.hasArg(options::OPT_nostdincxx))
3691     return;
3692
3693   // Include the support directory for things like xlocale and fudged system
3694   // headers.
3695   addSystemInclude(DriverArgs, CC1Args, "/usr/include/c++/v1/support/solaris");
3696
3697   if (GCCInstallation.isValid()) {
3698     GCCVersion Version = GCCInstallation.getVersion();
3699     addSystemInclude(DriverArgs, CC1Args,
3700                      getDriver().SysRoot + "/usr/gcc/" +
3701                      Version.MajorStr + "." +
3702                      Version.MinorStr +
3703                      "/include/c++/" + Version.Text);
3704     addSystemInclude(DriverArgs, CC1Args,
3705                      getDriver().SysRoot + "/usr/gcc/" + Version.MajorStr +
3706                      "." + Version.MinorStr + "/include/c++/" +
3707                      Version.Text + "/" +
3708                      GCCInstallation.getTriple().str());
3709   }
3710 }
3711
3712 /// Distribution (very bare-bones at the moment).
3713
3714 enum Distro {
3715   // NB: Releases of a particular Linux distro should be kept together
3716   // in this enum, because some tests are done by integer comparison against
3717   // the first and last known member in the family, e.g. IsRedHat().
3718   ArchLinux,
3719   DebianLenny,
3720   DebianSqueeze,
3721   DebianWheezy,
3722   DebianJessie,
3723   DebianStretch,
3724   Exherbo,
3725   RHEL5,
3726   RHEL6,
3727   RHEL7,
3728   Fedora,
3729   OpenSUSE,
3730   UbuntuHardy,
3731   UbuntuIntrepid,
3732   UbuntuJaunty,
3733   UbuntuKarmic,
3734   UbuntuLucid,
3735   UbuntuMaverick,
3736   UbuntuNatty,
3737   UbuntuOneiric,
3738   UbuntuPrecise,
3739   UbuntuQuantal,
3740   UbuntuRaring,
3741   UbuntuSaucy,
3742   UbuntuTrusty,
3743   UbuntuUtopic,
3744   UbuntuVivid,
3745   UbuntuWily,
3746   UbuntuXenial,
3747   UnknownDistro
3748 };
3749
3750 static bool IsRedhat(enum Distro Distro) {
3751   return Distro == Fedora || (Distro >= RHEL5 && Distro <= RHEL7);
3752 }
3753
3754 static bool IsOpenSUSE(enum Distro Distro) { return Distro == OpenSUSE; }
3755
3756 static bool IsDebian(enum Distro Distro) {
3757   return Distro >= DebianLenny && Distro <= DebianStretch;
3758 }
3759
3760 static bool IsUbuntu(enum Distro Distro) {
3761   return Distro >= UbuntuHardy && Distro <= UbuntuXenial;
3762 }
3763
3764 static Distro DetectDistro(const Driver &D, llvm::Triple::ArchType Arch) {
3765   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
3766       llvm::MemoryBuffer::getFile("/etc/lsb-release");
3767   if (File) {
3768     StringRef Data = File.get()->getBuffer();
3769     SmallVector<StringRef, 16> Lines;
3770     Data.split(Lines, "\n");
3771     Distro Version = UnknownDistro;
3772     for (StringRef Line : Lines)
3773       if (Version == UnknownDistro && Line.startswith("DISTRIB_CODENAME="))
3774         Version = llvm::StringSwitch<Distro>(Line.substr(17))
3775                       .Case("hardy", UbuntuHardy)
3776                       .Case("intrepid", UbuntuIntrepid)
3777                       .Case("jaunty", UbuntuJaunty)
3778                       .Case("karmic", UbuntuKarmic)
3779                       .Case("lucid", UbuntuLucid)
3780                       .Case("maverick", UbuntuMaverick)
3781                       .Case("natty", UbuntuNatty)
3782                       .Case("oneiric", UbuntuOneiric)
3783                       .Case("precise", UbuntuPrecise)
3784                       .Case("quantal", UbuntuQuantal)
3785                       .Case("raring", UbuntuRaring)
3786                       .Case("saucy", UbuntuSaucy)
3787                       .Case("trusty", UbuntuTrusty)
3788                       .Case("utopic", UbuntuUtopic)
3789                       .Case("vivid", UbuntuVivid)
3790                       .Case("wily", UbuntuWily)
3791                       .Case("xenial", UbuntuXenial)
3792                       .Default(UnknownDistro);
3793     if (Version != UnknownDistro)
3794       return Version;
3795   }
3796
3797   File = llvm::MemoryBuffer::getFile("/etc/redhat-release");
3798   if (File) {
3799     StringRef Data = File.get()->getBuffer();
3800     if (Data.startswith("Fedora release"))
3801       return Fedora;
3802     if (Data.startswith("Red Hat Enterprise Linux") ||
3803         Data.startswith("CentOS") ||
3804         Data.startswith("Scientific Linux")) {
3805       if (Data.find("release 7") != StringRef::npos)
3806         return RHEL7;
3807       else if (Data.find("release 6") != StringRef::npos)
3808         return RHEL6;
3809       else if (Data.find("release 5") != StringRef::npos)
3810         return RHEL5;
3811     }
3812     return UnknownDistro;
3813   }
3814
3815   File = llvm::MemoryBuffer::getFile("/etc/debian_version");
3816   if (File) {
3817     StringRef Data = File.get()->getBuffer();
3818     if (Data[0] == '5')
3819       return DebianLenny;
3820     else if (Data.startswith("squeeze/sid") || Data[0] == '6')
3821       return DebianSqueeze;
3822     else if (Data.startswith("wheezy/sid") || Data[0] == '7')
3823       return DebianWheezy;
3824     else if (Data.startswith("jessie/sid") || Data[0] == '8')
3825       return DebianJessie;
3826     else if (Data.startswith("stretch/sid") || Data[0] == '9')
3827       return DebianStretch;
3828     return UnknownDistro;
3829   }
3830
3831   if (D.getVFS().exists("/etc/SuSE-release"))
3832     return OpenSUSE;
3833
3834   if (D.getVFS().exists("/etc/exherbo-release"))
3835     return Exherbo;
3836
3837   if (D.getVFS().exists("/etc/arch-release"))
3838     return ArchLinux;
3839
3840   return UnknownDistro;
3841 }
3842
3843 /// \brief Get our best guess at the multiarch triple for a target.
3844 ///
3845 /// Debian-based systems are starting to use a multiarch setup where they use
3846 /// a target-triple directory in the library and header search paths.
3847 /// Unfortunately, this triple does not align with the vanilla target triple,
3848 /// so we provide a rough mapping here.
3849 static std::string getMultiarchTriple(const Driver &D,
3850                                       const llvm::Triple &TargetTriple,
3851                                       StringRef SysRoot) {
3852   llvm::Triple::EnvironmentType TargetEnvironment =
3853       TargetTriple.getEnvironment();
3854
3855   // For most architectures, just use whatever we have rather than trying to be
3856   // clever.
3857   switch (TargetTriple.getArch()) {
3858   default:
3859     break;
3860
3861   // We use the existence of '/lib/<triple>' as a directory to detect some
3862   // common linux triples that don't quite match the Clang triple for both
3863   // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
3864   // regardless of what the actual target triple is.
3865   case llvm::Triple::arm:
3866   case llvm::Triple::thumb:
3867     if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
3868       if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabihf"))
3869         return "arm-linux-gnueabihf";
3870     } else {
3871       if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabi"))
3872         return "arm-linux-gnueabi";
3873     }
3874     break;
3875   case llvm::Triple::armeb:
3876   case llvm::Triple::thumbeb:
3877     if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
3878       if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabihf"))
3879         return "armeb-linux-gnueabihf";
3880     } else {
3881       if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabi"))
3882         return "armeb-linux-gnueabi";
3883     }
3884     break;
3885   case llvm::Triple::x86:
3886     if (D.getVFS().exists(SysRoot + "/lib/i386-linux-gnu"))
3887       return "i386-linux-gnu";
3888     break;
3889   case llvm::Triple::x86_64:
3890     // We don't want this for x32, otherwise it will match x86_64 libs
3891     if (TargetEnvironment != llvm::Triple::GNUX32 &&
3892         D.getVFS().exists(SysRoot + "/lib/x86_64-linux-gnu"))
3893       return "x86_64-linux-gnu";
3894     break;
3895   case llvm::Triple::aarch64:
3896     if (D.getVFS().exists(SysRoot + "/lib/aarch64-linux-gnu"))
3897       return "aarch64-linux-gnu";
3898     break;
3899   case llvm::Triple::aarch64_be:
3900     if (D.getVFS().exists(SysRoot + "/lib/aarch64_be-linux-gnu"))
3901       return "aarch64_be-linux-gnu";
3902     break;
3903   case llvm::Triple::mips:
3904     if (D.getVFS().exists(SysRoot + "/lib/mips-linux-gnu"))
3905       return "mips-linux-gnu";
3906     break;
3907   case llvm::Triple::mipsel:
3908     if (D.getVFS().exists(SysRoot + "/lib/mipsel-linux-gnu"))
3909       return "mipsel-linux-gnu";
3910     break;
3911   case llvm::Triple::mips64:
3912     if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnu"))
3913       return "mips64-linux-gnu";
3914     if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnuabi64"))
3915       return "mips64-linux-gnuabi64";
3916     break;
3917   case llvm::Triple::mips64el:
3918     if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnu"))
3919       return "mips64el-linux-gnu";
3920     if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnuabi64"))
3921       return "mips64el-linux-gnuabi64";
3922     break;
3923   case llvm::Triple::ppc:
3924     if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
3925       return "powerpc-linux-gnuspe";
3926     if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnu"))
3927       return "powerpc-linux-gnu";
3928     break;
3929   case llvm::Triple::ppc64:
3930     if (D.getVFS().exists(SysRoot + "/lib/powerpc64-linux-gnu"))
3931       return "powerpc64-linux-gnu";
3932     break;
3933   case llvm::Triple::ppc64le:
3934     if (D.getVFS().exists(SysRoot + "/lib/powerpc64le-linux-gnu"))
3935       return "powerpc64le-linux-gnu";
3936     break;
3937   case llvm::Triple::sparc:
3938     if (D.getVFS().exists(SysRoot + "/lib/sparc-linux-gnu"))
3939       return "sparc-linux-gnu";
3940     break;
3941   case llvm::Triple::sparcv9:
3942     if (D.getVFS().exists(SysRoot + "/lib/sparc64-linux-gnu"))
3943       return "sparc64-linux-gnu";
3944     break;
3945   case llvm::Triple::systemz:
3946     if (D.getVFS().exists(SysRoot + "/lib/s390x-linux-gnu"))
3947       return "s390x-linux-gnu";
3948     break;
3949   }
3950   return TargetTriple.str();
3951 }
3952
3953 static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
3954   if (isMipsArch(Triple.getArch())) {
3955     // lib32 directory has a special meaning on MIPS targets.
3956     // It contains N32 ABI binaries. Use this folder if produce
3957     // code for N32 ABI only.
3958     if (tools::mips::hasMipsAbiArg(Args, "n32"))
3959       return "lib32";
3960     return Triple.isArch32Bit() ? "lib" : "lib64";
3961   }
3962
3963   // It happens that only x86 and PPC use the 'lib32' variant of oslibdir, and
3964   // using that variant while targeting other architectures causes problems
3965   // because the libraries are laid out in shared system roots that can't cope
3966   // with a 'lib32' library search path being considered. So we only enable
3967   // them when we know we may need it.
3968   //
3969   // FIXME: This is a bit of a hack. We should really unify this code for
3970   // reasoning about oslibdir spellings with the lib dir spellings in the
3971   // GCCInstallationDetector, but that is a more significant refactoring.
3972   if (Triple.getArch() == llvm::Triple::x86 ||
3973       Triple.getArch() == llvm::Triple::ppc)
3974     return "lib32";
3975
3976   if (Triple.getArch() == llvm::Triple::x86_64 &&
3977       Triple.getEnvironment() == llvm::Triple::GNUX32)
3978     return "libx32";
3979
3980   return Triple.isArch32Bit() ? "lib" : "lib64";
3981 }
3982
3983 static void addMultilibsFilePaths(const Driver &D, const MultilibSet &Multilibs,
3984                                   const Multilib &Multilib,
3985                                   StringRef InstallPath,
3986                                   ToolChain::path_list &Paths) {
3987   if (const auto &PathsCallback = Multilibs.filePathsCallback())
3988     for (const auto &Path : PathsCallback(Multilib))
3989       addPathIfExists(D, InstallPath + Path, Paths);
3990 }
3991
3992 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3993     : Generic_ELF(D, Triple, Args) {
3994   GCCInstallation.init(Triple, Args);
3995   CudaInstallation.init(Triple, Args);
3996   Multilibs = GCCInstallation.getMultilibs();
3997   llvm::Triple::ArchType Arch = Triple.getArch();
3998   std::string SysRoot = computeSysRoot();
3999
4000   // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
4001   // least) put various tools in a triple-prefixed directory off of the parent
4002   // of the GCC installation. We use the GCC triple here to ensure that we end
4003   // up with tools that support the same amount of cross compiling as the
4004   // detected GCC installation. For example, if we find a GCC installation
4005   // targeting x86_64, but it is a bi-arch GCC installation, it can also be
4006   // used to target i386.
4007   // FIXME: This seems unlikely to be Linux-specific.
4008   ToolChain::path_list &PPaths = getProgramPaths();
4009   PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
4010                          GCCInstallation.getTriple().str() + "/bin")
4011                        .str());
4012
4013   Distro Distro = DetectDistro(D, Arch);
4014
4015   if (IsOpenSUSE(Distro) || IsUbuntu(Distro)) {
4016     ExtraOpts.push_back("-z");
4017     ExtraOpts.push_back("relro");
4018   }
4019
4020   if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
4021     ExtraOpts.push_back("-X");
4022
4023   const bool IsAndroid = Triple.isAndroid();
4024   const bool IsMips = isMipsArch(Arch);
4025
4026   if (IsMips && !SysRoot.empty())
4027     ExtraOpts.push_back("--sysroot=" + SysRoot);
4028
4029   // Do not use 'gnu' hash style for Mips targets because .gnu.hash
4030   // and the MIPS ABI require .dynsym to be sorted in different ways.
4031   // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
4032   // ABI requires a mapping between the GOT and the symbol table.
4033   // Android loader does not support .gnu.hash.
4034   if (!IsMips && !IsAndroid) {
4035     if (IsRedhat(Distro) || IsOpenSUSE(Distro) ||
4036         (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
4037       ExtraOpts.push_back("--hash-style=gnu");
4038
4039     if (IsDebian(Distro) || IsOpenSUSE(Distro) || Distro == UbuntuLucid ||
4040         Distro == UbuntuJaunty || Distro == UbuntuKarmic)
4041       ExtraOpts.push_back("--hash-style=both");
4042   }
4043
4044   if (IsRedhat(Distro) && Distro != RHEL5 && Distro != RHEL6)
4045     ExtraOpts.push_back("--no-add-needed");
4046
4047 #ifdef ENABLE_LINKER_BUILD_ID
4048   ExtraOpts.push_back("--build-id");
4049 #endif
4050
4051   if (IsOpenSUSE(Distro))
4052     ExtraOpts.push_back("--enable-new-dtags");
4053
4054   // The selection of paths to try here is designed to match the patterns which
4055   // the GCC driver itself uses, as this is part of the GCC-compatible driver.
4056   // This was determined by running GCC in a fake filesystem, creating all
4057   // possible permutations of these directories, and seeing which ones it added
4058   // to the link paths.
4059   path_list &Paths = getFilePaths();
4060
4061   const std::string OSLibDir = getOSLibDir(Triple, Args);
4062   const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);
4063
4064   // Add the multilib suffixed paths where they are available.
4065   if (GCCInstallation.isValid()) {
4066     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
4067     const std::string &LibPath = GCCInstallation.getParentLibPath();
4068     const Multilib &Multilib = GCCInstallation.getMultilib();
4069     const MultilibSet &Multilibs = GCCInstallation.getMultilibs();
4070
4071     // Add toolchain / multilib specific file paths.
4072     addMultilibsFilePaths(D, Multilibs, Multilib,
4073                           GCCInstallation.getInstallPath(), Paths);
4074
4075     // Sourcery CodeBench MIPS toolchain holds some libraries under
4076     // a biarch-like suffix of the GCC installation.
4077     addPathIfExists(D, GCCInstallation.getInstallPath() + Multilib.gccSuffix(),
4078                     Paths);
4079
4080     // GCC cross compiling toolchains will install target libraries which ship
4081     // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
4082     // any part of the GCC installation in
4083     // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
4084     // debatable, but is the reality today. We need to search this tree even
4085     // when we have a sysroot somewhere else. It is the responsibility of
4086     // whomever is doing the cross build targeting a sysroot using a GCC
4087     // installation that is *not* within the system root to ensure two things:
4088     //
4089     //  1) Any DSOs that are linked in from this tree or from the install path
4090     //     above must be present on the system root and found via an
4091     //     appropriate rpath.
4092     //  2) There must not be libraries installed into
4093     //     <prefix>/<triple>/<libdir> unless they should be preferred over
4094     //     those within the system root.
4095     //
4096     // Note that this matches the GCC behavior. See the below comment for where
4097     // Clang diverges from GCC's behavior.
4098     addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib/../" +
4099                            OSLibDir + Multilib.osSuffix(),
4100                     Paths);
4101
4102     // If the GCC installation we found is inside of the sysroot, we want to
4103     // prefer libraries installed in the parent prefix of the GCC installation.
4104     // It is important to *not* use these paths when the GCC installation is
4105     // outside of the system root as that can pick up unintended libraries.
4106     // This usually happens when there is an external cross compiler on the
4107     // host system, and a more minimal sysroot available that is the target of
4108     // the cross. Note that GCC does include some of these directories in some
4109     // configurations but this seems somewhere between questionable and simply
4110     // a bug.
4111     if (StringRef(LibPath).startswith(SysRoot)) {
4112       addPathIfExists(D, LibPath + "/" + MultiarchTriple, Paths);
4113       addPathIfExists(D, LibPath + "/../" + OSLibDir, Paths);
4114     }
4115   }
4116
4117   // Similar to the logic for GCC above, if we currently running Clang inside
4118   // of the requested system root, add its parent library paths to
4119   // those searched.
4120   // FIXME: It's not clear whether we should use the driver's installed
4121   // directory ('Dir' below) or the ResourceDir.
4122   if (StringRef(D.Dir).startswith(SysRoot)) {
4123     addPathIfExists(D, D.Dir + "/../lib/" + MultiarchTriple, Paths);
4124     addPathIfExists(D, D.Dir + "/../" + OSLibDir, Paths);
4125   }
4126
4127   addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths);
4128   addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths);
4129   addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
4130   addPathIfExists(D, SysRoot + "/usr/lib/../" + OSLibDir, Paths);
4131
4132   // Try walking via the GCC triple path in case of biarch or multiarch GCC
4133   // installations with strange symlinks.
4134   if (GCCInstallation.isValid()) {
4135     addPathIfExists(D,
4136                     SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
4137                         "/../../" + OSLibDir,
4138                     Paths);
4139
4140     // Add the 'other' biarch variant path
4141     Multilib BiarchSibling;
4142     if (GCCInstallation.getBiarchSibling(BiarchSibling)) {
4143       addPathIfExists(D, GCCInstallation.getInstallPath() +
4144                              BiarchSibling.gccSuffix(),
4145                       Paths);
4146     }
4147
4148     // See comments above on the multilib variant for details of why this is
4149     // included even from outside the sysroot.
4150     const std::string &LibPath = GCCInstallation.getParentLibPath();
4151     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
4152     const Multilib &Multilib = GCCInstallation.getMultilib();
4153     addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib" +
4154                            Multilib.osSuffix(),
4155                     Paths);
4156
4157     // See comments above on the multilib variant for details of why this is
4158     // only included from within the sysroot.
4159     if (StringRef(LibPath).startswith(SysRoot))
4160       addPathIfExists(D, LibPath, Paths);
4161   }
4162
4163   // Similar to the logic for GCC above, if we are currently running Clang
4164   // inside of the requested system root, add its parent library path to those
4165   // searched.
4166   // FIXME: It's not clear whether we should use the driver's installed
4167   // directory ('Dir' below) or the ResourceDir.
4168   if (StringRef(D.Dir).startswith(SysRoot))
4169     addPathIfExists(D, D.Dir + "/../lib", Paths);
4170
4171   addPathIfExists(D, SysRoot + "/lib", Paths);
4172   addPathIfExists(D, SysRoot + "/usr/lib", Paths);
4173 }
4174
4175 bool Linux::HasNativeLLVMSupport() const { return true; }
4176
4177 Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }
4178
4179 Tool *Linux::buildAssembler() const {
4180   return new tools::gnutools::Assembler(*this);
4181 }
4182
4183 std::string Linux::computeSysRoot() const {
4184   if (!getDriver().SysRoot.empty())
4185     return getDriver().SysRoot;
4186
4187   if (!GCCInstallation.isValid() || !isMipsArch(getTriple().getArch()))
4188     return std::string();
4189
4190   // Standalone MIPS toolchains use different names for sysroot folder
4191   // and put it into different places. Here we try to check some known
4192   // variants.
4193
4194   const StringRef InstallDir = GCCInstallation.getInstallPath();
4195   const StringRef TripleStr = GCCInstallation.getTriple().str();
4196   const Multilib &Multilib = GCCInstallation.getMultilib();
4197
4198   std::string Path =
4199       (InstallDir + "/../../../../" + TripleStr + "/libc" + Multilib.osSuffix())
4200           .str();
4201
4202   if (getVFS().exists(Path))
4203     return Path;
4204
4205   Path = (InstallDir + "/../../../../sysroot" + Multilib.osSuffix()).str();
4206
4207   if (getVFS().exists(Path))
4208     return Path;
4209
4210   return std::string();
4211 }
4212
4213 std::string Linux::getDynamicLinker(const ArgList &Args) const {
4214   const llvm::Triple::ArchType Arch = getArch();
4215   const llvm::Triple &Triple = getTriple();
4216
4217   const enum Distro Distro = DetectDistro(getDriver(), Arch);
4218
4219   if (Triple.isAndroid())
4220     return Triple.isArch64Bit() ? "/system/bin/linker64" : "/system/bin/linker";
4221   else if (Triple.isMusl()) {
4222     std::string ArchName;
4223     switch (Arch) {
4224     case llvm::Triple::thumb:
4225       ArchName = "arm";
4226       break;
4227     case llvm::Triple::thumbeb:
4228       ArchName = "armeb";
4229       break;
4230     default:
4231       ArchName = Triple.getArchName().str();
4232     }
4233     if (Triple.getEnvironment() == llvm::Triple::MuslEABIHF)
4234       ArchName += "hf";
4235
4236     return "/lib/ld-musl-" + ArchName + ".so.1";
4237   }
4238
4239   std::string LibDir;
4240   std::string Loader;
4241
4242   switch (Arch) {
4243   default:
4244     llvm_unreachable("unsupported architecture");
4245
4246   case llvm::Triple::aarch64:
4247     LibDir = "lib";
4248     Loader = "ld-linux-aarch64.so.1";
4249     break;
4250   case llvm::Triple::aarch64_be:
4251     LibDir = "lib";
4252     Loader = "ld-linux-aarch64_be.so.1";
4253     break;
4254   case llvm::Triple::arm:
4255   case llvm::Triple::thumb:
4256   case llvm::Triple::armeb:
4257   case llvm::Triple::thumbeb: {
4258     const bool HF =
4259         Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
4260         tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard;
4261
4262     LibDir = "lib";
4263     Loader = HF ? "ld-linux-armhf.so.3" : "ld-linux.so.3";
4264     break;
4265   }
4266   case llvm::Triple::mips:
4267   case llvm::Triple::mipsel:
4268   case llvm::Triple::mips64:
4269   case llvm::Triple::mips64el: {
4270     bool LE = (Triple.getArch() == llvm::Triple::mipsel) ||
4271               (Triple.getArch() == llvm::Triple::mips64el);
4272     bool IsNaN2008 = tools::mips::isNaN2008(Args, Triple);
4273
4274     LibDir = "lib" + tools::mips::getMipsABILibSuffix(Args, Triple);
4275
4276     if (tools::mips::isUCLibc(Args))
4277       Loader = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
4278     else if (!Triple.hasEnvironment() &&
4279              Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies)
4280       Loader = LE ? "ld-musl-mipsel.so.1" : "ld-musl-mips.so.1";
4281     else
4282       Loader = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
4283
4284     break;
4285   }
4286   case llvm::Triple::ppc:
4287     LibDir = "lib";
4288     Loader = "ld.so.1";
4289     break;
4290   case llvm::Triple::ppc64:
4291     LibDir = "lib64";
4292     Loader =
4293         (tools::ppc::hasPPCAbiArg(Args, "elfv2")) ? "ld64.so.2" : "ld64.so.1";
4294     break;
4295   case llvm::Triple::ppc64le:
4296     LibDir = "lib64";
4297     Loader =
4298         (tools::ppc::hasPPCAbiArg(Args, "elfv1")) ? "ld64.so.1" : "ld64.so.2";
4299     break;
4300   case llvm::Triple::sparc:
4301   case llvm::Triple::sparcel:
4302     LibDir = "lib";
4303     Loader = "ld-linux.so.2";
4304     break;
4305   case llvm::Triple::sparcv9:
4306     LibDir = "lib64";
4307     Loader = "ld-linux.so.2";
4308     break;
4309   case llvm::Triple::systemz:
4310     LibDir = "lib";
4311     Loader = "ld64.so.1";
4312     break;
4313   case llvm::Triple::x86:
4314     LibDir = "lib";
4315     Loader = "ld-linux.so.2";
4316     break;
4317   case llvm::Triple::x86_64: {
4318     bool X32 = Triple.getEnvironment() == llvm::Triple::GNUX32;
4319
4320     LibDir = X32 ? "libx32" : "lib64";
4321     Loader = X32 ? "ld-linux-x32.so.2" : "ld-linux-x86-64.so.2";
4322     break;
4323   }
4324   }
4325
4326   if (Distro == Exherbo && (Triple.getVendor() == llvm::Triple::UnknownVendor ||
4327                             Triple.getVendor() == llvm::Triple::PC))
4328     return "/usr/" + Triple.str() + "/lib/" + Loader;
4329   return "/" + LibDir + "/" + Loader;
4330 }
4331
4332 void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
4333                                       ArgStringList &CC1Args) const {
4334   const Driver &D = getDriver();
4335   std::string SysRoot = computeSysRoot();
4336
4337   if (DriverArgs.hasArg(options::OPT_nostdinc))
4338     return;
4339
4340   if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
4341     addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
4342
4343   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
4344     SmallString<128> P(D.ResourceDir);
4345     llvm::sys::path::append(P, "include");
4346     addSystemInclude(DriverArgs, CC1Args, P);
4347   }
4348
4349   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
4350     return;
4351
4352   // Check for configure-time C include directories.
4353   StringRef CIncludeDirs(C_INCLUDE_DIRS);
4354   if (CIncludeDirs != "") {
4355     SmallVector<StringRef, 5> dirs;
4356     CIncludeDirs.split(dirs, ":");
4357     for (StringRef dir : dirs) {
4358       StringRef Prefix =
4359           llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) : "";
4360       addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
4361     }
4362     return;
4363   }
4364
4365   // Lacking those, try to detect the correct set of system includes for the
4366   // target triple.
4367
4368   // Add include directories specific to the selected multilib set and multilib.
4369   if (GCCInstallation.isValid()) {
4370     const auto &Callback = Multilibs.includeDirsCallback();
4371     if (Callback) {
4372       for (const auto &Path : Callback(GCCInstallation.getMultilib()))
4373         addExternCSystemIncludeIfExists(
4374             DriverArgs, CC1Args, GCCInstallation.getInstallPath() + Path);
4375     }
4376   }
4377
4378   // Implement generic Debian multiarch support.
4379   const StringRef X86_64MultiarchIncludeDirs[] = {
4380       "/usr/include/x86_64-linux-gnu",
4381
4382       // FIXME: These are older forms of multiarch. It's not clear that they're
4383       // in use in any released version of Debian, so we should consider
4384       // removing them.
4385       "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"};
4386   const StringRef X86MultiarchIncludeDirs[] = {
4387       "/usr/include/i386-linux-gnu",
4388
4389       // FIXME: These are older forms of multiarch. It's not clear that they're
4390       // in use in any released version of Debian, so we should consider
4391       // removing them.
4392       "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",
4393       "/usr/include/i486-linux-gnu"};
4394   const StringRef AArch64MultiarchIncludeDirs[] = {
4395       "/usr/include/aarch64-linux-gnu"};
4396   const StringRef ARMMultiarchIncludeDirs[] = {
4397       "/usr/include/arm-linux-gnueabi"};
4398   const StringRef ARMHFMultiarchIncludeDirs[] = {
4399       "/usr/include/arm-linux-gnueabihf"};
4400   const StringRef ARMEBMultiarchIncludeDirs[] = {
4401       "/usr/include/armeb-linux-gnueabi"};
4402   const StringRef ARMEBHFMultiarchIncludeDirs[] = {
4403       "/usr/include/armeb-linux-gnueabihf"};
4404   const StringRef MIPSMultiarchIncludeDirs[] = {"/usr/include/mips-linux-gnu"};
4405   const StringRef MIPSELMultiarchIncludeDirs[] = {
4406       "/usr/include/mipsel-linux-gnu"};
4407   const StringRef MIPS64MultiarchIncludeDirs[] = {
4408       "/usr/include/mips64-linux-gnu", "/usr/include/mips64-linux-gnuabi64"};
4409   const StringRef MIPS64ELMultiarchIncludeDirs[] = {
4410       "/usr/include/mips64el-linux-gnu",
4411       "/usr/include/mips64el-linux-gnuabi64"};
4412   const StringRef PPCMultiarchIncludeDirs[] = {
4413       "/usr/include/powerpc-linux-gnu"};
4414   const StringRef PPC64MultiarchIncludeDirs[] = {
4415       "/usr/include/powerpc64-linux-gnu"};
4416   const StringRef PPC64LEMultiarchIncludeDirs[] = {
4417       "/usr/include/powerpc64le-linux-gnu"};
4418   const StringRef SparcMultiarchIncludeDirs[] = {
4419       "/usr/include/sparc-linux-gnu"};
4420   const StringRef Sparc64MultiarchIncludeDirs[] = {
4421       "/usr/include/sparc64-linux-gnu"};
4422   const StringRef SYSTEMZMultiarchIncludeDirs[] = {
4423       "/usr/include/s390x-linux-gnu"};
4424   ArrayRef<StringRef> MultiarchIncludeDirs;
4425   switch (getTriple().getArch()) {
4426   case llvm::Triple::x86_64:
4427     MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
4428     break;
4429   case llvm::Triple::x86:
4430     MultiarchIncludeDirs = X86MultiarchIncludeDirs;
4431     break;
4432   case llvm::Triple::aarch64:
4433   case llvm::Triple::aarch64_be:
4434     MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
4435     break;
4436   case llvm::Triple::arm:
4437   case llvm::Triple::thumb:
4438     if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
4439       MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
4440     else
4441       MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
4442     break;
4443   case llvm::Triple::armeb:
4444   case llvm::Triple::thumbeb:
4445     if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
4446       MultiarchIncludeDirs = ARMEBHFMultiarchIncludeDirs;
4447     else
4448       MultiarchIncludeDirs = ARMEBMultiarchIncludeDirs;
4449     break;
4450   case llvm::Triple::mips:
4451     MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
4452     break;
4453   case llvm::Triple::mipsel:
4454     MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
4455     break;
4456   case llvm::Triple::mips64:
4457     MultiarchIncludeDirs = MIPS64MultiarchIncludeDirs;
4458     break;
4459   case llvm::Triple::mips64el:
4460     MultiarchIncludeDirs = MIPS64ELMultiarchIncludeDirs;
4461     break;
4462   case llvm::Triple::ppc:
4463     MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
4464     break;
4465   case llvm::Triple::ppc64:
4466     MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
4467     break;
4468   case llvm::Triple::ppc64le:
4469     MultiarchIncludeDirs = PPC64LEMultiarchIncludeDirs;
4470     break;
4471   case llvm::Triple::sparc:
4472     MultiarchIncludeDirs = SparcMultiarchIncludeDirs;
4473     break;
4474   case llvm::Triple::sparcv9:
4475     MultiarchIncludeDirs = Sparc64MultiarchIncludeDirs;
4476     break;
4477   case llvm::Triple::systemz:
4478     MultiarchIncludeDirs = SYSTEMZMultiarchIncludeDirs;
4479     break;
4480   default:
4481     break;
4482   }
4483   for (StringRef Dir : MultiarchIncludeDirs) {
4484     if (D.getVFS().exists(SysRoot + Dir)) {
4485       addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + Dir);
4486       break;
4487     }
4488   }
4489
4490   if (getTriple().getOS() == llvm::Triple::RTEMS)
4491     return;
4492
4493   // Add an include of '/include' directly. This isn't provided by default by
4494   // system GCCs, but is often used with cross-compiling GCCs, and harmless to
4495   // add even when Clang is acting as-if it were a system compiler.
4496   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
4497
4498   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
4499 }
4500
4501 static std::string DetectLibcxxIncludePath(StringRef base) {
4502   std::error_code EC;
4503   int MaxVersion = 0;
4504   std::string MaxVersionString = "";
4505   for (llvm::sys::fs::directory_iterator LI(base, EC), LE; !EC && LI != LE;
4506        LI = LI.increment(EC)) {
4507     StringRef VersionText = llvm::sys::path::filename(LI->path());
4508     int Version;
4509     if (VersionText[0] == 'v' &&
4510         !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
4511       if (Version > MaxVersion) {
4512         MaxVersion = Version;
4513         MaxVersionString = VersionText;
4514       }
4515     }
4516   }
4517   return MaxVersion ? (base + "/" + MaxVersionString).str() : "";
4518 }
4519
4520 void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
4521                                          ArgStringList &CC1Args) const {
4522   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4523       DriverArgs.hasArg(options::OPT_nostdincxx))
4524     return;
4525
4526   // Check if libc++ has been enabled and provide its include paths if so.
4527   if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
4528     const std::string LibCXXIncludePathCandidates[] = {
4529         DetectLibcxxIncludePath(getDriver().Dir + "/../include/c++"),
4530         // If this is a development, non-installed, clang, libcxx will
4531         // not be found at ../include/c++ but it likely to be found at
4532         // one of the following two locations:
4533         DetectLibcxxIncludePath(getDriver().SysRoot + "/usr/local/include/c++"),
4534         DetectLibcxxIncludePath(getDriver().SysRoot + "/usr/include/c++") };
4535     for (const auto &IncludePath : LibCXXIncludePathCandidates) {
4536       if (IncludePath.empty() || !getVFS().exists(IncludePath))
4537         continue;
4538       // Add the first candidate that exists.
4539       addSystemInclude(DriverArgs, CC1Args, IncludePath);
4540       break;
4541     }
4542     return;
4543   }
4544
4545   // We need a detected GCC installation on Linux to provide libstdc++'s
4546   // headers. We handled the libc++ case above.
4547   if (!GCCInstallation.isValid())
4548     return;
4549
4550   // By default, look for the C++ headers in an include directory adjacent to
4551   // the lib directory of the GCC installation. Note that this is expect to be
4552   // equivalent to '/usr/include/c++/X.Y' in almost all cases.
4553   StringRef LibDir = GCCInstallation.getParentLibPath();
4554   StringRef InstallDir = GCCInstallation.getInstallPath();
4555   StringRef TripleStr = GCCInstallation.getTriple().str();
4556   const Multilib &Multilib = GCCInstallation.getMultilib();
4557   const std::string GCCMultiarchTriple = getMultiarchTriple(
4558       getDriver(), GCCInstallation.getTriple(), getDriver().SysRoot);
4559   const std::string TargetMultiarchTriple =
4560       getMultiarchTriple(getDriver(), getTriple(), getDriver().SysRoot);
4561   const GCCVersion &Version = GCCInstallation.getVersion();
4562
4563   // The primary search for libstdc++ supports multiarch variants.
4564   if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
4565                                "/c++/" + Version.Text, TripleStr,
4566                                GCCMultiarchTriple, TargetMultiarchTriple,
4567                                Multilib.includeSuffix(), DriverArgs, CC1Args))
4568     return;
4569
4570   // Otherwise, fall back on a bunch of options which don't use multiarch
4571   // layouts for simplicity.
4572   const std::string LibStdCXXIncludePathCandidates[] = {
4573       // Gentoo is weird and places its headers inside the GCC install,
4574       // so if the first attempt to find the headers fails, try these patterns.
4575       InstallDir.str() + "/include/g++-v" + Version.Text,
4576       InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
4577           Version.MinorStr,
4578       InstallDir.str() + "/include/g++-v" + Version.MajorStr,
4579       // Android standalone toolchain has C++ headers in yet another place.
4580       LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
4581       // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
4582       // without a subdirectory corresponding to the gcc version.
4583       LibDir.str() + "/../include/c++",
4584   };
4585
4586   for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {
4587     if (addLibStdCXXIncludePaths(IncludePath, /*Suffix*/ "", TripleStr,
4588                                  /*GCCMultiarchTriple*/ "",
4589                                  /*TargetMultiarchTriple*/ "",
4590                                  Multilib.includeSuffix(), DriverArgs, CC1Args))
4591       break;
4592   }
4593 }
4594
4595 void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,
4596                                ArgStringList &CC1Args) const {
4597   if (DriverArgs.hasArg(options::OPT_nocudainc))
4598     return;
4599
4600   if (!CudaInstallation.isValid()) {
4601     getDriver().Diag(diag::err_drv_no_cuda_installation);
4602     return;
4603   }
4604
4605   addSystemInclude(DriverArgs, CC1Args, CudaInstallation.getIncludePath());
4606   CC1Args.push_back("-include");
4607   CC1Args.push_back("__clang_cuda_runtime_wrapper.h");
4608 }
4609
4610 void Linux::AddIAMCUIncludeArgs(const ArgList &DriverArgs,
4611                                 ArgStringList &CC1Args) const {
4612   if (GCCInstallation.isValid()) {
4613     CC1Args.push_back("-isystem");
4614     CC1Args.push_back(DriverArgs.MakeArgString(
4615         GCCInstallation.getParentLibPath() + "/../" +
4616         GCCInstallation.getTriple().str() + "/include"));
4617   }
4618 }
4619
4620 bool Linux::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); }
4621
4622 SanitizerMask Linux::getSupportedSanitizers() const {
4623   const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
4624   const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
4625   const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 ||
4626                         getTriple().getArch() == llvm::Triple::mips64el;
4627   const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||
4628                            getTriple().getArch() == llvm::Triple::ppc64le;
4629   const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
4630                          getTriple().getArch() == llvm::Triple::aarch64_be;
4631   SanitizerMask Res = ToolChain::getSupportedSanitizers();
4632   Res |= SanitizerKind::Address;
4633   Res |= SanitizerKind::KernelAddress;
4634   Res |= SanitizerKind::Vptr;
4635   Res |= SanitizerKind::SafeStack;
4636   if (IsX86_64 || IsMIPS64 || IsAArch64)
4637     Res |= SanitizerKind::DataFlow;
4638   if (IsX86_64 || IsMIPS64 || IsAArch64)
4639     Res |= SanitizerKind::Leak;
4640   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64)
4641     Res |= SanitizerKind::Thread;
4642   if (IsX86_64 || IsMIPS64 || IsPowerPC64 || IsAArch64)
4643     Res |= SanitizerKind::Memory;
4644   if (IsX86_64)
4645     Res |= SanitizerKind::Efficiency;
4646   if (IsX86 || IsX86_64) {
4647     Res |= SanitizerKind::Function;
4648   }
4649   return Res;
4650 }
4651
4652 void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
4653                              llvm::opt::ArgStringList &CmdArgs) const {
4654   if (!needsProfileRT(Args)) return;
4655
4656   // Add linker option -u__llvm_runtime_variable to cause runtime
4657   // initialization module to be linked in.
4658   if (!Args.hasArg(options::OPT_coverage))
4659     CmdArgs.push_back(Args.MakeArgString(
4660         Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
4661   ToolChain::addProfileRTLibs(Args, CmdArgs);
4662 }
4663
4664 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
4665
4666 DragonFly::DragonFly(const Driver &D, const llvm::Triple &Triple,
4667                      const ArgList &Args)
4668     : Generic_ELF(D, Triple, Args) {
4669
4670   // Path mangling to find libexec
4671   getProgramPaths().push_back(getDriver().getInstalledDir());
4672   if (getDriver().getInstalledDir() != getDriver().Dir)
4673     getProgramPaths().push_back(getDriver().Dir);
4674
4675   getFilePaths().push_back(getDriver().Dir + "/../lib");
4676   getFilePaths().push_back("/usr/lib");
4677   getFilePaths().push_back("/usr/lib/gcc50");
4678 }
4679
4680 Tool *DragonFly::buildAssembler() const {
4681   return new tools::dragonfly::Assembler(*this);
4682 }
4683
4684 Tool *DragonFly::buildLinker() const {
4685   return new tools::dragonfly::Linker(*this);
4686 }
4687
4688 /// CUDA toolchain.  Our assembler is ptxas, and our "linker" is fatbinary,
4689 /// which isn't properly a linker but nonetheless performs the step of stitching
4690 /// together object files from the assembler into a single blob.
4691
4692 CudaToolChain::CudaToolChain(const Driver &D, const llvm::Triple &Triple,
4693                              const ArgList &Args)
4694     : Linux(D, Triple, Args) {
4695   if (CudaInstallation.isValid())
4696     getProgramPaths().push_back(CudaInstallation.getBinPath());
4697 }
4698
4699 void
4700 CudaToolChain::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
4701                                      llvm::opt::ArgStringList &CC1Args) const {
4702   Linux::addClangTargetOptions(DriverArgs, CC1Args);
4703   CC1Args.push_back("-fcuda-is-device");
4704
4705   if (DriverArgs.hasFlag(options::OPT_fcuda_flush_denormals_to_zero,
4706                          options::OPT_fno_cuda_flush_denormals_to_zero, false))
4707     CC1Args.push_back("-fcuda-flush-denormals-to-zero");
4708
4709   if (DriverArgs.hasFlag(options::OPT_fcuda_approx_transcendentals,
4710                          options::OPT_fno_cuda_approx_transcendentals, false))
4711     CC1Args.push_back("-fcuda-approx-transcendentals");
4712
4713   if (DriverArgs.hasArg(options::OPT_nocudalib))
4714     return;
4715
4716   std::string LibDeviceFile = CudaInstallation.getLibDeviceFile(
4717       DriverArgs.getLastArgValue(options::OPT_march_EQ));
4718   if (!LibDeviceFile.empty()) {
4719     CC1Args.push_back("-mlink-cuda-bitcode");
4720     CC1Args.push_back(DriverArgs.MakeArgString(LibDeviceFile));
4721
4722     // Libdevice in CUDA-7.0 requires PTX version that's more recent
4723     // than LLVM defaults to. Use PTX4.2 which is the PTX version that
4724     // came with CUDA-7.0.
4725     CC1Args.push_back("-target-feature");
4726     CC1Args.push_back("+ptx42");
4727   }
4728 }
4729
4730 void CudaToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
4731                                        ArgStringList &CC1Args) const {
4732   // Check our CUDA version if we're going to include the CUDA headers.
4733   if (!DriverArgs.hasArg(options::OPT_nocudainc) &&
4734       !DriverArgs.hasArg(options::OPT_no_cuda_version_check)) {
4735     StringRef Arch = DriverArgs.getLastArgValue(options::OPT_march_EQ);
4736     assert(!Arch.empty() && "Must have an explicit GPU arch.");
4737     CudaInstallation.CheckCudaVersionSupportsArch(StringToCudaArch(Arch));
4738   }
4739   Linux::AddCudaIncludeArgs(DriverArgs, CC1Args);
4740 }
4741
4742 llvm::opt::DerivedArgList *
4743 CudaToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
4744                              const char *BoundArch) const {
4745   DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
4746   const OptTable &Opts = getDriver().getOpts();
4747
4748   for (Arg *A : Args) {
4749     if (A->getOption().matches(options::OPT_Xarch__)) {
4750       // Skip this argument unless the architecture matches BoundArch
4751       if (!BoundArch || A->getValue(0) != StringRef(BoundArch))
4752         continue;
4753
4754       unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
4755       unsigned Prev = Index;
4756       std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
4757
4758       // If the argument parsing failed or more than one argument was
4759       // consumed, the -Xarch_ argument's parameter tried to consume
4760       // extra arguments. Emit an error and ignore.
4761       //
4762       // We also want to disallow any options which would alter the
4763       // driver behavior; that isn't going to work in our model. We
4764       // use isDriverOption() as an approximation, although things
4765       // like -O4 are going to slip through.
4766       if (!XarchArg || Index > Prev + 1) {
4767         getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
4768             << A->getAsString(Args);
4769         continue;
4770       } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
4771         getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
4772             << A->getAsString(Args);
4773         continue;
4774       }
4775       XarchArg->setBaseArg(A);
4776       A = XarchArg.release();
4777       DAL->AddSynthesizedArg(A);
4778     }
4779     DAL->append(A);
4780   }
4781
4782   if (BoundArch) {
4783     DAL->eraseArg(options::OPT_march_EQ);
4784     DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ), BoundArch);
4785   }
4786   return DAL;
4787 }
4788
4789 Tool *CudaToolChain::buildAssembler() const {
4790   return new tools::NVPTX::Assembler(*this);
4791 }
4792
4793 Tool *CudaToolChain::buildLinker() const {
4794   return new tools::NVPTX::Linker(*this);
4795 }
4796
4797 /// XCore tool chain
4798 XCoreToolChain::XCoreToolChain(const Driver &D, const llvm::Triple &Triple,
4799                                const ArgList &Args)
4800     : ToolChain(D, Triple, Args) {
4801   // ProgramPaths are found via 'PATH' environment variable.
4802 }
4803
4804 Tool *XCoreToolChain::buildAssembler() const {
4805   return new tools::XCore::Assembler(*this);
4806 }
4807
4808 Tool *XCoreToolChain::buildLinker() const {
4809   return new tools::XCore::Linker(*this);
4810 }
4811
4812 bool XCoreToolChain::isPICDefault() const { return false; }
4813
4814 bool XCoreToolChain::isPIEDefault() const { return false; }
4815
4816 bool XCoreToolChain::isPICDefaultForced() const { return false; }
4817
4818 bool XCoreToolChain::SupportsProfiling() const { return false; }
4819
4820 bool XCoreToolChain::hasBlocksRuntime() const { return false; }
4821
4822 void XCoreToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
4823                                                ArgStringList &CC1Args) const {
4824   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
4825       DriverArgs.hasArg(options::OPT_nostdlibinc))
4826     return;
4827   if (const char *cl_include_dir = getenv("XCC_C_INCLUDE_PATH")) {
4828     SmallVector<StringRef, 4> Dirs;
4829     const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
4830     StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
4831     ArrayRef<StringRef> DirVec(Dirs);
4832     addSystemIncludes(DriverArgs, CC1Args, DirVec);
4833   }
4834 }
4835
4836 void XCoreToolChain::addClangTargetOptions(const ArgList &DriverArgs,
4837                                            ArgStringList &CC1Args) const {
4838   CC1Args.push_back("-nostdsysteminc");
4839 }
4840
4841 void XCoreToolChain::AddClangCXXStdlibIncludeArgs(
4842     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
4843   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
4844       DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4845       DriverArgs.hasArg(options::OPT_nostdincxx))
4846     return;
4847   if (const char *cl_include_dir = getenv("XCC_CPLUS_INCLUDE_PATH")) {
4848     SmallVector<StringRef, 4> Dirs;
4849     const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
4850     StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
4851     ArrayRef<StringRef> DirVec(Dirs);
4852     addSystemIncludes(DriverArgs, CC1Args, DirVec);
4853   }
4854 }
4855
4856 void XCoreToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
4857                                          ArgStringList &CmdArgs) const {
4858   // We don't output any lib args. This is handled by xcc.
4859 }
4860
4861 MyriadToolChain::MyriadToolChain(const Driver &D, const llvm::Triple &Triple,
4862                                  const ArgList &Args)
4863     : Generic_ELF(D, Triple, Args) {
4864   // If a target of 'sparc-myriad-elf' is specified to clang, it wants to use
4865   // 'sparc-myriad--elf' (note the unknown OS) as the canonical triple.
4866   // This won't work to find gcc. Instead we give the installation detector an
4867   // extra triple, which is preferable to further hacks of the logic that at
4868   // present is based solely on getArch(). In particular, it would be wrong to
4869   // choose the myriad installation when targeting a non-myriad sparc install.
4870   switch (Triple.getArch()) {
4871   default:
4872     D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4873                                               << "myriad";
4874   case llvm::Triple::sparc:
4875   case llvm::Triple::sparcel:
4876   case llvm::Triple::shave:
4877     GCCInstallation.init(Triple, Args, {"sparc-myriad-elf"});
4878   }
4879
4880   if (GCCInstallation.isValid()) {
4881     // The contents of LibDir are independent of the version of gcc.
4882     // This contains libc, libg (a superset of libc), libm, libstdc++, libssp.
4883     SmallString<128> LibDir(GCCInstallation.getParentLibPath());
4884     if (Triple.getArch() == llvm::Triple::sparcel)
4885       llvm::sys::path::append(LibDir, "../sparc-myriad-elf/lib/le");
4886     else
4887       llvm::sys::path::append(LibDir, "../sparc-myriad-elf/lib");
4888     addPathIfExists(D, LibDir, getFilePaths());
4889
4890     // This directory contains crt{i,n,begin,end}.o as well as libgcc.
4891     // These files are tied to a particular version of gcc.
4892     SmallString<128> CompilerSupportDir(GCCInstallation.getInstallPath());
4893     // There are actually 4 choices: {le,be} x {fpu,nofpu}
4894     // but as this toolchain is for LEON sparc, it can assume FPU.
4895     if (Triple.getArch() == llvm::Triple::sparcel)
4896       llvm::sys::path::append(CompilerSupportDir, "le");
4897     addPathIfExists(D, CompilerSupportDir, getFilePaths());
4898   }
4899 }
4900
4901 MyriadToolChain::~MyriadToolChain() {}
4902
4903 void MyriadToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
4904                                                 ArgStringList &CC1Args) const {
4905   if (!DriverArgs.hasArg(options::OPT_nostdinc))
4906     addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot + "/include");
4907 }
4908
4909 void MyriadToolChain::AddClangCXXStdlibIncludeArgs(
4910     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
4911   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4912       DriverArgs.hasArg(options::OPT_nostdincxx))
4913     return;
4914
4915   // Only libstdc++, for now.
4916   StringRef LibDir = GCCInstallation.getParentLibPath();
4917   const GCCVersion &Version = GCCInstallation.getVersion();
4918   StringRef TripleStr = GCCInstallation.getTriple().str();
4919   const Multilib &Multilib = GCCInstallation.getMultilib();
4920
4921   addLibStdCXXIncludePaths(
4922       LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
4923       "", TripleStr, "", "", Multilib.includeSuffix(), DriverArgs, CC1Args);
4924 }
4925
4926 // MyriadToolChain handles several triples:
4927 //  {shave,sparc{,el}}-myriad-{rtems,unknown}-elf
4928 Tool *MyriadToolChain::SelectTool(const JobAction &JA) const {
4929   // The inherited method works fine if not targeting the SHAVE.
4930   if (!isShaveCompilation(getTriple()))
4931     return ToolChain::SelectTool(JA);
4932   switch (JA.getKind()) {
4933   case Action::PreprocessJobClass:
4934   case Action::CompileJobClass:
4935     if (!Compiler)
4936       Compiler.reset(new tools::SHAVE::Compiler(*this));
4937     return Compiler.get();
4938   case Action::AssembleJobClass:
4939     if (!Assembler)
4940       Assembler.reset(new tools::SHAVE::Assembler(*this));
4941     return Assembler.get();
4942   default:
4943     return ToolChain::getTool(JA.getKind());
4944   }
4945 }
4946
4947 Tool *MyriadToolChain::buildLinker() const {
4948   return new tools::Myriad::Linker(*this);
4949 }
4950
4951 WebAssembly::WebAssembly(const Driver &D, const llvm::Triple &Triple,
4952                          const llvm::opt::ArgList &Args)
4953   : ToolChain(D, Triple, Args) {
4954
4955   assert(Triple.isArch32Bit() != Triple.isArch64Bit());
4956   getFilePaths().push_back(
4957       getDriver().SysRoot + "/lib" + (Triple.isArch32Bit() ? "32" : "64"));
4958
4959   // Use LLD by default.
4960   DefaultLinker = "lld";
4961 }
4962
4963 bool WebAssembly::IsMathErrnoDefault() const { return false; }
4964
4965 bool WebAssembly::IsObjCNonFragileABIDefault() const { return true; }
4966
4967 bool WebAssembly::UseObjCMixedDispatch() const { return true; }
4968
4969 bool WebAssembly::isPICDefault() const { return false; }
4970
4971 bool WebAssembly::isPIEDefault() const { return false; }
4972
4973 bool WebAssembly::isPICDefaultForced() const { return false; }
4974
4975 bool WebAssembly::IsIntegratedAssemblerDefault() const { return true; }
4976
4977 // TODO: Support Objective C stuff.
4978 bool WebAssembly::SupportsObjCGC() const { return false; }
4979
4980 bool WebAssembly::hasBlocksRuntime() const { return false; }
4981
4982 // TODO: Support profiling.
4983 bool WebAssembly::SupportsProfiling() const { return false; }
4984
4985 bool WebAssembly::HasNativeLLVMSupport() const { return true; }
4986
4987 void WebAssembly::addClangTargetOptions(const ArgList &DriverArgs,
4988                                         ArgStringList &CC1Args) const {
4989   if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
4990                          options::OPT_fno_use_init_array, true))
4991     CC1Args.push_back("-fuse-init-array");
4992 }
4993
4994 ToolChain::RuntimeLibType WebAssembly::GetDefaultRuntimeLibType() const {
4995   return ToolChain::RLT_CompilerRT;
4996 }
4997
4998 ToolChain::CXXStdlibType WebAssembly::GetCXXStdlibType(const ArgList &Args) const {
4999   return ToolChain::CST_Libcxx;
5000 }
5001
5002 void WebAssembly::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
5003                                             ArgStringList &CC1Args) const {
5004   if (!DriverArgs.hasArg(options::OPT_nostdinc))
5005     addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot + "/include");
5006 }
5007
5008 void WebAssembly::AddClangCXXStdlibIncludeArgs(
5009       const llvm::opt::ArgList &DriverArgs,
5010       llvm::opt::ArgStringList &CC1Args) const {
5011   if (!DriverArgs.hasArg(options::OPT_nostdlibinc) &&
5012       !DriverArgs.hasArg(options::OPT_nostdincxx))
5013     addSystemInclude(DriverArgs, CC1Args,
5014                      getDriver().SysRoot + "/include/c++/v1");
5015 }
5016
5017 Tool *WebAssembly::buildLinker() const {
5018   return new tools::wasm::Linker(*this);
5019 }
5020
5021 PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
5022     : Generic_ELF(D, Triple, Args) {
5023   if (Args.hasArg(options::OPT_static))
5024     D.Diag(diag::err_drv_unsupported_opt_for_target) << "-static" << "PS4";
5025
5026   // Determine where to find the PS4 libraries. We use SCE_ORBIS_SDK_DIR
5027   // if it exists; otherwise use the driver's installation path, which
5028   // should be <SDK_DIR>/host_tools/bin.
5029
5030   SmallString<512> PS4SDKDir;
5031   if (const char *EnvValue = getenv("SCE_ORBIS_SDK_DIR")) {
5032     if (!llvm::sys::fs::exists(EnvValue))
5033       getDriver().Diag(clang::diag::warn_drv_ps4_sdk_dir) << EnvValue;
5034     PS4SDKDir = EnvValue;
5035   } else {
5036     PS4SDKDir = getDriver().Dir;
5037     llvm::sys::path::append(PS4SDKDir, "/../../");
5038   }
5039
5040   // By default, the driver won't report a warning if it can't find
5041   // PS4's include or lib directories. This behavior could be changed if
5042   // -Weverything or -Winvalid-or-nonexistent-directory options are passed.
5043   // If -isysroot was passed, use that as the SDK base path.
5044   std::string PrefixDir;
5045   if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5046     PrefixDir = A->getValue();
5047     if (!llvm::sys::fs::exists(PrefixDir))
5048       getDriver().Diag(clang::diag::warn_missing_sysroot) << PrefixDir;
5049   } else
5050     PrefixDir = PS4SDKDir.str();
5051
5052   SmallString<512> PS4SDKIncludeDir(PrefixDir);
5053   llvm::sys::path::append(PS4SDKIncludeDir, "target/include");
5054   if (!Args.hasArg(options::OPT_nostdinc) &&
5055       !Args.hasArg(options::OPT_nostdlibinc) &&
5056       !Args.hasArg(options::OPT_isysroot) &&
5057       !Args.hasArg(options::OPT__sysroot_EQ) &&
5058       !llvm::sys::fs::exists(PS4SDKIncludeDir)) {
5059     getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
5060         << "PS4 system headers" << PS4SDKIncludeDir;
5061   }
5062
5063   SmallString<512> PS4SDKLibDir(PS4SDKDir);
5064   llvm::sys::path::append(PS4SDKLibDir, "target/lib");
5065   if (!Args.hasArg(options::OPT_nostdlib) &&
5066       !Args.hasArg(options::OPT_nodefaultlibs) &&
5067       !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
5068       !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
5069       !Args.hasArg(options::OPT_emit_ast) &&
5070       !llvm::sys::fs::exists(PS4SDKLibDir)) {
5071     getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
5072         << "PS4 system libraries" << PS4SDKLibDir;
5073     return;
5074   }
5075   getFilePaths().push_back(PS4SDKLibDir.str());
5076 }
5077
5078 Tool *PS4CPU::buildAssembler() const {
5079   return new tools::PS4cpu::Assemble(*this);
5080 }
5081
5082 Tool *PS4CPU::buildLinker() const { return new tools::PS4cpu::Link(*this); }
5083
5084 bool PS4CPU::isPICDefault() const { return true; }
5085
5086 bool PS4CPU::HasNativeLLVMSupport() const { return true; }
5087
5088 SanitizerMask PS4CPU::getSupportedSanitizers() const {
5089   SanitizerMask Res = ToolChain::getSupportedSanitizers();
5090   Res |= SanitizerKind::Address;
5091   Res |= SanitizerKind::Vptr;
5092   return Res;
5093 }