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 Initialize 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 void
1004 Generic_GCC::GCCInstallationDetector::init(
1005     const Driver &D, const llvm::Triple &TargetTriple, const ArgList &Args) {
1006   llvm::Triple MultiarchTriple
1007     = TargetTriple.isArch32Bit() ? TargetTriple.get64BitArchVariant()
1008                                  : TargetTriple.get32BitArchVariant();
1009   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1010   // The library directories which may contain GCC installations.
1011   SmallVector<StringRef, 4> CandidateLibDirs, CandidateMultiarchLibDirs;
1012   // The compatible GCC triples for this particular architecture.
1013   SmallVector<StringRef, 10> CandidateTripleAliases;
1014   SmallVector<StringRef, 10> CandidateMultiarchTripleAliases;
1015   CollectLibDirsAndTriples(TargetTriple, MultiarchTriple, CandidateLibDirs,
1016                            CandidateTripleAliases,
1017                            CandidateMultiarchLibDirs,
1018                            CandidateMultiarchTripleAliases);
1019
1020   // Compute the set of prefixes for our search.
1021   SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1022                                        D.PrefixDirs.end());
1023
1024   StringRef GCCToolchainDir = getGCCToolchainDir(Args);
1025   if (GCCToolchainDir != "") {
1026     if (GCCToolchainDir.back() == '/')
1027       GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1028
1029     Prefixes.push_back(GCCToolchainDir);
1030   } else {
1031     Prefixes.push_back(D.SysRoot);
1032     Prefixes.push_back(D.SysRoot + "/usr");
1033     Prefixes.push_back(D.InstalledDir + "/..");
1034   }
1035
1036   // Loop over the various components which exist and select the best GCC
1037   // installation available. GCC installs are ranked by version number.
1038   Version = GCCVersion::Parse("0.0.0");
1039   for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) {
1040     if (!llvm::sys::fs::exists(Prefixes[i]))
1041       continue;
1042     for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) {
1043       const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str();
1044       if (!llvm::sys::fs::exists(LibDir))
1045         continue;
1046       for (unsigned k = 0, ke = CandidateTripleAliases.size(); k < ke; ++k)
1047         ScanLibDirForGCCTriple(TargetArch, Args, LibDir,
1048                                CandidateTripleAliases[k]);
1049     }
1050     for (unsigned j = 0, je = CandidateMultiarchLibDirs.size(); j < je; ++j) {
1051       const std::string LibDir
1052         = Prefixes[i] + CandidateMultiarchLibDirs[j].str();
1053       if (!llvm::sys::fs::exists(LibDir))
1054         continue;
1055       for (unsigned k = 0, ke = CandidateMultiarchTripleAliases.size(); k < ke;
1056            ++k)
1057         ScanLibDirForGCCTriple(TargetArch, Args, LibDir,
1058                                CandidateMultiarchTripleAliases[k],
1059                                /*NeedsMultiarchSuffix=*/true);
1060     }
1061   }
1062 }
1063
1064 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1065     const llvm::Triple &TargetTriple,
1066     const llvm::Triple &MultiarchTriple,
1067     SmallVectorImpl<StringRef> &LibDirs,
1068     SmallVectorImpl<StringRef> &TripleAliases,
1069     SmallVectorImpl<StringRef> &MultiarchLibDirs,
1070     SmallVectorImpl<StringRef> &MultiarchTripleAliases) {
1071   // Declare a bunch of static data sets that we'll select between below. These
1072   // are specifically designed to always refer to string literals to avoid any
1073   // lifetime or initialization issues.
1074   static const char *const AArch64LibDirs[] = { "/lib" };
1075   static const char *const AArch64Triples[] = {
1076     "aarch64-none-linux-gnu",
1077     "aarch64-linux-gnu"
1078   };
1079
1080   static const char *const ARMLibDirs[] = { "/lib" };
1081   static const char *const ARMTriples[] = {
1082     "arm-linux-gnueabi",
1083     "arm-linux-androideabi"
1084   };
1085   static const char *const ARMHFTriples[] = {
1086     "arm-linux-gnueabihf",
1087     "armv7hl-redhat-linux-gnueabi"
1088   };
1089
1090   static const char *const X86_64LibDirs[] = { "/lib64", "/lib" };
1091   static const char *const X86_64Triples[] = {
1092     "x86_64-linux-gnu",
1093     "x86_64-unknown-linux-gnu",
1094     "x86_64-pc-linux-gnu",
1095     "x86_64-redhat-linux6E",
1096     "x86_64-redhat-linux",
1097     "x86_64-suse-linux",
1098     "x86_64-manbo-linux-gnu",
1099     "x86_64-linux-gnu",
1100     "x86_64-slackware-linux"
1101   };
1102   static const char *const X86LibDirs[] = { "/lib32", "/lib" };
1103   static const char *const X86Triples[] = {
1104     "i686-linux-gnu",
1105     "i686-pc-linux-gnu",
1106     "i486-linux-gnu",
1107     "i386-linux-gnu",
1108     "i386-redhat-linux6E",
1109     "i686-redhat-linux",
1110     "i586-redhat-linux",
1111     "i386-redhat-linux",
1112     "i586-suse-linux",
1113     "i486-slackware-linux",
1114     "i686-montavista-linux"
1115   };
1116
1117   static const char *const MIPSLibDirs[] = { "/lib" };
1118   static const char *const MIPSTriples[] = { "mips-linux-gnu" };
1119   static const char *const MIPSELLibDirs[] = { "/lib" };
1120   static const char *const MIPSELTriples[] = {
1121     "mipsel-linux-gnu",
1122     "mipsel-linux-android",
1123     "mips-linux-gnu"
1124   };
1125
1126   static const char *const MIPS64LibDirs[] = { "/lib64", "/lib" };
1127   static const char *const MIPS64Triples[] = { "mips64-linux-gnu" };
1128   static const char *const MIPS64ELLibDirs[] = { "/lib64", "/lib" };
1129   static const char *const MIPS64ELTriples[] = { "mips64el-linux-gnu" };
1130
1131   static const char *const PPCLibDirs[] = { "/lib32", "/lib" };
1132   static const char *const PPCTriples[] = {
1133     "powerpc-linux-gnu",
1134     "powerpc-unknown-linux-gnu",
1135     "powerpc-linux-gnuspe",
1136     "powerpc-suse-linux",
1137     "powerpc-montavista-linuxspe"
1138   };
1139   static const char *const PPC64LibDirs[] = { "/lib64", "/lib" };
1140   static const char *const PPC64Triples[] = {
1141     "powerpc64-linux-gnu",
1142     "powerpc64-unknown-linux-gnu",
1143     "powerpc64-suse-linux",
1144     "ppc64-redhat-linux"
1145   };
1146
1147   static const char *const SystemZLibDirs[] = { "/lib64", "/lib" };
1148   static const char *const SystemZTriples[] = {
1149     "s390x-linux-gnu",
1150     "s390x-unknown-linux-gnu",
1151     "s390x-ibm-linux-gnu",
1152     "s390x-suse-linux",
1153     "s390x-redhat-linux"
1154   };
1155
1156   switch (TargetTriple.getArch()) {
1157   case llvm::Triple::aarch64:
1158     LibDirs.append(AArch64LibDirs, AArch64LibDirs
1159                    + llvm::array_lengthof(AArch64LibDirs));
1160     TripleAliases.append(
1161       AArch64Triples, AArch64Triples + llvm::array_lengthof(AArch64Triples));
1162     MultiarchLibDirs.append(
1163       AArch64LibDirs, AArch64LibDirs + llvm::array_lengthof(AArch64LibDirs));
1164     MultiarchTripleAliases.append(
1165       AArch64Triples, AArch64Triples + llvm::array_lengthof(AArch64Triples));
1166     break;
1167   case llvm::Triple::arm:
1168   case llvm::Triple::thumb:
1169     LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs));
1170     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1171       TripleAliases.append(
1172         ARMHFTriples, ARMHFTriples + llvm::array_lengthof(ARMHFTriples));
1173     } else {
1174       TripleAliases.append(
1175         ARMTriples, ARMTriples + llvm::array_lengthof(ARMTriples));
1176     }
1177     break;
1178   case llvm::Triple::x86_64:
1179     LibDirs.append(
1180       X86_64LibDirs, X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1181     TripleAliases.append(
1182       X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples));
1183     MultiarchLibDirs.append(
1184       X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1185     MultiarchTripleAliases.append(
1186       X86Triples, X86Triples + llvm::array_lengthof(X86Triples));
1187     break;
1188   case llvm::Triple::x86:
1189     LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1190     TripleAliases.append(
1191       X86Triples, X86Triples + llvm::array_lengthof(X86Triples));
1192     MultiarchLibDirs.append(
1193       X86_64LibDirs, X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1194     MultiarchTripleAliases.append(
1195       X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples));
1196     break;
1197   case llvm::Triple::mips:
1198     LibDirs.append(
1199       MIPSLibDirs, MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1200     TripleAliases.append(
1201       MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples));
1202     MultiarchLibDirs.append(
1203       MIPS64LibDirs, MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1204     MultiarchTripleAliases.append(
1205       MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1206     break;
1207   case llvm::Triple::mipsel:
1208     LibDirs.append(
1209       MIPSELLibDirs, MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1210     TripleAliases.append(
1211       MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1212     MultiarchLibDirs.append(
1213       MIPS64ELLibDirs, MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1214     MultiarchTripleAliases.append(
1215       MIPS64ELTriples, MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1216     break;
1217   case llvm::Triple::mips64:
1218     LibDirs.append(
1219       MIPS64LibDirs, MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1220     TripleAliases.append(
1221       MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1222     MultiarchLibDirs.append(
1223       MIPSLibDirs, MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1224     MultiarchTripleAliases.append(
1225       MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples));
1226     break;
1227   case llvm::Triple::mips64el:
1228     LibDirs.append(
1229       MIPS64ELLibDirs, MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1230     TripleAliases.append(
1231       MIPS64ELTriples, MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1232     MultiarchLibDirs.append(
1233       MIPSELLibDirs, MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1234     MultiarchTripleAliases.append(
1235       MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1236     break;
1237   case llvm::Triple::ppc:
1238     LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1239     TripleAliases.append(
1240       PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples));
1241     MultiarchLibDirs.append(
1242       PPC64LibDirs, PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1243     MultiarchTripleAliases.append(
1244       PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples));
1245     break;
1246   case llvm::Triple::ppc64:
1247     LibDirs.append(
1248       PPC64LibDirs, PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1249     TripleAliases.append(
1250       PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples));
1251     MultiarchLibDirs.append(
1252       PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1253     MultiarchTripleAliases.append(
1254       PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples));
1255     break;
1256   case llvm::Triple::systemz:
1257     LibDirs.append(
1258       SystemZLibDirs, SystemZLibDirs + llvm::array_lengthof(SystemZLibDirs));
1259     TripleAliases.append(
1260       SystemZTriples, SystemZTriples + llvm::array_lengthof(SystemZTriples));
1261     break;
1262
1263   default:
1264     // By default, just rely on the standard lib directories and the original
1265     // triple.
1266     break;
1267   }
1268
1269   // Always append the drivers target triple to the end, in case it doesn't
1270   // match any of our aliases.
1271   TripleAliases.push_back(TargetTriple.str());
1272
1273   // Also include the multiarch variant if it's different.
1274   if (TargetTriple.str() != MultiarchTriple.str())
1275     MultiarchTripleAliases.push_back(MultiarchTriple.str());
1276 }
1277
1278 static bool isSoftFloatABI(const ArgList &Args) {
1279   Arg *A = Args.getLastArg(options::OPT_msoft_float,
1280                            options::OPT_mhard_float,
1281                            options::OPT_mfloat_abi_EQ);
1282   if (!A) return false;
1283
1284   return A->getOption().matches(options::OPT_msoft_float) ||
1285          (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
1286           A->getValue() == StringRef("soft"));
1287 }
1288
1289 static bool isMipsArch(llvm::Triple::ArchType Arch) {
1290   return Arch == llvm::Triple::mips ||
1291          Arch == llvm::Triple::mipsel ||
1292          Arch == llvm::Triple::mips64 ||
1293          Arch == llvm::Triple::mips64el;
1294 }
1295
1296 static bool isMips16(const ArgList &Args) {
1297   Arg *A = Args.getLastArg(options::OPT_mips16,
1298                            options::OPT_mno_mips16);
1299   return A && A->getOption().matches(options::OPT_mips16);
1300 }
1301
1302 static bool isMicroMips(const ArgList &Args) {
1303   Arg *A = Args.getLastArg(options::OPT_mmicromips,
1304                            options::OPT_mno_micromips);
1305   return A && A->getOption().matches(options::OPT_mmicromips);
1306 }
1307
1308 // FIXME: There is the same routine in the Tools.cpp.
1309 static bool hasMipsN32ABIArg(const ArgList &Args) {
1310   Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1311   return A && (A->getValue() == StringRef("n32"));
1312 }
1313
1314 static void appendMipsTargetSuffix(std::string &Path,
1315                                    llvm::Triple::ArchType TargetArch,
1316                                    const ArgList &Args) {
1317   if (isMips16(Args))
1318     Path += "/mips16";
1319   else if (isMicroMips(Args))
1320     Path += "/micromips";
1321
1322   if (isSoftFloatABI(Args))
1323     Path += "/soft-float";
1324
1325   if (TargetArch == llvm::Triple::mipsel ||
1326       TargetArch == llvm::Triple::mips64el)
1327     Path += "/el";
1328 }
1329
1330 static StringRef getMipsTargetABISuffix(llvm::Triple::ArchType TargetArch,
1331                                         const ArgList &Args) {
1332   if (TargetArch == llvm::Triple::mips64 ||
1333       TargetArch == llvm::Triple::mips64el)
1334     return hasMipsN32ABIArg(Args) ? "/n32" : "/64";
1335
1336   return "/32";
1337 }
1338
1339 static bool findTargetMultiarchSuffix(std::string &Suffix,
1340                                       StringRef Path,
1341                                       llvm::Triple::ArchType TargetArch,
1342                                       const ArgList &Args) {
1343   if (isMipsArch(TargetArch)) {
1344     StringRef ABISuffix = getMipsTargetABISuffix(TargetArch, Args);
1345
1346     // First build and check a complex path to crtbegin.o
1347     // depends on command line options (-mips16, -msoft-float, ...)
1348     // like mips-linux-gnu/4.7/mips16/soft-float/el/crtbegin.o
1349     appendMipsTargetSuffix(Suffix, TargetArch, Args);
1350
1351     if (TargetArch == llvm::Triple::mips64 ||
1352         TargetArch == llvm::Triple::mips64el)
1353       Suffix += ABISuffix;
1354
1355     if (llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o"))
1356       return true;
1357
1358     // Then fall back and probe a simple case like
1359     // mips-linux-gnu/4.7/32/crtbegin.o
1360     Suffix = ABISuffix;
1361     return llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o");
1362   }
1363
1364   if (TargetArch == llvm::Triple::x86_64 ||
1365       TargetArch == llvm::Triple::ppc64 ||
1366       TargetArch == llvm::Triple::systemz)
1367     Suffix = "/64";
1368   else
1369     Suffix = "/32";
1370
1371   return llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o");
1372 }
1373
1374 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
1375     llvm::Triple::ArchType TargetArch, const ArgList &Args,
1376     const std::string &LibDir,
1377     StringRef CandidateTriple, bool NeedsMultiarchSuffix) {
1378   // There are various different suffixes involving the triple we
1379   // check for. We also record what is necessary to walk from each back
1380   // up to the lib directory.
1381   const std::string LibSuffixes[] = {
1382     "/gcc/" + CandidateTriple.str(),
1383     "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
1384
1385     // The Freescale PPC SDK has the gcc libraries in
1386     // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well.
1387     "/" + CandidateTriple.str(),
1388
1389     // Ubuntu has a strange mis-matched pair of triples that this happens to
1390     // match.
1391     // FIXME: It may be worthwhile to generalize this and look for a second
1392     // triple.
1393     "/i386-linux-gnu/gcc/" + CandidateTriple.str()
1394   };
1395   const std::string InstallSuffixes[] = {
1396     "/../../..",
1397     "/../../../..",
1398     "/../..",
1399     "/../../../.."
1400   };
1401   // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
1402   const unsigned NumLibSuffixes = (llvm::array_lengthof(LibSuffixes) -
1403                                    (TargetArch != llvm::Triple::x86));
1404   for (unsigned i = 0; i < NumLibSuffixes; ++i) {
1405     StringRef LibSuffix = LibSuffixes[i];
1406     llvm::error_code EC;
1407     for (llvm::sys::fs::directory_iterator LI(LibDir + LibSuffix, EC), LE;
1408          !EC && LI != LE; LI = LI.increment(EC)) {
1409       StringRef VersionText = llvm::sys::path::filename(LI->path());
1410       GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1411       static const GCCVersion MinVersion = { "4.1.1", 4, 1, 1, "" };
1412       if (CandidateVersion < MinVersion)
1413         continue;
1414       if (CandidateVersion <= Version)
1415         continue;
1416
1417       // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1418       // in what would normally be GCCInstallPath and put the 64-bit
1419       // libs in a subdirectory named 64. The simple logic we follow is that
1420       // *if* there is a subdirectory of the right name with crtbegin.o in it,
1421       // we use that. If not, and if not a multiarch triple, we look for
1422       // crtbegin.o without the subdirectory.
1423
1424       std::string MultiarchSuffix;
1425       if (findTargetMultiarchSuffix(MultiarchSuffix,
1426                                     LI->path(), TargetArch, Args)) {
1427         GCCMultiarchSuffix = MultiarchSuffix;
1428       } else {
1429         if (NeedsMultiarchSuffix ||
1430             !llvm::sys::fs::exists(LI->path() + "/crtbegin.o"))
1431           continue;
1432         GCCMultiarchSuffix.clear();
1433       }
1434
1435       Version = CandidateVersion;
1436       GCCTriple.setTriple(CandidateTriple);
1437       // FIXME: We hack together the directory name here instead of
1438       // using LI to ensure stable path separators across Windows and
1439       // Linux.
1440       GCCInstallPath = LibDir + LibSuffixes[i] + "/" + VersionText.str();
1441       GCCParentLibPath = GCCInstallPath + InstallSuffixes[i];
1442       IsValid = true;
1443     }
1444   }
1445 }
1446
1447 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple& Triple,
1448                          const ArgList &Args)
1449   : ToolChain(D, Triple, Args), GCCInstallation() {
1450   getProgramPaths().push_back(getDriver().getInstalledDir());
1451   if (getDriver().getInstalledDir() != getDriver().Dir)
1452     getProgramPaths().push_back(getDriver().Dir);
1453 }
1454
1455 Generic_GCC::~Generic_GCC() {
1456 }
1457
1458 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
1459   switch (AC) {
1460   case Action::PreprocessJobClass:
1461     if (!Preprocess)
1462       Preprocess.reset(new tools::gcc::Preprocess(*this));
1463     return Preprocess.get();
1464   case Action::PrecompileJobClass:
1465     if (!Precompile)
1466       Precompile.reset(new tools::gcc::Precompile(*this));
1467     return Precompile.get();
1468   case Action::CompileJobClass:
1469     if (!Compile)
1470       Compile.reset(new tools::gcc::Compile(*this));
1471     return Compile.get();
1472   default:
1473     return ToolChain::getTool(AC);
1474   }
1475 }
1476
1477 Tool *Generic_GCC::buildAssembler() const {
1478   return new tools::gcc::Assemble(*this);
1479 }
1480
1481 Tool *Generic_GCC::buildLinker() const {
1482   return new tools::gcc::Link(*this);
1483 }
1484
1485 bool Generic_GCC::IsUnwindTablesDefault() const {
1486   return getArch() == llvm::Triple::x86_64;
1487 }
1488
1489 bool Generic_GCC::isPICDefault() const {
1490   return false;
1491 }
1492
1493 bool Generic_GCC::isPIEDefault() const {
1494   return false;
1495 }
1496
1497 bool Generic_GCC::isPICDefaultForced() const {
1498   return false;
1499 }
1500
1501 /// Hexagon Toolchain
1502
1503 std::string Hexagon_TC::GetGnuDir(const std::string &InstalledDir) {
1504
1505   // Locate the rest of the toolchain ...
1506   if (strlen(GCC_INSTALL_PREFIX))
1507     return std::string(GCC_INSTALL_PREFIX);
1508
1509   std::string InstallRelDir = InstalledDir + "/../../gnu";
1510   if (llvm::sys::fs::exists(InstallRelDir))
1511     return InstallRelDir;
1512
1513   std::string PrefixRelDir = std::string(LLVM_PREFIX) + "/../gnu";
1514   if (llvm::sys::fs::exists(PrefixRelDir))
1515     return PrefixRelDir;
1516
1517   return InstallRelDir;
1518 }
1519
1520 static void GetHexagonLibraryPaths(
1521   const ArgList &Args,
1522   const std::string Ver,
1523   const std::string MarchString,
1524   const std::string &InstalledDir,
1525   ToolChain::path_list *LibPaths)
1526 {
1527   bool buildingLib = Args.hasArg(options::OPT_shared);
1528
1529   //----------------------------------------------------------------------------
1530   // -L Args
1531   //----------------------------------------------------------------------------
1532   for (arg_iterator
1533          it = Args.filtered_begin(options::OPT_L),
1534          ie = Args.filtered_end();
1535        it != ie;
1536        ++it) {
1537     for (unsigned i = 0, e = (*it)->getNumValues(); i != e; ++i)
1538       LibPaths->push_back((*it)->getValue(i));
1539   }
1540
1541   //----------------------------------------------------------------------------
1542   // Other standard paths
1543   //----------------------------------------------------------------------------
1544   const std::string MarchSuffix = "/" + MarchString;
1545   const std::string G0Suffix = "/G0";
1546   const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
1547   const std::string RootDir = Hexagon_TC::GetGnuDir(InstalledDir) + "/";
1548
1549   // lib/gcc/hexagon/...
1550   std::string LibGCCHexagonDir = RootDir + "lib/gcc/hexagon/";
1551   if (buildingLib) {
1552     LibPaths->push_back(LibGCCHexagonDir + Ver + MarchG0Suffix);
1553     LibPaths->push_back(LibGCCHexagonDir + Ver + G0Suffix);
1554   }
1555   LibPaths->push_back(LibGCCHexagonDir + Ver + MarchSuffix);
1556   LibPaths->push_back(LibGCCHexagonDir + Ver);
1557
1558   // lib/gcc/...
1559   LibPaths->push_back(RootDir + "lib/gcc");
1560
1561   // hexagon/lib/...
1562   std::string HexagonLibDir = RootDir + "hexagon/lib";
1563   if (buildingLib) {
1564     LibPaths->push_back(HexagonLibDir + MarchG0Suffix);
1565     LibPaths->push_back(HexagonLibDir + G0Suffix);
1566   }
1567   LibPaths->push_back(HexagonLibDir + MarchSuffix);
1568   LibPaths->push_back(HexagonLibDir);
1569 }
1570
1571 Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple,
1572                        const ArgList &Args)
1573   : Linux(D, Triple, Args) {
1574   const std::string InstalledDir(getDriver().getInstalledDir());
1575   const std::string GnuDir = Hexagon_TC::GetGnuDir(InstalledDir);
1576
1577   // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
1578   // program paths
1579   const std::string BinDir(GnuDir + "/bin");
1580   if (llvm::sys::fs::exists(BinDir))
1581     getProgramPaths().push_back(BinDir);
1582
1583   // Determine version of GCC libraries and headers to use.
1584   const std::string HexagonDir(GnuDir + "/lib/gcc/hexagon");
1585   llvm::error_code ec;
1586   GCCVersion MaxVersion= GCCVersion::Parse("0.0.0");
1587   for (llvm::sys::fs::directory_iterator di(HexagonDir, ec), de;
1588        !ec && di != de; di = di.increment(ec)) {
1589     GCCVersion cv = GCCVersion::Parse(llvm::sys::path::filename(di->path()));
1590     if (MaxVersion < cv)
1591       MaxVersion = cv;
1592   }
1593   GCCLibAndIncVersion = MaxVersion;
1594
1595   ToolChain::path_list *LibPaths= &getFilePaths();
1596
1597   // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
1598   // 'elf' OS type, so the Linux paths are not appropriate. When we actually
1599   // support 'linux' we'll need to fix this up
1600   LibPaths->clear();
1601
1602   GetHexagonLibraryPaths(
1603     Args,
1604     GetGCCLibAndIncVersion(),
1605     GetTargetCPU(Args),
1606     InstalledDir,
1607     LibPaths);
1608 }
1609
1610 Hexagon_TC::~Hexagon_TC() {
1611 }
1612
1613 Tool *Hexagon_TC::buildAssembler() const {
1614   return new tools::hexagon::Assemble(*this);
1615 }
1616
1617 Tool *Hexagon_TC::buildLinker() const {
1618   return new tools::hexagon::Link(*this);
1619 }
1620
1621 void Hexagon_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
1622                                            ArgStringList &CC1Args) const {
1623   const Driver &D = getDriver();
1624
1625   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
1626       DriverArgs.hasArg(options::OPT_nostdlibinc))
1627     return;
1628
1629   llvm::sys::Path InstallDir(D.InstalledDir);
1630   std::string Ver(GetGCCLibAndIncVersion());
1631   std::string GnuDir = Hexagon_TC::GetGnuDir(D.InstalledDir);
1632   std::string HexagonDir(GnuDir + "/lib/gcc/hexagon/" + Ver);
1633   addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include");
1634   addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include-fixed");
1635   addExternCSystemInclude(DriverArgs, CC1Args, GnuDir + "/hexagon/include");
1636 }
1637
1638 void Hexagon_TC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1639                                               ArgStringList &CC1Args) const {
1640
1641   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1642       DriverArgs.hasArg(options::OPT_nostdincxx))
1643     return;
1644
1645   const Driver &D = getDriver();
1646   std::string Ver(GetGCCLibAndIncVersion());
1647   llvm::sys::Path IncludeDir(Hexagon_TC::GetGnuDir(D.InstalledDir));
1648
1649   IncludeDir.appendComponent("hexagon/include/c++/");
1650   IncludeDir.appendComponent(Ver);
1651   addSystemInclude(DriverArgs, CC1Args, IncludeDir.str());
1652 }
1653
1654 ToolChain::CXXStdlibType
1655 Hexagon_TC::GetCXXStdlibType(const ArgList &Args) const {
1656   Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1657   if (!A)
1658     return ToolChain::CST_Libstdcxx;
1659
1660   StringRef Value = A->getValue();
1661   if (Value != "libstdc++") {
1662     getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1663       << A->getAsString(Args);
1664   }
1665
1666   return ToolChain::CST_Libstdcxx;
1667 }
1668
1669 static Arg *GetLastHexagonArchArg(const ArgList &Args)
1670 {
1671   Arg *A = NULL;
1672
1673   for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
1674        it != ie; ++it) {
1675     if ((*it)->getOption().matches(options::OPT_march_EQ) ||
1676         (*it)->getOption().matches(options::OPT_mcpu_EQ)) {
1677       A = *it;
1678       A->claim();
1679     } else if ((*it)->getOption().matches(options::OPT_m_Joined)) {
1680       StringRef Value = (*it)->getValue(0);
1681       if (Value.startswith("v")) {
1682         A = *it;
1683         A->claim();
1684       }
1685     }
1686   }
1687   return A;
1688 }
1689
1690 StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args)
1691 {
1692   // Select the default CPU (v4) if none was given or detection failed.
1693   Arg *A = GetLastHexagonArchArg (Args);
1694   if (A) {
1695     StringRef WhichHexagon = A->getValue();
1696     if (WhichHexagon.startswith("hexagon"))
1697       return WhichHexagon.substr(sizeof("hexagon") - 1);
1698     if (WhichHexagon != "")
1699       return WhichHexagon;
1700   }
1701
1702   return "v4";
1703 }
1704 // End Hexagon
1705
1706 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1707 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1708 /// Currently does not support anything else but compilation.
1709
1710 TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple,
1711                            const ArgList &Args)
1712   : ToolChain(D, Triple, Args) {
1713   // Path mangling to find libexec
1714   std::string Path(getDriver().Dir);
1715
1716   Path += "/../libexec";
1717   getProgramPaths().push_back(Path);
1718 }
1719
1720 TCEToolChain::~TCEToolChain() {
1721 }
1722
1723 bool TCEToolChain::IsMathErrnoDefault() const {
1724   return true;
1725 }
1726
1727 bool TCEToolChain::isPICDefault() const {
1728   return false;
1729 }
1730
1731 bool TCEToolChain::isPIEDefault() const {
1732   return false;
1733 }
1734
1735 bool TCEToolChain::isPICDefaultForced() const {
1736   return false;
1737 }
1738
1739 /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1740
1741 OpenBSD::OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1742   : Generic_ELF(D, Triple, Args) {
1743   getFilePaths().push_back(getDriver().Dir + "/../lib");
1744   getFilePaths().push_back("/usr/lib");
1745 }
1746
1747 Tool *OpenBSD::buildAssembler() const {
1748   return new tools::openbsd::Assemble(*this);
1749 }
1750
1751 Tool *OpenBSD::buildLinker() const {
1752   return new tools::openbsd::Link(*this);
1753 }
1754
1755 /// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
1756
1757 Bitrig::Bitrig(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1758   : Generic_ELF(D, Triple, Args) {
1759   getFilePaths().push_back(getDriver().Dir + "/../lib");
1760   getFilePaths().push_back("/usr/lib");
1761 }
1762
1763 Tool *Bitrig::buildAssembler() const {
1764   return new tools::bitrig::Assemble(*this);
1765 }
1766
1767 Tool *Bitrig::buildLinker() const {
1768   return new tools::bitrig::Link(*this);
1769 }
1770
1771 void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1772                                           ArgStringList &CC1Args) const {
1773   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1774       DriverArgs.hasArg(options::OPT_nostdincxx))
1775     return;
1776
1777   switch (GetCXXStdlibType(DriverArgs)) {
1778   case ToolChain::CST_Libcxx:
1779     addSystemInclude(DriverArgs, CC1Args,
1780                      getDriver().SysRoot + "/usr/include/c++/");
1781     break;
1782   case ToolChain::CST_Libstdcxx:
1783     addSystemInclude(DriverArgs, CC1Args,
1784                      getDriver().SysRoot + "/usr/include/c++/stdc++");
1785     addSystemInclude(DriverArgs, CC1Args,
1786                      getDriver().SysRoot + "/usr/include/c++/stdc++/backward");
1787
1788     StringRef Triple = getTriple().str();
1789     if (Triple.startswith("amd64"))
1790       addSystemInclude(DriverArgs, CC1Args,
1791                        getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" +
1792                        Triple.substr(5));
1793     else
1794       addSystemInclude(DriverArgs, CC1Args,
1795                        getDriver().SysRoot + "/usr/include/c++/stdc++/" +
1796                        Triple);
1797     break;
1798   }
1799 }
1800
1801 void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
1802                                  ArgStringList &CmdArgs) const {
1803   switch (GetCXXStdlibType(Args)) {
1804   case ToolChain::CST_Libcxx:
1805     CmdArgs.push_back("-lc++");
1806     CmdArgs.push_back("-lcxxrt");
1807     // Include supc++ to provide Unwind until provided by libcxx.
1808     CmdArgs.push_back("-lgcc");
1809     break;
1810   case ToolChain::CST_Libstdcxx:
1811     CmdArgs.push_back("-lstdc++");
1812     break;
1813   }
1814 }
1815
1816 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1817
1818 FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1819   : Generic_ELF(D, Triple, Args) {
1820
1821   // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
1822   // back to '/usr/lib' if it doesn't exist.
1823   if ((Triple.getArch() == llvm::Triple::x86 ||
1824        Triple.getArch() == llvm::Triple::ppc) &&
1825       llvm::sys::fs::exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
1826     getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
1827   else
1828     getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
1829 }
1830
1831 Tool *FreeBSD::buildAssembler() const {
1832   return new tools::freebsd::Assemble(*this);
1833 }
1834
1835 Tool *FreeBSD::buildLinker() const {
1836   return new tools::freebsd::Link(*this);
1837 }
1838
1839 bool FreeBSD::UseSjLjExceptions() const {
1840   // FreeBSD uses SjLj exceptions on ARM oabi.
1841   switch (getTriple().getEnvironment()) {
1842   case llvm::Triple::GNUEABI:
1843   case llvm::Triple::EABI:
1844     return false;
1845
1846   default:
1847     return (getTriple().getArch() == llvm::Triple::arm ||
1848             getTriple().getArch() == llvm::Triple::thumb);
1849   }
1850 }
1851
1852 ToolChain::CXXStdlibType
1853 FreeBSD::GetCXXStdlibType(const ArgList &Args) const {
1854   if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
1855     StringRef Value = A->getValue();
1856     if (Value == "libc++")
1857       return ToolChain::CST_Libcxx;
1858     if (Value == "libstdc++")
1859       return ToolChain::CST_Libstdcxx;
1860     getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1861       << A->getAsString(Args);
1862   }
1863
1864   return getTriple().getOSMajorVersion() >= 10 ? ToolChain::CST_Libcxx :
1865          ToolChain::CST_Libstdcxx;
1866 }
1867
1868 void FreeBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1869                                           ArgStringList &CC1Args) const {
1870   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1871       DriverArgs.hasArg(options::OPT_nostdincxx))
1872     return;
1873
1874   if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx)
1875     addSystemInclude(DriverArgs, CC1Args,
1876                      getDriver().SysRoot + "/usr/include/c++/v1");
1877   else
1878     addSystemInclude(DriverArgs, CC1Args,
1879                      getDriver().SysRoot + "/usr/include/c++/4.2");
1880   return;
1881
1882 }
1883
1884 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
1885
1886 NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1887   : Generic_ELF(D, Triple, Args) {
1888
1889   if (getDriver().UseStdLib) {
1890     // When targeting a 32-bit platform, try the special directory used on
1891     // 64-bit hosts, and only fall back to the main library directory if that
1892     // doesn't work.
1893     // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
1894     // what all logic is needed to emulate the '=' prefix here.
1895     if (Triple.getArch() == llvm::Triple::x86)
1896       getFilePaths().push_back("=/usr/lib/i386");
1897
1898     getFilePaths().push_back("=/usr/lib");
1899   }
1900 }
1901
1902 Tool *NetBSD::buildAssembler() const {
1903   return new tools::netbsd::Assemble(*this);
1904 }
1905
1906 Tool *NetBSD::buildLinker() const {
1907   return new tools::netbsd::Link(*this);
1908 }
1909
1910 ToolChain::CXXStdlibType
1911 NetBSD::GetCXXStdlibType(const ArgList &Args) const {
1912   if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
1913     StringRef Value = A->getValue();
1914     if (Value == "libstdc++")
1915       return ToolChain::CST_Libstdcxx;
1916     if (Value == "libc++")
1917       return ToolChain::CST_Libcxx;
1918
1919     getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1920       << A->getAsString(Args);
1921   }
1922
1923   return ToolChain::CST_Libstdcxx;
1924 }
1925
1926 void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1927                                           ArgStringList &CC1Args) const {
1928   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1929       DriverArgs.hasArg(options::OPT_nostdincxx))
1930     return;
1931
1932   switch (GetCXXStdlibType(DriverArgs)) {
1933   case ToolChain::CST_Libcxx:
1934     addSystemInclude(DriverArgs, CC1Args,
1935                      getDriver().SysRoot + "/usr/include/c++/");
1936     break;
1937   case ToolChain::CST_Libstdcxx:
1938     addSystemInclude(DriverArgs, CC1Args,
1939                      getDriver().SysRoot + "/usr/include/g++");
1940     addSystemInclude(DriverArgs, CC1Args,
1941                      getDriver().SysRoot + "/usr/include/g++/backward");
1942     break;
1943   }
1944 }
1945
1946 /// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1947
1948 Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1949   : Generic_ELF(D, Triple, Args) {
1950   getFilePaths().push_back(getDriver().Dir + "/../lib");
1951   getFilePaths().push_back("/usr/lib");
1952 }
1953
1954 Tool *Minix::buildAssembler() const {
1955   return new tools::minix::Assemble(*this);
1956 }
1957
1958 Tool *Minix::buildLinker() const {
1959   return new tools::minix::Link(*this);
1960 }
1961
1962 /// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1963
1964 AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple,
1965                    const ArgList &Args)
1966   : Generic_GCC(D, Triple, Args) {
1967
1968   getProgramPaths().push_back(getDriver().getInstalledDir());
1969   if (getDriver().getInstalledDir() != getDriver().Dir)
1970     getProgramPaths().push_back(getDriver().Dir);
1971
1972   getFilePaths().push_back(getDriver().Dir + "/../lib");
1973   getFilePaths().push_back("/usr/lib");
1974   getFilePaths().push_back("/usr/sfw/lib");
1975   getFilePaths().push_back("/opt/gcc4/lib");
1976   getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
1977
1978 }
1979
1980 Tool *AuroraUX::buildAssembler() const {
1981   return new tools::auroraux::Assemble(*this);
1982 }
1983
1984 Tool *AuroraUX::buildLinker() const {
1985   return new tools::auroraux::Link(*this);
1986 }
1987
1988 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
1989
1990 Solaris::Solaris(const Driver &D, const llvm::Triple& Triple,
1991                  const ArgList &Args)
1992   : Generic_GCC(D, Triple, Args) {
1993
1994   getProgramPaths().push_back(getDriver().getInstalledDir());
1995   if (getDriver().getInstalledDir() != getDriver().Dir)
1996     getProgramPaths().push_back(getDriver().Dir);
1997
1998   getFilePaths().push_back(getDriver().Dir + "/../lib");
1999   getFilePaths().push_back("/usr/lib");
2000 }
2001
2002 Tool *Solaris::buildAssembler() const {
2003   return new tools::solaris::Assemble(*this);
2004 }
2005
2006 Tool *Solaris::buildLinker() const {
2007   return new tools::solaris::Link(*this);
2008 }
2009
2010 /// Distribution (very bare-bones at the moment).
2011
2012 enum Distro {
2013   ArchLinux,
2014   DebianLenny,
2015   DebianSqueeze,
2016   DebianWheezy,
2017   DebianJessie,
2018   Exherbo,
2019   RHEL4,
2020   RHEL5,
2021   RHEL6,
2022   Fedora13,
2023   Fedora14,
2024   Fedora15,
2025   Fedora16,
2026   FedoraRawhide,
2027   OpenSuse11_3,
2028   OpenSuse11_4,
2029   OpenSuse12_1,
2030   OpenSuse12_2,
2031   UbuntuHardy,
2032   UbuntuIntrepid,
2033   UbuntuJaunty,
2034   UbuntuKarmic,
2035   UbuntuLucid,
2036   UbuntuMaverick,
2037   UbuntuNatty,
2038   UbuntuOneiric,
2039   UbuntuPrecise,
2040   UbuntuQuantal,
2041   UbuntuRaring,
2042   UnknownDistro
2043 };
2044
2045 static bool IsRedhat(enum Distro Distro) {
2046   return (Distro >= Fedora13 && Distro <= FedoraRawhide) ||
2047          (Distro >= RHEL4    && Distro <= RHEL6);
2048 }
2049
2050 static bool IsOpenSuse(enum Distro Distro) {
2051   return Distro >= OpenSuse11_3 && Distro <= OpenSuse12_2;
2052 }
2053
2054 static bool IsDebian(enum Distro Distro) {
2055   return Distro >= DebianLenny && Distro <= DebianJessie;
2056 }
2057
2058 static bool IsUbuntu(enum Distro Distro) {
2059   return Distro >= UbuntuHardy && Distro <= UbuntuRaring;
2060 }
2061
2062 static Distro DetectDistro(llvm::Triple::ArchType Arch) {
2063   OwningPtr<llvm::MemoryBuffer> File;
2064   if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
2065     StringRef Data = File.get()->getBuffer();
2066     SmallVector<StringRef, 8> Lines;
2067     Data.split(Lines, "\n");
2068     Distro Version = UnknownDistro;
2069     for (unsigned i = 0, s = Lines.size(); i != s; ++i)
2070       if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME="))
2071         Version = llvm::StringSwitch<Distro>(Lines[i].substr(17))
2072           .Case("hardy", UbuntuHardy)
2073           .Case("intrepid", UbuntuIntrepid)
2074           .Case("jaunty", UbuntuJaunty)
2075           .Case("karmic", UbuntuKarmic)
2076           .Case("lucid", UbuntuLucid)
2077           .Case("maverick", UbuntuMaverick)
2078           .Case("natty", UbuntuNatty)
2079           .Case("oneiric", UbuntuOneiric)
2080           .Case("precise", UbuntuPrecise)
2081           .Case("quantal", UbuntuQuantal)
2082           .Case("raring", UbuntuRaring)
2083           .Default(UnknownDistro);
2084     return Version;
2085   }
2086
2087   if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
2088     StringRef Data = File.get()->getBuffer();
2089     if (Data.startswith("Fedora release 16"))
2090       return Fedora16;
2091     else if (Data.startswith("Fedora release 15"))
2092       return Fedora15;
2093     else if (Data.startswith("Fedora release 14"))
2094       return Fedora14;
2095     else if (Data.startswith("Fedora release 13"))
2096       return Fedora13;
2097     else if (Data.startswith("Fedora release") &&
2098              Data.find("Rawhide") != StringRef::npos)
2099       return FedoraRawhide;
2100     else if (Data.startswith("Red Hat Enterprise Linux") &&
2101              Data.find("release 6") != StringRef::npos)
2102       return RHEL6;
2103     else if ((Data.startswith("Red Hat Enterprise Linux") ||
2104               Data.startswith("CentOS")) &&
2105              Data.find("release 5") != StringRef::npos)
2106       return RHEL5;
2107     else if ((Data.startswith("Red Hat Enterprise Linux") ||
2108               Data.startswith("CentOS")) &&
2109              Data.find("release 4") != StringRef::npos)
2110       return RHEL4;
2111     return UnknownDistro;
2112   }
2113
2114   if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
2115     StringRef Data = File.get()->getBuffer();
2116     if (Data[0] == '5')
2117       return DebianLenny;
2118     else if (Data.startswith("squeeze/sid") || Data[0] == '6')
2119       return DebianSqueeze;
2120     else if (Data.startswith("wheezy/sid")  || Data[0] == '7')
2121       return DebianWheezy;
2122     else if (Data.startswith("jessie/sid")  || Data[0] == '8')
2123       return DebianJessie;
2124     return UnknownDistro;
2125   }
2126
2127   if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File))
2128     return llvm::StringSwitch<Distro>(File.get()->getBuffer())
2129       .StartsWith("openSUSE 11.3", OpenSuse11_3)
2130       .StartsWith("openSUSE 11.4", OpenSuse11_4)
2131       .StartsWith("openSUSE 12.1", OpenSuse12_1)
2132       .StartsWith("openSUSE 12.2", OpenSuse12_2)
2133       .Default(UnknownDistro);
2134
2135   bool Exists;
2136   if (!llvm::sys::fs::exists("/etc/exherbo-release", Exists) && Exists)
2137     return Exherbo;
2138
2139   if (!llvm::sys::fs::exists("/etc/arch-release", Exists) && Exists)
2140     return ArchLinux;
2141
2142   return UnknownDistro;
2143 }
2144
2145 /// \brief Get our best guess at the multiarch triple for a target.
2146 ///
2147 /// Debian-based systems are starting to use a multiarch setup where they use
2148 /// a target-triple directory in the library and header search paths.
2149 /// Unfortunately, this triple does not align with the vanilla target triple,
2150 /// so we provide a rough mapping here.
2151 static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
2152                                       StringRef SysRoot) {
2153   // For most architectures, just use whatever we have rather than trying to be
2154   // clever.
2155   switch (TargetTriple.getArch()) {
2156   default:
2157     return TargetTriple.str();
2158
2159     // We use the existence of '/lib/<triple>' as a directory to detect some
2160     // common linux triples that don't quite match the Clang triple for both
2161     // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
2162     // regardless of what the actual target triple is.
2163   case llvm::Triple::arm:
2164   case llvm::Triple::thumb:
2165     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2166       if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabihf"))
2167         return "arm-linux-gnueabihf";
2168     } else {
2169       if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabi"))
2170         return "arm-linux-gnueabi";
2171     }
2172     return TargetTriple.str();
2173   case llvm::Triple::x86:
2174     if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
2175       return "i386-linux-gnu";
2176     return TargetTriple.str();
2177   case llvm::Triple::x86_64:
2178     if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
2179       return "x86_64-linux-gnu";
2180     return TargetTriple.str();
2181   case llvm::Triple::aarch64:
2182     if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64-linux-gnu"))
2183       return "aarch64-linux-gnu";
2184   case llvm::Triple::mips:
2185     if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu"))
2186       return "mips-linux-gnu";
2187     return TargetTriple.str();
2188   case llvm::Triple::mipsel:
2189     if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu"))
2190       return "mipsel-linux-gnu";
2191     return TargetTriple.str();
2192   case llvm::Triple::ppc:
2193     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
2194       return "powerpc-linux-gnuspe";
2195     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu"))
2196       return "powerpc-linux-gnu";
2197     return TargetTriple.str();
2198   case llvm::Triple::ppc64:
2199     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu"))
2200       return "powerpc64-linux-gnu";
2201     return TargetTriple.str();
2202   }
2203 }
2204
2205 static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) {
2206   if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str());
2207 }
2208
2209 static bool isMipsR2Arch(llvm::Triple::ArchType Arch,
2210                          const ArgList &Args) {
2211   if (Arch != llvm::Triple::mips &&
2212       Arch != llvm::Triple::mipsel)
2213     return false;
2214
2215   Arg *A = Args.getLastArg(options::OPT_march_EQ,
2216                            options::OPT_mcpu_EQ,
2217                            options::OPT_mips_CPUs_Group);
2218
2219   if (!A)
2220     return false;
2221
2222   if (A->getOption().matches(options::OPT_mips_CPUs_Group))
2223     return A->getOption().matches(options::OPT_mips32r2);
2224
2225   return A->getValue() == StringRef("mips32r2");
2226 }
2227
2228 static StringRef getMultilibDir(const llvm::Triple &Triple,
2229                                 const ArgList &Args) {
2230   if (!isMipsArch(Triple.getArch()))
2231     return Triple.isArch32Bit() ? "lib32" : "lib64";
2232
2233   // lib32 directory has a special meaning on MIPS targets.
2234   // It contains N32 ABI binaries. Use this folder if produce
2235   // code for N32 ABI only.
2236   if (hasMipsN32ABIArg(Args))
2237     return "lib32";
2238
2239   return Triple.isArch32Bit() ? "lib" : "lib64";
2240 }
2241
2242 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2243   : Generic_ELF(D, Triple, Args) {
2244   GCCInstallation.init(D, Triple, Args);
2245   llvm::Triple::ArchType Arch = Triple.getArch();
2246   std::string SysRoot = computeSysRoot(Args);
2247
2248   // OpenSuse stores the linker with the compiler, add that to the search
2249   // path.
2250   ToolChain::path_list &PPaths = getProgramPaths();
2251   PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
2252                          GCCInstallation.getTriple().str() + "/bin").str());
2253
2254   Linker = GetProgramPath("ld");
2255
2256   Distro Distro = DetectDistro(Arch);
2257
2258   if (IsOpenSuse(Distro) || IsUbuntu(Distro)) {
2259     ExtraOpts.push_back("-z");
2260     ExtraOpts.push_back("relro");
2261   }
2262
2263   if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
2264     ExtraOpts.push_back("-X");
2265
2266   const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::Android;
2267   const bool IsMips = isMipsArch(Arch);
2268
2269   if (IsMips && !SysRoot.empty())
2270     ExtraOpts.push_back("--sysroot=" + SysRoot);
2271
2272   // Do not use 'gnu' hash style for Mips targets because .gnu.hash
2273   // and the MIPS ABI require .dynsym to be sorted in different ways.
2274   // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
2275   // ABI requires a mapping between the GOT and the symbol table.
2276   // Android loader does not support .gnu.hash.
2277   if (!IsMips && !IsAndroid) {
2278     if (IsRedhat(Distro) || IsOpenSuse(Distro) ||
2279         (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
2280       ExtraOpts.push_back("--hash-style=gnu");
2281
2282     if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid ||
2283         Distro == UbuntuJaunty || Distro == UbuntuKarmic)
2284       ExtraOpts.push_back("--hash-style=both");
2285   }
2286
2287   if (IsRedhat(Distro))
2288     ExtraOpts.push_back("--no-add-needed");
2289
2290   if (Distro == DebianSqueeze || Distro == DebianWheezy ||
2291       Distro == DebianJessie || IsOpenSuse(Distro) ||
2292       (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
2293       (IsUbuntu(Distro) && Distro >= UbuntuKarmic))
2294     ExtraOpts.push_back("--build-id");
2295
2296   if (IsOpenSuse(Distro))
2297     ExtraOpts.push_back("--enable-new-dtags");
2298
2299   // The selection of paths to try here is designed to match the patterns which
2300   // the GCC driver itself uses, as this is part of the GCC-compatible driver.
2301   // This was determined by running GCC in a fake filesystem, creating all
2302   // possible permutations of these directories, and seeing which ones it added
2303   // to the link paths.
2304   path_list &Paths = getFilePaths();
2305
2306   const std::string Multilib = getMultilibDir(Triple, Args);
2307   const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
2308
2309   // Add the multilib suffixed paths where they are available.
2310   if (GCCInstallation.isValid()) {
2311     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2312     const std::string &LibPath = GCCInstallation.getParentLibPath();
2313
2314     if (IsAndroid && isMipsR2Arch(Triple.getArch(), Args))
2315       addPathIfExists(GCCInstallation.getInstallPath() +
2316                       GCCInstallation.getMultiarchSuffix() +
2317                       "/mips-r2",
2318                       Paths);
2319     else
2320       addPathIfExists((GCCInstallation.getInstallPath() +
2321                        GCCInstallation.getMultiarchSuffix()),
2322                       Paths);
2323
2324     // If the GCC installation we found is inside of the sysroot, we want to
2325     // prefer libraries installed in the parent prefix of the GCC installation.
2326     // It is important to *not* use these paths when the GCC installation is
2327     // outside of the system root as that can pick up unintended libraries.
2328     // This usually happens when there is an external cross compiler on the
2329     // host system, and a more minimal sysroot available that is the target of
2330     // the cross.
2331     if (StringRef(LibPath).startswith(SysRoot)) {
2332       addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + Multilib,
2333                       Paths);
2334       addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
2335       addPathIfExists(LibPath + "/../" + Multilib, Paths);
2336     }
2337     // On Android, libraries in the parent prefix of the GCC installation are
2338     // preferred to the ones under sysroot.
2339     if (IsAndroid) {
2340       addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths);
2341     }
2342     // Sourcery CodeBench MIPS toolchain holds some libraries under
2343     // the parent prefix of the GCC installation.
2344     if (IsMips) {
2345       std::string Suffix;
2346       appendMipsTargetSuffix(Suffix, Arch, Args);
2347       addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" +
2348                       Multilib + Suffix,
2349                       Paths);
2350     }
2351   }
2352   addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
2353   addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
2354   addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
2355   addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
2356
2357   // Try walking via the GCC triple path in case of multiarch GCC
2358   // installations with strange symlinks.
2359   if (GCCInstallation.isValid())
2360     addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
2361                     "/../../" + Multilib, Paths);
2362
2363   // Add the non-multilib suffixed paths (if potentially different).
2364   if (GCCInstallation.isValid()) {
2365     const std::string &LibPath = GCCInstallation.getParentLibPath();
2366     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2367     if (!GCCInstallation.getMultiarchSuffix().empty())
2368       addPathIfExists(GCCInstallation.getInstallPath(), Paths);
2369
2370     if (StringRef(LibPath).startswith(SysRoot)) {
2371       addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths);
2372       addPathIfExists(LibPath, Paths);
2373     }
2374   }
2375   addPathIfExists(SysRoot + "/lib", Paths);
2376   addPathIfExists(SysRoot + "/usr/lib", Paths);
2377
2378   IsPIEDefault = SanitizerArgs(*this, Args).hasZeroBaseShadow();
2379 }
2380
2381 bool Linux::HasNativeLLVMSupport() const {
2382   return true;
2383 }
2384
2385 Tool *Linux::buildLinker() const {
2386   return new tools::gnutools::Link(*this);
2387 }
2388
2389 Tool *Linux::buildAssembler() const {
2390   return new tools::gnutools::Assemble(*this);
2391 }
2392
2393 void Linux::addClangTargetOptions(const ArgList &DriverArgs,
2394                                   ArgStringList &CC1Args) const {
2395   const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2396   bool UseInitArrayDefault
2397     = V >= Generic_GCC::GCCVersion::Parse("4.7.0") ||
2398       getTriple().getArch() == llvm::Triple::aarch64 ||
2399       getTriple().getEnvironment() == llvm::Triple::Android;
2400   if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2401                          options::OPT_fno_use_init_array,
2402                          UseInitArrayDefault))
2403     CC1Args.push_back("-fuse-init-array");
2404 }
2405
2406 std::string Linux::computeSysRoot(const ArgList &Args) const {
2407   if (!getDriver().SysRoot.empty())
2408     return getDriver().SysRoot;
2409
2410   if (!GCCInstallation.isValid() || !isMipsArch(getTriple().getArch()))
2411     return std::string();
2412
2413   std::string Path =
2414     (GCCInstallation.getInstallPath() +
2415      "/../../../../" + GCCInstallation.getTriple().str() + "/libc").str();
2416   appendMipsTargetSuffix(Path, getTriple().getArch(), Args);
2417
2418   return llvm::sys::fs::exists(Path) ? Path : "";
2419 }
2420
2421 void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2422                                       ArgStringList &CC1Args) const {
2423   const Driver &D = getDriver();
2424   std::string SysRoot = computeSysRoot(DriverArgs);
2425
2426   if (DriverArgs.hasArg(options::OPT_nostdinc))
2427     return;
2428
2429   if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
2430     addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
2431
2432   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2433     llvm::sys::Path P(D.ResourceDir);
2434     P.appendComponent("include");
2435     addSystemInclude(DriverArgs, CC1Args, P.str());
2436   }
2437
2438   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2439     return;
2440
2441   // Check for configure-time C include directories.
2442   StringRef CIncludeDirs(C_INCLUDE_DIRS);
2443   if (CIncludeDirs != "") {
2444     SmallVector<StringRef, 5> dirs;
2445     CIncludeDirs.split(dirs, ":");
2446     for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
2447          I != E; ++I) {
2448       StringRef Prefix = llvm::sys::path::is_absolute(*I) ? SysRoot : "";
2449       addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
2450     }
2451     return;
2452   }
2453
2454   // Lacking those, try to detect the correct set of system includes for the
2455   // target triple.
2456
2457   // Sourcery CodeBench and modern FSF Mips toolchains put extern C
2458   // system includes under three additional directories.
2459   if (GCCInstallation.isValid() && isMipsArch(getTriple().getArch())) {
2460     addExternCSystemIncludeIfExists(DriverArgs, CC1Args,
2461                                     GCCInstallation.getInstallPath() +
2462                                     "/include");
2463
2464     addExternCSystemIncludeIfExists(DriverArgs, CC1Args,
2465                                     GCCInstallation.getInstallPath() +
2466                                     "/../../../../" +
2467                                     GCCInstallation.getTriple().str() +
2468                                     "/libc/usr/include");
2469   }
2470
2471   // Implement generic Debian multiarch support.
2472   const StringRef X86_64MultiarchIncludeDirs[] = {
2473     "/usr/include/x86_64-linux-gnu",
2474
2475     // FIXME: These are older forms of multiarch. It's not clear that they're
2476     // in use in any released version of Debian, so we should consider
2477     // removing them.
2478     "/usr/include/i686-linux-gnu/64",
2479     "/usr/include/i486-linux-gnu/64"
2480   };
2481   const StringRef X86MultiarchIncludeDirs[] = {
2482     "/usr/include/i386-linux-gnu",
2483
2484     // FIXME: These are older forms of multiarch. It's not clear that they're
2485     // in use in any released version of Debian, so we should consider
2486     // removing them.
2487     "/usr/include/x86_64-linux-gnu/32",
2488     "/usr/include/i686-linux-gnu",
2489     "/usr/include/i486-linux-gnu"
2490   };
2491   const StringRef AArch64MultiarchIncludeDirs[] = {
2492     "/usr/include/aarch64-linux-gnu"
2493   };
2494   const StringRef ARMMultiarchIncludeDirs[] = {
2495     "/usr/include/arm-linux-gnueabi"
2496   };
2497   const StringRef ARMHFMultiarchIncludeDirs[] = {
2498     "/usr/include/arm-linux-gnueabihf"
2499   };
2500   const StringRef MIPSMultiarchIncludeDirs[] = {
2501     "/usr/include/mips-linux-gnu"
2502   };
2503   const StringRef MIPSELMultiarchIncludeDirs[] = {
2504     "/usr/include/mipsel-linux-gnu"
2505   };
2506   const StringRef PPCMultiarchIncludeDirs[] = {
2507     "/usr/include/powerpc-linux-gnu"
2508   };
2509   const StringRef PPC64MultiarchIncludeDirs[] = {
2510     "/usr/include/powerpc64-linux-gnu"
2511   };
2512   ArrayRef<StringRef> MultiarchIncludeDirs;
2513   if (getTriple().getArch() == llvm::Triple::x86_64) {
2514     MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
2515   } else if (getTriple().getArch() == llvm::Triple::x86) {
2516     MultiarchIncludeDirs = X86MultiarchIncludeDirs;
2517   } else if (getTriple().getArch() == llvm::Triple::aarch64) {
2518     MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
2519   } else if (getTriple().getArch() == llvm::Triple::arm) {
2520     if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
2521       MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
2522     else
2523       MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
2524   } else if (getTriple().getArch() == llvm::Triple::mips) {
2525     MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
2526   } else if (getTriple().getArch() == llvm::Triple::mipsel) {
2527     MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
2528   } else if (getTriple().getArch() == llvm::Triple::ppc) {
2529     MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
2530   } else if (getTriple().getArch() == llvm::Triple::ppc64) {
2531     MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
2532   }
2533   for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(),
2534                                      E = MultiarchIncludeDirs.end();
2535        I != E; ++I) {
2536     if (llvm::sys::fs::exists(SysRoot + *I)) {
2537       addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + *I);
2538       break;
2539     }
2540   }
2541
2542   if (getTriple().getOS() == llvm::Triple::RTEMS)
2543     return;
2544
2545   // Add an include of '/include' directly. This isn't provided by default by
2546   // system GCCs, but is often used with cross-compiling GCCs, and harmless to
2547   // add even when Clang is acting as-if it were a system compiler.
2548   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
2549
2550   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
2551 }
2552
2553 /// \brief Helper to add the three variant paths for a libstdc++ installation.
2554 /*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
2555                                                 const ArgList &DriverArgs,
2556                                                 ArgStringList &CC1Args) {
2557   if (!llvm::sys::fs::exists(Base))
2558     return false;
2559   addSystemInclude(DriverArgs, CC1Args, Base);
2560   addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir);
2561   addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
2562   return true;
2563 }
2564
2565 /// \brief Helper to add an extra variant path for an (Ubuntu) multilib
2566 /// libstdc++ installation.
2567 /*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
2568                                                 Twine TargetArchDir,
2569                                                 Twine MultiLibSuffix,
2570                                                 const ArgList &DriverArgs,
2571                                                 ArgStringList &CC1Args) {
2572   if (!addLibStdCXXIncludePaths(Base+Suffix, TargetArchDir + MultiLibSuffix,
2573                                 DriverArgs, CC1Args))
2574     return false;
2575
2576   addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir + Suffix
2577                    + MultiLibSuffix);
2578   return true;
2579 }
2580
2581 void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2582                                          ArgStringList &CC1Args) const {
2583   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2584       DriverArgs.hasArg(options::OPT_nostdincxx))
2585     return;
2586
2587   // Check if libc++ has been enabled and provide its include paths if so.
2588   if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
2589     // libc++ is always installed at a fixed path on Linux currently.
2590     addSystemInclude(DriverArgs, CC1Args,
2591                      getDriver().SysRoot + "/usr/include/c++/v1");
2592     return;
2593   }
2594
2595   // We need a detected GCC installation on Linux to provide libstdc++'s
2596   // headers. We handled the libc++ case above.
2597   if (!GCCInstallation.isValid())
2598     return;
2599
2600   // By default, look for the C++ headers in an include directory adjacent to
2601   // the lib directory of the GCC installation. Note that this is expect to be
2602   // equivalent to '/usr/include/c++/X.Y' in almost all cases.
2603   StringRef LibDir = GCCInstallation.getParentLibPath();
2604   StringRef InstallDir = GCCInstallation.getInstallPath();
2605   StringRef Version = GCCInstallation.getVersion().Text;
2606   StringRef TripleStr = GCCInstallation.getTriple().str();
2607
2608   if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
2609                                "/c++/" + Version.str(),
2610                                TripleStr,
2611                                GCCInstallation.getMultiarchSuffix(),
2612                                DriverArgs, CC1Args))
2613     return;
2614
2615   const std::string IncludePathCandidates[] = {
2616     // Gentoo is weird and places its headers inside the GCC install, so if the
2617     // first attempt to find the headers fails, try this pattern.
2618     InstallDir.str() + "/include/g++-v4",
2619     // Android standalone toolchain has C++ headers in yet another place.
2620     LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.str(),
2621     // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
2622     // without a subdirectory corresponding to the gcc version.
2623     LibDir.str() + "/../include/c++",
2624   };
2625
2626   for (unsigned i = 0; i < llvm::array_lengthof(IncludePathCandidates); ++i) {
2627     if (addLibStdCXXIncludePaths(IncludePathCandidates[i], (TripleStr +
2628                 GCCInstallation.getMultiarchSuffix()),
2629             DriverArgs, CC1Args))
2630       break;
2631   }
2632 }
2633
2634 bool Linux::isPIEDefault() const {
2635   return IsPIEDefault;
2636 }
2637
2638 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2639
2640 DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2641   : Generic_ELF(D, Triple, Args) {
2642
2643   // Path mangling to find libexec
2644   getProgramPaths().push_back(getDriver().getInstalledDir());
2645   if (getDriver().getInstalledDir() != getDriver().Dir)
2646     getProgramPaths().push_back(getDriver().Dir);
2647
2648   getFilePaths().push_back(getDriver().Dir + "/../lib");
2649   getFilePaths().push_back("/usr/lib");
2650   if (llvm::sys::fs::exists("/usr/lib/gcc47"))
2651     getFilePaths().push_back("/usr/lib/gcc47");
2652   else
2653     getFilePaths().push_back("/usr/lib/gcc44");
2654 }
2655
2656 Tool *DragonFly::buildAssembler() const {
2657   return new tools::dragonfly::Assemble(*this);
2658 }
2659
2660 Tool *DragonFly::buildLinker() const {
2661   return new tools::dragonfly::Link(*this);
2662 }