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