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

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