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

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