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::GNUEABI:
2038   case llvm::Triple::EABI:
2039     return false;
2040
2041   default:
2042     return (getTriple().getArch() == llvm::Triple::arm ||
2043             getTriple().getArch() == llvm::Triple::thumb);
2044   }
2045 }
2046
2047 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
2048
2049 NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2050   : Generic_ELF(D, Triple, Args) {
2051
2052   if (getDriver().UseStdLib) {
2053     // When targeting a 32-bit platform, try the special directory used on
2054     // 64-bit hosts, and only fall back to the main library directory if that
2055     // doesn't work.
2056     // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
2057     // what all logic is needed to emulate the '=' prefix here.
2058     if (Triple.getArch() == llvm::Triple::x86)
2059       getFilePaths().push_back("=/usr/lib/i386");
2060
2061     getFilePaths().push_back("=/usr/lib");
2062   }
2063 }
2064
2065 Tool *NetBSD::buildAssembler() const {
2066   return new tools::netbsd::Assemble(*this);
2067 }
2068
2069 Tool *NetBSD::buildLinker() const {
2070   return new tools::netbsd::Link(*this);
2071 }
2072
2073 ToolChain::CXXStdlibType
2074 NetBSD::GetCXXStdlibType(const ArgList &Args) const {
2075   if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2076     StringRef Value = A->getValue();
2077     if (Value == "libstdc++")
2078       return ToolChain::CST_Libstdcxx;
2079     if (Value == "libc++")
2080       return ToolChain::CST_Libcxx;
2081
2082     getDriver().Diag(diag::err_drv_invalid_stdlib_name)
2083       << A->getAsString(Args);
2084   }
2085
2086   unsigned Major, Minor, Micro;
2087   getTriple().getOSVersion(Major, Minor, Micro);
2088   if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
2089     if (getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64)
2090       return ToolChain::CST_Libcxx;
2091   }
2092   return ToolChain::CST_Libstdcxx;
2093 }
2094
2095 void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2096                                           ArgStringList &CC1Args) const {
2097   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2098       DriverArgs.hasArg(options::OPT_nostdincxx))
2099     return;
2100
2101   switch (GetCXXStdlibType(DriverArgs)) {
2102   case ToolChain::CST_Libcxx:
2103     addSystemInclude(DriverArgs, CC1Args,
2104                      getDriver().SysRoot + "/usr/include/c++/");
2105     break;
2106   case ToolChain::CST_Libstdcxx:
2107     addSystemInclude(DriverArgs, CC1Args,
2108                      getDriver().SysRoot + "/usr/include/g++");
2109     addSystemInclude(DriverArgs, CC1Args,
2110                      getDriver().SysRoot + "/usr/include/g++/backward");
2111     break;
2112   }
2113 }
2114
2115 /// Minix - Minix tool chain which can call as(1) and ld(1) directly.
2116
2117 Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2118   : Generic_ELF(D, Triple, Args) {
2119   getFilePaths().push_back(getDriver().Dir + "/../lib");
2120   getFilePaths().push_back("/usr/lib");
2121 }
2122
2123 Tool *Minix::buildAssembler() const {
2124   return new tools::minix::Assemble(*this);
2125 }
2126
2127 Tool *Minix::buildLinker() const {
2128   return new tools::minix::Link(*this);
2129 }
2130
2131 /// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
2132
2133 AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple,
2134                    const ArgList &Args)
2135   : Generic_GCC(D, Triple, Args) {
2136
2137   getProgramPaths().push_back(getDriver().getInstalledDir());
2138   if (getDriver().getInstalledDir() != getDriver().Dir)
2139     getProgramPaths().push_back(getDriver().Dir);
2140
2141   getFilePaths().push_back(getDriver().Dir + "/../lib");
2142   getFilePaths().push_back("/usr/lib");
2143   getFilePaths().push_back("/usr/sfw/lib");
2144   getFilePaths().push_back("/opt/gcc4/lib");
2145   getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
2146
2147 }
2148
2149 Tool *AuroraUX::buildAssembler() const {
2150   return new tools::auroraux::Assemble(*this);
2151 }
2152
2153 Tool *AuroraUX::buildLinker() const {
2154   return new tools::auroraux::Link(*this);
2155 }
2156
2157 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
2158
2159 Solaris::Solaris(const Driver &D, const llvm::Triple& Triple,
2160                  const ArgList &Args)
2161   : Generic_GCC(D, Triple, Args) {
2162
2163   getProgramPaths().push_back(getDriver().getInstalledDir());
2164   if (getDriver().getInstalledDir() != getDriver().Dir)
2165     getProgramPaths().push_back(getDriver().Dir);
2166
2167   getFilePaths().push_back(getDriver().Dir + "/../lib");
2168   getFilePaths().push_back("/usr/lib");
2169 }
2170
2171 Tool *Solaris::buildAssembler() const {
2172   return new tools::solaris::Assemble(*this);
2173 }
2174
2175 Tool *Solaris::buildLinker() const {
2176   return new tools::solaris::Link(*this);
2177 }
2178
2179 /// Distribution (very bare-bones at the moment).
2180
2181 enum Distro {
2182   ArchLinux,
2183   DebianLenny,
2184   DebianSqueeze,
2185   DebianWheezy,
2186   DebianJessie,
2187   Exherbo,
2188   RHEL4,
2189   RHEL5,
2190   RHEL6,
2191   Fedora,
2192   OpenSUSE,
2193   UbuntuHardy,
2194   UbuntuIntrepid,
2195   UbuntuJaunty,
2196   UbuntuKarmic,
2197   UbuntuLucid,
2198   UbuntuMaverick,
2199   UbuntuNatty,
2200   UbuntuOneiric,
2201   UbuntuPrecise,
2202   UbuntuQuantal,
2203   UbuntuRaring,
2204   UbuntuSaucy,
2205   UbuntuTrusty,
2206   UnknownDistro
2207 };
2208
2209 static bool IsRedhat(enum Distro Distro) {
2210   return Distro == Fedora || (Distro >= RHEL4 && Distro <= RHEL6);
2211 }
2212
2213 static bool IsOpenSUSE(enum Distro Distro) {
2214   return Distro == OpenSUSE;
2215 }
2216
2217 static bool IsDebian(enum Distro Distro) {
2218   return Distro >= DebianLenny && Distro <= DebianJessie;
2219 }
2220
2221 static bool IsUbuntu(enum Distro Distro) {
2222   return Distro >= UbuntuHardy && Distro <= UbuntuTrusty;
2223 }
2224
2225 static Distro DetectDistro(llvm::Triple::ArchType Arch) {
2226   OwningPtr<llvm::MemoryBuffer> File;
2227   if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
2228     StringRef Data = File.get()->getBuffer();
2229     SmallVector<StringRef, 8> Lines;
2230     Data.split(Lines, "\n");
2231     Distro Version = UnknownDistro;
2232     for (unsigned i = 0, s = Lines.size(); i != s; ++i)
2233       if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME="))
2234         Version = llvm::StringSwitch<Distro>(Lines[i].substr(17))
2235           .Case("hardy", UbuntuHardy)
2236           .Case("intrepid", UbuntuIntrepid)
2237           .Case("jaunty", UbuntuJaunty)
2238           .Case("karmic", UbuntuKarmic)
2239           .Case("lucid", UbuntuLucid)
2240           .Case("maverick", UbuntuMaverick)
2241           .Case("natty", UbuntuNatty)
2242           .Case("oneiric", UbuntuOneiric)
2243           .Case("precise", UbuntuPrecise)
2244           .Case("quantal", UbuntuQuantal)
2245           .Case("raring", UbuntuRaring)
2246           .Case("saucy", UbuntuSaucy)
2247           .Case("trusty", UbuntuTrusty)
2248           .Default(UnknownDistro);
2249     return Version;
2250   }
2251
2252   if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
2253     StringRef Data = File.get()->getBuffer();
2254     if (Data.startswith("Fedora release"))
2255       return Fedora;
2256     else if (Data.startswith("Red Hat Enterprise Linux") &&
2257              Data.find("release 6") != StringRef::npos)
2258       return RHEL6;
2259     else if ((Data.startswith("Red Hat Enterprise Linux") ||
2260               Data.startswith("CentOS")) &&
2261              Data.find("release 5") != StringRef::npos)
2262       return RHEL5;
2263     else if ((Data.startswith("Red Hat Enterprise Linux") ||
2264               Data.startswith("CentOS")) &&
2265              Data.find("release 4") != StringRef::npos)
2266       return RHEL4;
2267     return UnknownDistro;
2268   }
2269
2270   if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
2271     StringRef Data = File.get()->getBuffer();
2272     if (Data[0] == '5')
2273       return DebianLenny;
2274     else if (Data.startswith("squeeze/sid") || Data[0] == '6')
2275       return DebianSqueeze;
2276     else if (Data.startswith("wheezy/sid")  || Data[0] == '7')
2277       return DebianWheezy;
2278     else if (Data.startswith("jessie/sid")  || Data[0] == '8')
2279       return DebianJessie;
2280     return UnknownDistro;
2281   }
2282
2283   if (llvm::sys::fs::exists("/etc/SuSE-release"))
2284     return OpenSUSE;
2285
2286   if (llvm::sys::fs::exists("/etc/exherbo-release"))
2287     return Exherbo;
2288
2289   if (llvm::sys::fs::exists("/etc/arch-release"))
2290     return ArchLinux;
2291
2292   return UnknownDistro;
2293 }
2294
2295 /// \brief Get our best guess at the multiarch triple for a target.
2296 ///
2297 /// Debian-based systems are starting to use a multiarch setup where they use
2298 /// a target-triple directory in the library and header search paths.
2299 /// Unfortunately, this triple does not align with the vanilla target triple,
2300 /// so we provide a rough mapping here.
2301 static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
2302                                       StringRef SysRoot) {
2303   // For most architectures, just use whatever we have rather than trying to be
2304   // clever.
2305   switch (TargetTriple.getArch()) {
2306   default:
2307     return TargetTriple.str();
2308
2309     // We use the existence of '/lib/<triple>' as a directory to detect some
2310     // common linux triples that don't quite match the Clang triple for both
2311     // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
2312     // regardless of what the actual target triple is.
2313   case llvm::Triple::arm:
2314   case llvm::Triple::thumb:
2315     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2316       if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabihf"))
2317         return "arm-linux-gnueabihf";
2318     } else {
2319       if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabi"))
2320         return "arm-linux-gnueabi";
2321     }
2322     return TargetTriple.str();
2323   case llvm::Triple::x86:
2324     if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
2325       return "i386-linux-gnu";
2326     return TargetTriple.str();
2327   case llvm::Triple::x86_64:
2328     if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
2329       return "x86_64-linux-gnu";
2330     return TargetTriple.str();
2331   case llvm::Triple::aarch64:
2332     if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64-linux-gnu"))
2333       return "aarch64-linux-gnu";
2334     return TargetTriple.str();
2335   case llvm::Triple::mips:
2336     if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu"))
2337       return "mips-linux-gnu";
2338     return TargetTriple.str();
2339   case llvm::Triple::mipsel:
2340     if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu"))
2341       return "mipsel-linux-gnu";
2342     return TargetTriple.str();
2343   case llvm::Triple::ppc:
2344     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
2345       return "powerpc-linux-gnuspe";
2346     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu"))
2347       return "powerpc-linux-gnu";
2348     return TargetTriple.str();
2349   case llvm::Triple::ppc64:
2350     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu"))
2351       return "powerpc64-linux-gnu";
2352   case llvm::Triple::ppc64le:
2353     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64le-linux-gnu"))
2354       return "powerpc64le-linux-gnu";
2355     return TargetTriple.str();
2356   }
2357 }
2358
2359 static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) {
2360   if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str());
2361 }
2362
2363 static StringRef getMultilibDir(const llvm::Triple &Triple,
2364                                 const ArgList &Args) {
2365   if (isMipsArch(Triple.getArch())) {
2366     // lib32 directory has a special meaning on MIPS targets.
2367     // It contains N32 ABI binaries. Use this folder if produce
2368     // code for N32 ABI only.
2369     if (hasMipsN32ABIArg(Args))
2370       return "lib32";
2371     return Triple.isArch32Bit() ? "lib" : "lib64";
2372   }
2373
2374   // It happens that only x86 and PPC use the 'lib32' variant of multilib, and
2375   // using that variant while targeting other architectures causes problems
2376   // because the libraries are laid out in shared system roots that can't cope
2377   // with a 'lib32' multilib search path being considered. So we only enable
2378   // them when we know we may need it.
2379   //
2380   // FIXME: This is a bit of a hack. We should really unify this code for
2381   // reasoning about multilib spellings with the lib dir spellings in the
2382   // GCCInstallationDetector, but that is a more significant refactoring.
2383   if (Triple.getArch() == llvm::Triple::x86 ||
2384       Triple.getArch() == llvm::Triple::ppc)
2385     return "lib32";
2386
2387   return Triple.isArch32Bit() ? "lib" : "lib64";
2388 }
2389
2390 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2391   : Generic_ELF(D, Triple, Args) {
2392   GCCInstallation.init(Triple, Args);
2393   llvm::Triple::ArchType Arch = Triple.getArch();
2394   std::string SysRoot = computeSysRoot();
2395
2396   // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
2397   // least) put various tools in a triple-prefixed directory off of the parent
2398   // of the GCC installation. We use the GCC triple here to ensure that we end
2399   // up with tools that support the same amount of cross compiling as the
2400   // detected GCC installation. For example, if we find a GCC installation
2401   // targeting x86_64, but it is a bi-arch GCC installation, it can also be
2402   // used to target i386.
2403   // FIXME: This seems unlikely to be Linux-specific.
2404   ToolChain::path_list &PPaths = getProgramPaths();
2405   PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
2406                          GCCInstallation.getTriple().str() + "/bin").str());
2407
2408   Linker = GetProgramPath("ld");
2409
2410   Distro Distro = DetectDistro(Arch);
2411
2412   if (IsOpenSUSE(Distro) || IsUbuntu(Distro)) {
2413     ExtraOpts.push_back("-z");
2414     ExtraOpts.push_back("relro");
2415   }
2416
2417   if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
2418     ExtraOpts.push_back("-X");
2419
2420   const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::Android;
2421   const bool IsMips = isMipsArch(Arch);
2422
2423   if (IsMips && !SysRoot.empty())
2424     ExtraOpts.push_back("--sysroot=" + SysRoot);
2425
2426   // Do not use 'gnu' hash style for Mips targets because .gnu.hash
2427   // and the MIPS ABI require .dynsym to be sorted in different ways.
2428   // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
2429   // ABI requires a mapping between the GOT and the symbol table.
2430   // Android loader does not support .gnu.hash.
2431   if (!IsMips && !IsAndroid) {
2432     if (IsRedhat(Distro) || IsOpenSUSE(Distro) ||
2433         (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
2434       ExtraOpts.push_back("--hash-style=gnu");
2435
2436     if (IsDebian(Distro) || IsOpenSUSE(Distro) || Distro == UbuntuLucid ||
2437         Distro == UbuntuJaunty || Distro == UbuntuKarmic)
2438       ExtraOpts.push_back("--hash-style=both");
2439   }
2440
2441   if (IsRedhat(Distro))
2442     ExtraOpts.push_back("--no-add-needed");
2443
2444   if (Distro == DebianSqueeze || Distro == DebianWheezy ||
2445       Distro == DebianJessie || IsOpenSUSE(Distro) ||
2446       (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
2447       (IsUbuntu(Distro) && Distro >= UbuntuKarmic))
2448     ExtraOpts.push_back("--build-id");
2449
2450   if (IsOpenSUSE(Distro))
2451     ExtraOpts.push_back("--enable-new-dtags");
2452
2453   // The selection of paths to try here is designed to match the patterns which
2454   // the GCC driver itself uses, as this is part of the GCC-compatible driver.
2455   // This was determined by running GCC in a fake filesystem, creating all
2456   // possible permutations of these directories, and seeing which ones it added
2457   // to the link paths.
2458   path_list &Paths = getFilePaths();
2459
2460   const std::string Multilib = getMultilibDir(Triple, Args);
2461   const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
2462
2463   // Add the multilib suffixed paths where they are available.
2464   if (GCCInstallation.isValid()) {
2465     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2466     const std::string &LibPath = GCCInstallation.getParentLibPath();
2467
2468     // Sourcery CodeBench MIPS toolchain holds some libraries under
2469     // a biarch-like suffix of the GCC installation.
2470     //
2471     // FIXME: It would be cleaner to model this as a variant of bi-arch. IE,
2472     // instead of a '64' biarch suffix it would be 'el' or something.
2473     if (IsAndroid && IsMips && isMips32r2(Args)) {
2474       assert(GCCInstallation.getBiarchSuffix().empty() &&
2475              "Unexpected bi-arch suffix");
2476       addPathIfExists(GCCInstallation.getInstallPath() + "/mips-r2", Paths);
2477     } else {
2478       addPathIfExists((GCCInstallation.getInstallPath() +
2479                        GCCInstallation.getMIPSABIDirSuffix() +
2480                        GCCInstallation.getBiarchSuffix()),
2481                       Paths);
2482     }
2483
2484     // GCC cross compiling toolchains will install target libraries which ship
2485     // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
2486     // any part of the GCC installation in
2487     // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
2488     // debatable, but is the reality today. We need to search this tree even
2489     // when we have a sysroot somewhere else. It is the responsibility of
2490     // whomever is doing the cross build targetting a sysroot using a GCC
2491     // installation that is *not* within the system root to ensure two things:
2492     //
2493     //  1) Any DSOs that are linked in from this tree or from the install path
2494     //     above must be preasant on the system root and found via an
2495     //     appropriate rpath.
2496     //  2) There must not be libraries installed into
2497     //     <prefix>/<triple>/<libdir> unless they should be preferred over
2498     //     those within the system root.
2499     //
2500     // Note that this matches the GCC behavior. See the below comment for where
2501     // Clang diverges from GCC's behavior.
2502     addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + Multilib +
2503                     GCCInstallation.getMIPSABIDirSuffix(),
2504                     Paths);
2505
2506     // If the GCC installation we found is inside of the sysroot, we want to
2507     // prefer libraries installed in the parent prefix of the GCC installation.
2508     // It is important to *not* use these paths when the GCC installation is
2509     // outside of the system root as that can pick up unintended libraries.
2510     // This usually happens when there is an external cross compiler on the
2511     // host system, and a more minimal sysroot available that is the target of
2512     // the cross. Note that GCC does include some of these directories in some
2513     // configurations but this seems somewhere between questionable and simply
2514     // a bug.
2515     if (StringRef(LibPath).startswith(SysRoot)) {
2516       addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
2517       addPathIfExists(LibPath + "/../" + Multilib, Paths);
2518     }
2519   }
2520   addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
2521   addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
2522   addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
2523   addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
2524
2525   // Try walking via the GCC triple path in case of biarch or multiarch GCC
2526   // installations with strange symlinks.
2527   if (GCCInstallation.isValid()) {
2528     addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
2529                     "/../../" + Multilib, Paths);
2530
2531     // Add the non-multilib suffixed paths (if potentially different).
2532     const std::string &LibPath = GCCInstallation.getParentLibPath();
2533     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2534     if (!GCCInstallation.getBiarchSuffix().empty())
2535       addPathIfExists(GCCInstallation.getInstallPath() +
2536                       GCCInstallation.getMIPSABIDirSuffix(), Paths);
2537
2538     // See comments above on the multilib variant for details of why this is
2539     // included even from outside the sysroot.
2540     addPathIfExists(LibPath + "/../" + GCCTriple.str() +
2541                     "/lib" + GCCInstallation.getMIPSABIDirSuffix(), Paths);
2542
2543     // See comments above on the multilib variant for details of why this is
2544     // only included from within the sysroot.
2545     if (StringRef(LibPath).startswith(SysRoot))
2546       addPathIfExists(LibPath, Paths);
2547   }
2548   addPathIfExists(SysRoot + "/lib", Paths);
2549   addPathIfExists(SysRoot + "/usr/lib", Paths);
2550 }
2551
2552 bool FreeBSD::HasNativeLLVMSupport() const {
2553   return true;
2554 }
2555
2556 bool Linux::HasNativeLLVMSupport() const {
2557   return true;
2558 }
2559
2560 Tool *Linux::buildLinker() const {
2561   return new tools::gnutools::Link(*this);
2562 }
2563
2564 Tool *Linux::buildAssembler() const {
2565   return new tools::gnutools::Assemble(*this);
2566 }
2567
2568 void Linux::addClangTargetOptions(const ArgList &DriverArgs,
2569                                   ArgStringList &CC1Args) const {
2570   const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2571   bool UseInitArrayDefault =
2572       !V.isOlderThan(4, 7, 0) ||
2573       getTriple().getArch() == llvm::Triple::aarch64 ||
2574       getTriple().getEnvironment() == llvm::Triple::Android;
2575   if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2576                          options::OPT_fno_use_init_array,
2577                          UseInitArrayDefault))
2578     CC1Args.push_back("-fuse-init-array");
2579 }
2580
2581 std::string Linux::computeSysRoot() const {
2582   if (!getDriver().SysRoot.empty())
2583     return getDriver().SysRoot;
2584
2585   if (!GCCInstallation.isValid() || !isMipsArch(getTriple().getArch()))
2586     return std::string();
2587
2588   // Standalone MIPS toolchains use different names for sysroot folder
2589   // and put it into different places. Here we try to check some known
2590   // variants.
2591
2592   const StringRef InstallDir = GCCInstallation.getInstallPath();
2593   const StringRef TripleStr = GCCInstallation.getTriple().str();
2594   const StringRef MIPSABIDirSuffix = GCCInstallation.getMIPSABIDirSuffix();
2595
2596   std::string Path = (InstallDir + "/../../../../" + TripleStr + "/libc" +
2597                       MIPSABIDirSuffix).str();
2598
2599   if (llvm::sys::fs::exists(Path))
2600     return Path;
2601
2602   Path = (InstallDir + "/../../../../sysroot" + MIPSABIDirSuffix).str();
2603
2604   if (llvm::sys::fs::exists(Path))
2605     return Path;
2606
2607   return std::string();
2608 }
2609
2610 void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2611                                       ArgStringList &CC1Args) const {
2612   const Driver &D = getDriver();
2613   std::string SysRoot = computeSysRoot();
2614
2615   if (DriverArgs.hasArg(options::OPT_nostdinc))
2616     return;
2617
2618   if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
2619     addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
2620
2621   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2622     SmallString<128> P(D.ResourceDir);
2623     llvm::sys::path::append(P, "include");
2624     addSystemInclude(DriverArgs, CC1Args, P.str());
2625   }
2626
2627   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2628     return;
2629
2630   // Check for configure-time C include directories.
2631   StringRef CIncludeDirs(C_INCLUDE_DIRS);
2632   if (CIncludeDirs != "") {
2633     SmallVector<StringRef, 5> dirs;
2634     CIncludeDirs.split(dirs, ":");
2635     for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
2636          I != E; ++I) {
2637       StringRef Prefix = llvm::sys::path::is_absolute(*I) ? SysRoot : "";
2638       addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
2639     }
2640     return;
2641   }
2642
2643   // Lacking those, try to detect the correct set of system includes for the
2644   // target triple.
2645
2646   // Sourcery CodeBench and modern FSF Mips toolchains put extern C
2647   // system includes under three additional directories.
2648   if (GCCInstallation.isValid() && isMipsArch(getTriple().getArch())) {
2649     addExternCSystemIncludeIfExists(
2650         DriverArgs, CC1Args, GCCInstallation.getInstallPath() + "/include");
2651
2652     addExternCSystemIncludeIfExists(
2653         DriverArgs, CC1Args,
2654         GCCInstallation.getInstallPath() + "/../../../../" +
2655             GCCInstallation.getTriple().str() + "/libc/usr/include");
2656
2657     addExternCSystemIncludeIfExists(
2658         DriverArgs, CC1Args,
2659         GCCInstallation.getInstallPath() + "/../../../../sysroot/usr/include");
2660   }
2661
2662   // Implement generic Debian multiarch support.
2663   const StringRef X86_64MultiarchIncludeDirs[] = {
2664     "/usr/include/x86_64-linux-gnu",
2665
2666     // FIXME: These are older forms of multiarch. It's not clear that they're
2667     // in use in any released version of Debian, so we should consider
2668     // removing them.
2669     "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"
2670   };
2671   const StringRef X86MultiarchIncludeDirs[] = {
2672     "/usr/include/i386-linux-gnu",
2673
2674     // FIXME: These are older forms of multiarch. It's not clear that they're
2675     // in use in any released version of Debian, so we should consider
2676     // removing them.
2677     "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",
2678     "/usr/include/i486-linux-gnu"
2679   };
2680   const StringRef AArch64MultiarchIncludeDirs[] = {
2681     "/usr/include/aarch64-linux-gnu"
2682   };
2683   const StringRef ARMMultiarchIncludeDirs[] = {
2684     "/usr/include/arm-linux-gnueabi"
2685   };
2686   const StringRef ARMHFMultiarchIncludeDirs[] = {
2687     "/usr/include/arm-linux-gnueabihf"
2688   };
2689   const StringRef MIPSMultiarchIncludeDirs[] = {
2690     "/usr/include/mips-linux-gnu"
2691   };
2692   const StringRef MIPSELMultiarchIncludeDirs[] = {
2693     "/usr/include/mipsel-linux-gnu"
2694   };
2695   const StringRef PPCMultiarchIncludeDirs[] = {
2696     "/usr/include/powerpc-linux-gnu"
2697   };
2698   const StringRef PPC64MultiarchIncludeDirs[] = {
2699     "/usr/include/powerpc64-linux-gnu"
2700   };
2701   ArrayRef<StringRef> MultiarchIncludeDirs;
2702   if (getTriple().getArch() == llvm::Triple::x86_64) {
2703     MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
2704   } else if (getTriple().getArch() == llvm::Triple::x86) {
2705     MultiarchIncludeDirs = X86MultiarchIncludeDirs;
2706   } else if (getTriple().getArch() == llvm::Triple::aarch64) {
2707     MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
2708   } else if (getTriple().getArch() == llvm::Triple::arm) {
2709     if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
2710       MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
2711     else
2712       MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
2713   } else if (getTriple().getArch() == llvm::Triple::mips) {
2714     MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
2715   } else if (getTriple().getArch() == llvm::Triple::mipsel) {
2716     MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
2717   } else if (getTriple().getArch() == llvm::Triple::ppc) {
2718     MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
2719   } else if (getTriple().getArch() == llvm::Triple::ppc64) {
2720     MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
2721   }
2722   for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(),
2723                                      E = MultiarchIncludeDirs.end();
2724        I != E; ++I) {
2725     if (llvm::sys::fs::exists(SysRoot + *I)) {
2726       addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + *I);
2727       break;
2728     }
2729   }
2730
2731   if (getTriple().getOS() == llvm::Triple::RTEMS)
2732     return;
2733
2734   // Add an include of '/include' directly. This isn't provided by default by
2735   // system GCCs, but is often used with cross-compiling GCCs, and harmless to
2736   // add even when Clang is acting as-if it were a system compiler.
2737   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
2738
2739   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
2740 }
2741
2742 /// \brief Helper to add the three variant paths for a libstdc++ installation.
2743 /*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
2744                                                 const ArgList &DriverArgs,
2745                                                 ArgStringList &CC1Args) {
2746   if (!llvm::sys::fs::exists(Base))
2747     return false;
2748   addSystemInclude(DriverArgs, CC1Args, Base);
2749   addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir);
2750   addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
2751   return true;
2752 }
2753
2754 /// \brief Helper to add an extra variant path for an (Ubuntu) multilib
2755 /// libstdc++ installation.
2756 /*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
2757                                                 Twine TargetArchDir,
2758                                                 Twine BiarchSuffix,
2759                                                 Twine MIPSABIDirSuffix,
2760                                                 const ArgList &DriverArgs,
2761                                                 ArgStringList &CC1Args) {
2762   if (!addLibStdCXXIncludePaths(Base + Suffix,
2763                                 TargetArchDir + MIPSABIDirSuffix + BiarchSuffix,
2764                                 DriverArgs, CC1Args))
2765     return false;
2766
2767   addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir + Suffix
2768                    + MIPSABIDirSuffix + BiarchSuffix);
2769   return true;
2770 }
2771
2772 void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2773                                          ArgStringList &CC1Args) const {
2774   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2775       DriverArgs.hasArg(options::OPT_nostdincxx))
2776     return;
2777
2778   // Check if libc++ has been enabled and provide its include paths if so.
2779   if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
2780     // libc++ is always installed at a fixed path on Linux currently.
2781     addSystemInclude(DriverArgs, CC1Args,
2782                      getDriver().SysRoot + "/usr/include/c++/v1");
2783     return;
2784   }
2785
2786   // We need a detected GCC installation on Linux to provide libstdc++'s
2787   // headers. We handled the libc++ case above.
2788   if (!GCCInstallation.isValid())
2789     return;
2790
2791   // By default, look for the C++ headers in an include directory adjacent to
2792   // the lib directory of the GCC installation. Note that this is expect to be
2793   // equivalent to '/usr/include/c++/X.Y' in almost all cases.
2794   StringRef LibDir = GCCInstallation.getParentLibPath();
2795   StringRef InstallDir = GCCInstallation.getInstallPath();
2796   StringRef TripleStr = GCCInstallation.getTriple().str();
2797   StringRef MIPSABIDirSuffix = GCCInstallation.getMIPSABIDirSuffix();
2798   StringRef BiarchSuffix = GCCInstallation.getBiarchSuffix();
2799   const GCCVersion &Version = GCCInstallation.getVersion();
2800
2801   if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
2802                                "/c++/" + Version.Text, TripleStr, BiarchSuffix,
2803                                MIPSABIDirSuffix, DriverArgs, CC1Args))
2804     return;
2805
2806   const std::string IncludePathCandidates[] = {
2807     // Gentoo is weird and places its headers inside the GCC install, so if the
2808     // first attempt to find the headers fails, try these patterns.
2809     InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
2810         Version.MinorStr,
2811     InstallDir.str() + "/include/g++-v" + Version.MajorStr,
2812     // Android standalone toolchain has C++ headers in yet another place.
2813     LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
2814     // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
2815     // without a subdirectory corresponding to the gcc version.
2816     LibDir.str() + "/../include/c++",
2817   };
2818
2819   for (unsigned i = 0; i < llvm::array_lengthof(IncludePathCandidates); ++i) {
2820     if (addLibStdCXXIncludePaths(IncludePathCandidates[i],
2821                                  TripleStr + MIPSABIDirSuffix + BiarchSuffix,
2822                                  DriverArgs, CC1Args))
2823       break;
2824   }
2825 }
2826
2827 bool Linux::isPIEDefault() const {
2828   return getSanitizerArgs().hasZeroBaseShadow();
2829 }
2830
2831 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2832
2833 DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2834   : Generic_ELF(D, Triple, Args) {
2835
2836   // Path mangling to find libexec
2837   getProgramPaths().push_back(getDriver().getInstalledDir());
2838   if (getDriver().getInstalledDir() != getDriver().Dir)
2839     getProgramPaths().push_back(getDriver().Dir);
2840
2841   getFilePaths().push_back(getDriver().Dir + "/../lib");
2842   getFilePaths().push_back("/usr/lib");
2843   if (llvm::sys::fs::exists("/usr/lib/gcc47"))
2844     getFilePaths().push_back("/usr/lib/gcc47");
2845   else
2846     getFilePaths().push_back("/usr/lib/gcc44");
2847 }
2848
2849 Tool *DragonFly::buildAssembler() const {
2850   return new tools::dragonfly::Assemble(*this);
2851 }
2852
2853 Tool *DragonFly::buildLinker() const {
2854   return new tools::dragonfly::Link(*this);
2855 }
2856
2857
2858 /// XCore tool chain
2859 XCore::XCore(const Driver &D, const llvm::Triple &Triple,
2860              const ArgList &Args) : ToolChain(D, Triple, Args) {
2861   // ProgramPaths are found via 'PATH' environment variable.
2862 }
2863
2864 Tool *XCore::buildAssembler() const {
2865   return new tools::XCore::Assemble(*this);
2866 }
2867
2868 Tool *XCore::buildLinker() const {
2869   return new tools::XCore::Link(*this);
2870 }
2871
2872 bool XCore::isPICDefault() const {
2873   return false;
2874 }
2875
2876 bool XCore::isPIEDefault() const {
2877   return false;
2878 }
2879
2880 bool XCore::isPICDefaultForced() const {
2881   return false;
2882 }
2883
2884 bool XCore::SupportsProfiling() const {
2885   return false;
2886 }
2887
2888 bool XCore::hasBlocksRuntime() const {
2889   return false;
2890 }
2891
2892
2893 void XCore::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2894                                       ArgStringList &CC1Args) const {
2895   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2896       DriverArgs.hasArg(options::OPT_nostdlibinc))
2897     return;
2898   if (const char *cl_include_dir = getenv("XCC_C_INCLUDE_PATH")) {
2899     SmallVector<StringRef, 4> Dirs;
2900     const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,'\0'};
2901     StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
2902     ArrayRef<StringRef> DirVec(Dirs);
2903     addSystemIncludes(DriverArgs, CC1Args, DirVec);
2904   }
2905 }
2906
2907 void XCore::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
2908                                      llvm::opt::ArgStringList &CC1Args) const {
2909   CC1Args.push_back("-nostdsysteminc");
2910 }
2911
2912 void XCore::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2913                                          ArgStringList &CC1Args) const {
2914   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2915       DriverArgs.hasArg(options::OPT_nostdlibinc))
2916     return;
2917   if (const char *cl_include_dir = getenv("XCC_CPLUS_INCLUDE_PATH")) {
2918     SmallVector<StringRef, 4> Dirs;
2919     const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,'\0'};
2920     StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
2921     ArrayRef<StringRef> DirVec(Dirs);
2922     addSystemIncludes(DriverArgs, CC1Args, DirVec);
2923   }
2924 }
2925
2926 void XCore::AddCXXStdlibLibArgs(const ArgList &Args,
2927                                 ArgStringList &CmdArgs) const {
2928   // We don't output any lib args. This is handled by xcc.
2929 }