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