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 Construct 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 Generic_GCC::GCCInstallationDetector::GCCInstallationDetector(
1027     const Driver &D, const llvm::Triple &TargetTriple, const ArgList &Args)
1028     : IsValid(false), D(D) {
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 SystemZLibDirs[] = { "/lib64", "/lib" };
1168   static const char *const SystemZTriples[] = {
1169     "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
1170     "s390x-suse-linux", "s390x-redhat-linux"
1171   };
1172
1173   switch (TargetTriple.getArch()) {
1174   case llvm::Triple::aarch64:
1175     LibDirs.append(AArch64LibDirs,
1176                    AArch64LibDirs + llvm::array_lengthof(AArch64LibDirs));
1177     TripleAliases.append(AArch64Triples,
1178                          AArch64Triples + llvm::array_lengthof(AArch64Triples));
1179     BiarchLibDirs.append(AArch64LibDirs,
1180                          AArch64LibDirs + llvm::array_lengthof(AArch64LibDirs));
1181     BiarchTripleAliases.append(
1182         AArch64Triples, AArch64Triples + llvm::array_lengthof(AArch64Triples));
1183     break;
1184   case llvm::Triple::arm:
1185   case llvm::Triple::thumb:
1186     LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs));
1187     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1188       TripleAliases.append(ARMHFTriples,
1189                            ARMHFTriples + llvm::array_lengthof(ARMHFTriples));
1190     } else {
1191       TripleAliases.append(ARMTriples,
1192                            ARMTriples + llvm::array_lengthof(ARMTriples));
1193     }
1194     break;
1195   case llvm::Triple::x86_64:
1196     LibDirs.append(X86_64LibDirs,
1197                    X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1198     TripleAliases.append(X86_64Triples,
1199                          X86_64Triples + llvm::array_lengthof(X86_64Triples));
1200     BiarchLibDirs.append(X86LibDirs,
1201                          X86LibDirs + llvm::array_lengthof(X86LibDirs));
1202     BiarchTripleAliases.append(X86Triples,
1203                                X86Triples + llvm::array_lengthof(X86Triples));
1204     break;
1205   case llvm::Triple::x86:
1206     LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1207     TripleAliases.append(X86Triples,
1208                          X86Triples + llvm::array_lengthof(X86Triples));
1209     BiarchLibDirs.append(X86_64LibDirs,
1210                          X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1211     BiarchTripleAliases.append(
1212         X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples));
1213     break;
1214   case llvm::Triple::mips:
1215     LibDirs.append(MIPSLibDirs,
1216                    MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1217     TripleAliases.append(MIPSTriples,
1218                          MIPSTriples + llvm::array_lengthof(MIPSTriples));
1219     BiarchLibDirs.append(MIPS64LibDirs,
1220                          MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1221     BiarchTripleAliases.append(
1222         MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1223     break;
1224   case llvm::Triple::mipsel:
1225     LibDirs.append(MIPSELLibDirs,
1226                    MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1227     TripleAliases.append(MIPSELTriples,
1228                          MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1229     TripleAliases.append(MIPSTriples,
1230                          MIPSTriples + llvm::array_lengthof(MIPSTriples));
1231     BiarchLibDirs.append(
1232         MIPS64ELLibDirs,
1233         MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1234     BiarchTripleAliases.append(
1235         MIPS64ELTriples,
1236         MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1237     break;
1238   case llvm::Triple::mips64:
1239     LibDirs.append(MIPS64LibDirs,
1240                    MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1241     TripleAliases.append(MIPS64Triples,
1242                          MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1243     BiarchLibDirs.append(MIPSLibDirs,
1244                          MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1245     BiarchTripleAliases.append(MIPSTriples,
1246                                MIPSTriples + llvm::array_lengthof(MIPSTriples));
1247     break;
1248   case llvm::Triple::mips64el:
1249     LibDirs.append(MIPS64ELLibDirs,
1250                    MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1251     TripleAliases.append(
1252         MIPS64ELTriples,
1253         MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1254     BiarchLibDirs.append(MIPSELLibDirs,
1255                          MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1256     BiarchTripleAliases.append(
1257         MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1258     BiarchTripleAliases.append(
1259         MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples));
1260     break;
1261   case llvm::Triple::ppc:
1262     LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1263     TripleAliases.append(PPCTriples,
1264                          PPCTriples + llvm::array_lengthof(PPCTriples));
1265     BiarchLibDirs.append(PPC64LibDirs,
1266                          PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1267     BiarchTripleAliases.append(
1268         PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples));
1269     break;
1270   case llvm::Triple::ppc64:
1271     LibDirs.append(PPC64LibDirs,
1272                    PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1273     TripleAliases.append(PPC64Triples,
1274                          PPC64Triples + llvm::array_lengthof(PPC64Triples));
1275     BiarchLibDirs.append(PPCLibDirs,
1276                          PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1277     BiarchTripleAliases.append(PPCTriples,
1278                                PPCTriples + llvm::array_lengthof(PPCTriples));
1279     break;
1280   case llvm::Triple::ppc64le:
1281     LibDirs.append(PPC64LELibDirs,
1282                    PPC64LELibDirs + llvm::array_lengthof(PPC64LELibDirs));
1283     TripleAliases.append(PPC64LETriples,
1284                          PPC64LETriples + llvm::array_lengthof(PPC64LETriples));
1285     break;
1286   case llvm::Triple::systemz:
1287     LibDirs.append(SystemZLibDirs,
1288                    SystemZLibDirs + llvm::array_lengthof(SystemZLibDirs));
1289     TripleAliases.append(SystemZTriples,
1290                          SystemZTriples + llvm::array_lengthof(SystemZTriples));
1291     break;
1292
1293   default:
1294     // By default, just rely on the standard lib directories and the original
1295     // triple.
1296     break;
1297   }
1298
1299   // Always append the drivers target triple to the end, in case it doesn't
1300   // match any of our aliases.
1301   TripleAliases.push_back(TargetTriple.str());
1302
1303   // Also include the multiarch variant if it's different.
1304   if (TargetTriple.str() != BiarchTriple.str())
1305     BiarchTripleAliases.push_back(BiarchTriple.str());
1306 }
1307
1308 static bool isSoftFloatABI(const ArgList &Args) {
1309   Arg *A = Args.getLastArg(options::OPT_msoft_float,
1310                            options::OPT_mhard_float,
1311                            options::OPT_mfloat_abi_EQ);
1312   if (!A) return false;
1313
1314   return A->getOption().matches(options::OPT_msoft_float) ||
1315          (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
1316           A->getValue() == StringRef("soft"));
1317 }
1318
1319 static bool isMipsArch(llvm::Triple::ArchType Arch) {
1320   return Arch == llvm::Triple::mips ||
1321          Arch == llvm::Triple::mipsel ||
1322          Arch == llvm::Triple::mips64 ||
1323          Arch == llvm::Triple::mips64el;
1324 }
1325
1326 static bool isMips16(const ArgList &Args) {
1327   Arg *A = Args.getLastArg(options::OPT_mips16,
1328                            options::OPT_mno_mips16);
1329   return A && A->getOption().matches(options::OPT_mips16);
1330 }
1331
1332 static bool isMips32r2(const ArgList &Args) {
1333   Arg *A = Args.getLastArg(options::OPT_march_EQ,
1334                            options::OPT_mcpu_EQ);
1335
1336   return A && A->getValue() == StringRef("mips32r2");
1337 }
1338
1339 static bool isMips64r2(const ArgList &Args) {
1340   Arg *A = Args.getLastArg(options::OPT_march_EQ,
1341                            options::OPT_mcpu_EQ);
1342
1343   return A && A->getValue() == StringRef("mips64r2");
1344 }
1345
1346 static bool isMicroMips(const ArgList &Args) {
1347   Arg *A = Args.getLastArg(options::OPT_mmicromips,
1348                            options::OPT_mno_micromips);
1349   return A && A->getOption().matches(options::OPT_mmicromips);
1350 }
1351
1352 static bool isMipsFP64(const ArgList &Args) {
1353   Arg *A = Args.getLastArg(options::OPT_mfp64, options::OPT_mfp32);
1354   return A && A->getOption().matches(options::OPT_mfp64);
1355 }
1356
1357 static bool isMipsNan2008(const ArgList &Args) {
1358   Arg *A = Args.getLastArg(options::OPT_mnan_EQ);
1359   return A && A->getValue() == StringRef("2008");
1360 }
1361
1362 // FIXME: There is the same routine in the Tools.cpp.
1363 static bool hasMipsN32ABIArg(const ArgList &Args) {
1364   Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1365   return A && (A->getValue() == StringRef("n32"));
1366 }
1367
1368 static bool hasCrtBeginObj(Twine Path) {
1369   return llvm::sys::fs::exists(Path + "/crtbegin.o");
1370 }
1371
1372 static bool findTargetBiarchSuffix(std::string &Suffix, StringRef Path,
1373                                    llvm::Triple::ArchType TargetArch,
1374                                    const ArgList &Args) {
1375   // FIXME: This routine was only intended to model bi-arch toolchains which
1376   // use -m32 and -m64 to swap between variants of a target. It shouldn't be
1377   // doing ABI-based builtin location for MIPS.
1378   if (hasMipsN32ABIArg(Args))
1379     Suffix = "/n32";
1380   else if (TargetArch == llvm::Triple::x86_64 ||
1381            TargetArch == llvm::Triple::ppc64 ||
1382            TargetArch == llvm::Triple::systemz ||
1383            TargetArch == llvm::Triple::mips64 ||
1384            TargetArch == llvm::Triple::mips64el)
1385     Suffix = "/64";
1386   else
1387     Suffix = "/32";
1388
1389   return hasCrtBeginObj(Path + Suffix);
1390 }
1391
1392 void Generic_GCC::GCCInstallationDetector::findMIPSABIDirSuffix(
1393     std::string &Suffix, llvm::Triple::ArchType TargetArch, StringRef Path,
1394     const llvm::opt::ArgList &Args) {
1395   if (!isMipsArch(TargetArch))
1396     return;
1397
1398   // Some MIPS toolchains put libraries and object files compiled
1399   // using different options in to the sub-directoris which names
1400   // reflects the flags used for compilation. For example sysroot
1401   // directory might looks like the following examples:
1402   //
1403   // /usr
1404   //   /lib      <= crt*.o files compiled with '-mips32'
1405   // /mips16
1406   //   /usr
1407   //     /lib    <= crt*.o files compiled with '-mips16'
1408   //   /el
1409   //     /usr
1410   //       /lib  <= crt*.o files compiled with '-mips16 -EL'
1411   //
1412   // or
1413   //
1414   // /usr
1415   //   /lib      <= crt*.o files compiled with '-mips32r2'
1416   // /mips16
1417   //   /usr
1418   //     /lib    <= crt*.o files compiled with '-mips32r2 -mips16'
1419   // /mips32
1420   //     /usr
1421   //       /lib  <= crt*.o files compiled with '-mips32'
1422   //
1423   // Unfortunately different toolchains use different and partially
1424   // overlapped naming schemes. So we have to make a trick for detection
1425   // of using toolchain. We lookup a path which unique for each toolchains.
1426
1427   bool IsMentorToolChain = hasCrtBeginObj(Path + "/mips16/soft-float");
1428   bool IsFSFToolChain = hasCrtBeginObj(Path + "/mips32/mips16/sof");
1429
1430   if (IsMentorToolChain && IsFSFToolChain)
1431     D.Diag(diag::err_drv_unknown_toolchain);
1432
1433   if (IsMentorToolChain) {
1434     if (isMips16(Args))
1435       Suffix += "/mips16";
1436     else if (isMicroMips(Args))
1437       Suffix += "/micromips";
1438
1439     if (isSoftFloatABI(Args))
1440       Suffix += "/soft-float";
1441
1442     if (TargetArch == llvm::Triple::mipsel ||
1443         TargetArch == llvm::Triple::mips64el)
1444       Suffix += "/el";
1445   } else if (IsFSFToolChain) {
1446     if (TargetArch == llvm::Triple::mips ||
1447         TargetArch == llvm::Triple::mipsel) {
1448       if (isMicroMips(Args))
1449         Suffix += "/micromips";
1450       else if (isMips32r2(Args))
1451         Suffix += "";
1452       else
1453         Suffix += "/mips32";
1454
1455       if (isMips16(Args))
1456         Suffix += "/mips16";
1457     } else {
1458       if (isMips64r2(Args))
1459         Suffix += hasMipsN32ABIArg(Args) ? "/mips64r2" : "/mips64r2/64";
1460       else
1461         Suffix += hasMipsN32ABIArg(Args) ? "/mips64" : "/mips64/64";
1462     }
1463
1464     if (TargetArch == llvm::Triple::mipsel ||
1465         TargetArch == llvm::Triple::mips64el)
1466       Suffix += "/el";
1467
1468     if (isSoftFloatABI(Args))
1469       Suffix += "/sof";
1470     else {
1471       if (isMipsFP64(Args))
1472         Suffix += "/fp64";
1473
1474       if (isMipsNan2008(Args))
1475         Suffix += "/nan2008";
1476     }
1477   }
1478
1479   if (!hasCrtBeginObj(Path + Suffix))
1480     Suffix.clear();
1481 }
1482
1483 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
1484     llvm::Triple::ArchType TargetArch, const ArgList &Args,
1485     const std::string &LibDir, StringRef CandidateTriple,
1486     bool NeedsBiarchSuffix) {
1487   // There are various different suffixes involving the triple we
1488   // check for. We also record what is necessary to walk from each back
1489   // up to the lib directory.
1490   const std::string LibSuffixes[] = {
1491     "/gcc/" + CandidateTriple.str(),
1492     // Debian puts cross-compilers in gcc-cross
1493     "/gcc-cross/" + CandidateTriple.str(),
1494     "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
1495
1496     // The Freescale PPC SDK has the gcc libraries in
1497     // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well.
1498     "/" + CandidateTriple.str(),
1499
1500     // Ubuntu has a strange mis-matched pair of triples that this happens to
1501     // match.
1502     // FIXME: It may be worthwhile to generalize this and look for a second
1503     // triple.
1504     "/i386-linux-gnu/gcc/" + CandidateTriple.str()
1505   };
1506   const std::string InstallSuffixes[] = {
1507     "/../../..",    // gcc/
1508     "/../../..",    // gcc-cross/
1509     "/../../../..", // <triple>/gcc/
1510     "/../..",       // <triple>/
1511     "/../../../.."  // i386-linux-gnu/gcc/<triple>/
1512   };
1513   // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
1514   const unsigned NumLibSuffixes =
1515       (llvm::array_lengthof(LibSuffixes) - (TargetArch != llvm::Triple::x86));
1516   for (unsigned i = 0; i < NumLibSuffixes; ++i) {
1517     StringRef LibSuffix = LibSuffixes[i];
1518     llvm::error_code EC;
1519     for (llvm::sys::fs::directory_iterator LI(LibDir + LibSuffix, EC), LE;
1520          !EC && LI != LE; LI = LI.increment(EC)) {
1521       StringRef VersionText = llvm::sys::path::filename(LI->path());
1522       GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1523       if (CandidateVersion.Major != -1) // Filter obviously bad entries.
1524         if (!CandidateGCCInstallPaths.insert(LI->path()).second)
1525           continue; // Saw this path before; no need to look at it again.
1526       if (CandidateVersion.isOlderThan(4, 1, 1))
1527         continue;
1528       if (CandidateVersion <= Version)
1529         continue;
1530
1531       std::string MIPSABIDirSuffix;
1532       findMIPSABIDirSuffix(MIPSABIDirSuffix, TargetArch, LI->path(), Args);
1533
1534       // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1535       // in what would normally be GCCInstallPath and put the 64-bit
1536       // libs in a subdirectory named 64. The simple logic we follow is that
1537       // *if* there is a subdirectory of the right name with crtbegin.o in it,
1538       // we use that. If not, and if not a biarch triple alias, we look for
1539       // crtbegin.o without the subdirectory.
1540
1541       std::string BiarchSuffix;
1542       if (findTargetBiarchSuffix(BiarchSuffix,
1543                                  LI->path() + MIPSABIDirSuffix,
1544                                  TargetArch, Args)) {
1545         GCCBiarchSuffix = BiarchSuffix;
1546       } else if (NeedsBiarchSuffix ||
1547                  !hasCrtBeginObj(LI->path() + MIPSABIDirSuffix)) {
1548         continue;
1549       } else {
1550         GCCBiarchSuffix.clear();
1551       }
1552
1553       Version = CandidateVersion;
1554       GCCTriple.setTriple(CandidateTriple);
1555       // FIXME: We hack together the directory name here instead of
1556       // using LI to ensure stable path separators across Windows and
1557       // Linux.
1558       GCCInstallPath = LibDir + LibSuffixes[i] + "/" + VersionText.str();
1559       GCCParentLibPath = GCCInstallPath + InstallSuffixes[i];
1560       GCCMIPSABIDirSuffix = MIPSABIDirSuffix;
1561       IsValid = true;
1562     }
1563   }
1564 }
1565
1566 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple& Triple,
1567                          const ArgList &Args)
1568   : ToolChain(D, Triple, Args), GCCInstallation(getDriver(), Triple, Args) {
1569   getProgramPaths().push_back(getDriver().getInstalledDir());
1570   if (getDriver().getInstalledDir() != getDriver().Dir)
1571     getProgramPaths().push_back(getDriver().Dir);
1572 }
1573
1574 Generic_GCC::~Generic_GCC() {
1575 }
1576
1577 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
1578   switch (AC) {
1579   case Action::PreprocessJobClass:
1580     if (!Preprocess)
1581       Preprocess.reset(new tools::gcc::Preprocess(*this));
1582     return Preprocess.get();
1583   case Action::PrecompileJobClass:
1584     if (!Precompile)
1585       Precompile.reset(new tools::gcc::Precompile(*this));
1586     return Precompile.get();
1587   case Action::CompileJobClass:
1588     if (!Compile)
1589       Compile.reset(new tools::gcc::Compile(*this));
1590     return Compile.get();
1591   default:
1592     return ToolChain::getTool(AC);
1593   }
1594 }
1595
1596 Tool *Generic_GCC::buildAssembler() const {
1597   return new tools::gcc::Assemble(*this);
1598 }
1599
1600 Tool *Generic_GCC::buildLinker() const {
1601   return new tools::gcc::Link(*this);
1602 }
1603
1604 void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
1605   // Print the information about how we detected the GCC installation.
1606   GCCInstallation.print(OS);
1607 }
1608
1609 bool Generic_GCC::IsUnwindTablesDefault() const {
1610   return getArch() == llvm::Triple::x86_64;
1611 }
1612
1613 bool Generic_GCC::isPICDefault() const {
1614   return false;
1615 }
1616
1617 bool Generic_GCC::isPIEDefault() const {
1618   return false;
1619 }
1620
1621 bool Generic_GCC::isPICDefaultForced() const {
1622   return false;
1623 }
1624
1625 /// Hexagon Toolchain
1626
1627 std::string Hexagon_TC::GetGnuDir(const std::string &InstalledDir) {
1628
1629   // Locate the rest of the toolchain ...
1630   if (strlen(GCC_INSTALL_PREFIX))
1631     return std::string(GCC_INSTALL_PREFIX);
1632
1633   std::string InstallRelDir = InstalledDir + "/../../gnu";
1634   if (llvm::sys::fs::exists(InstallRelDir))
1635     return InstallRelDir;
1636
1637   std::string PrefixRelDir = std::string(LLVM_PREFIX) + "/../gnu";
1638   if (llvm::sys::fs::exists(PrefixRelDir))
1639     return PrefixRelDir;
1640
1641   return InstallRelDir;
1642 }
1643
1644 static void GetHexagonLibraryPaths(
1645   const ArgList &Args,
1646   const std::string Ver,
1647   const std::string MarchString,
1648   const std::string &InstalledDir,
1649   ToolChain::path_list *LibPaths)
1650 {
1651   bool buildingLib = Args.hasArg(options::OPT_shared);
1652
1653   //----------------------------------------------------------------------------
1654   // -L Args
1655   //----------------------------------------------------------------------------
1656   for (arg_iterator
1657          it = Args.filtered_begin(options::OPT_L),
1658          ie = Args.filtered_end();
1659        it != ie;
1660        ++it) {
1661     for (unsigned i = 0, e = (*it)->getNumValues(); i != e; ++i)
1662       LibPaths->push_back((*it)->getValue(i));
1663   }
1664
1665   //----------------------------------------------------------------------------
1666   // Other standard paths
1667   //----------------------------------------------------------------------------
1668   const std::string MarchSuffix = "/" + MarchString;
1669   const std::string G0Suffix = "/G0";
1670   const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
1671   const std::string RootDir = Hexagon_TC::GetGnuDir(InstalledDir) + "/";
1672
1673   // lib/gcc/hexagon/...
1674   std::string LibGCCHexagonDir = RootDir + "lib/gcc/hexagon/";
1675   if (buildingLib) {
1676     LibPaths->push_back(LibGCCHexagonDir + Ver + MarchG0Suffix);
1677     LibPaths->push_back(LibGCCHexagonDir + Ver + G0Suffix);
1678   }
1679   LibPaths->push_back(LibGCCHexagonDir + Ver + MarchSuffix);
1680   LibPaths->push_back(LibGCCHexagonDir + Ver);
1681
1682   // lib/gcc/...
1683   LibPaths->push_back(RootDir + "lib/gcc");
1684
1685   // hexagon/lib/...
1686   std::string HexagonLibDir = RootDir + "hexagon/lib";
1687   if (buildingLib) {
1688     LibPaths->push_back(HexagonLibDir + MarchG0Suffix);
1689     LibPaths->push_back(HexagonLibDir + G0Suffix);
1690   }
1691   LibPaths->push_back(HexagonLibDir + MarchSuffix);
1692   LibPaths->push_back(HexagonLibDir);
1693 }
1694
1695 Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple,
1696                        const ArgList &Args)
1697   : Linux(D, Triple, Args) {
1698   const std::string InstalledDir(getDriver().getInstalledDir());
1699   const std::string GnuDir = Hexagon_TC::GetGnuDir(InstalledDir);
1700
1701   // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
1702   // program paths
1703   const std::string BinDir(GnuDir + "/bin");
1704   if (llvm::sys::fs::exists(BinDir))
1705     getProgramPaths().push_back(BinDir);
1706
1707   // Determine version of GCC libraries and headers to use.
1708   const std::string HexagonDir(GnuDir + "/lib/gcc/hexagon");
1709   llvm::error_code ec;
1710   GCCVersion MaxVersion= GCCVersion::Parse("0.0.0");
1711   for (llvm::sys::fs::directory_iterator di(HexagonDir, ec), de;
1712        !ec && di != de; di = di.increment(ec)) {
1713     GCCVersion cv = GCCVersion::Parse(llvm::sys::path::filename(di->path()));
1714     if (MaxVersion < cv)
1715       MaxVersion = cv;
1716   }
1717   GCCLibAndIncVersion = MaxVersion;
1718
1719   ToolChain::path_list *LibPaths= &getFilePaths();
1720
1721   // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
1722   // 'elf' OS type, so the Linux paths are not appropriate. When we actually
1723   // support 'linux' we'll need to fix this up
1724   LibPaths->clear();
1725
1726   GetHexagonLibraryPaths(
1727     Args,
1728     GetGCCLibAndIncVersion(),
1729     GetTargetCPU(Args),
1730     InstalledDir,
1731     LibPaths);
1732 }
1733
1734 Hexagon_TC::~Hexagon_TC() {
1735 }
1736
1737 Tool *Hexagon_TC::buildAssembler() const {
1738   return new tools::hexagon::Assemble(*this);
1739 }
1740
1741 Tool *Hexagon_TC::buildLinker() const {
1742   return new tools::hexagon::Link(*this);
1743 }
1744
1745 void Hexagon_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
1746                                            ArgStringList &CC1Args) const {
1747   const Driver &D = getDriver();
1748
1749   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
1750       DriverArgs.hasArg(options::OPT_nostdlibinc))
1751     return;
1752
1753   std::string Ver(GetGCCLibAndIncVersion());
1754   std::string GnuDir = Hexagon_TC::GetGnuDir(D.InstalledDir);
1755   std::string HexagonDir(GnuDir + "/lib/gcc/hexagon/" + Ver);
1756   addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include");
1757   addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include-fixed");
1758   addExternCSystemInclude(DriverArgs, CC1Args, GnuDir + "/hexagon/include");
1759 }
1760
1761 void Hexagon_TC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1762                                               ArgStringList &CC1Args) const {
1763
1764   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1765       DriverArgs.hasArg(options::OPT_nostdincxx))
1766     return;
1767
1768   const Driver &D = getDriver();
1769   std::string Ver(GetGCCLibAndIncVersion());
1770   SmallString<128> IncludeDir(Hexagon_TC::GetGnuDir(D.InstalledDir));
1771
1772   llvm::sys::path::append(IncludeDir, "hexagon/include/c++/");
1773   llvm::sys::path::append(IncludeDir, Ver);
1774   addSystemInclude(DriverArgs, CC1Args, IncludeDir.str());
1775 }
1776
1777 ToolChain::CXXStdlibType
1778 Hexagon_TC::GetCXXStdlibType(const ArgList &Args) const {
1779   Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1780   if (!A)
1781     return ToolChain::CST_Libstdcxx;
1782
1783   StringRef Value = A->getValue();
1784   if (Value != "libstdc++") {
1785     getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1786       << A->getAsString(Args);
1787   }
1788
1789   return ToolChain::CST_Libstdcxx;
1790 }
1791
1792 static int getHexagonVersion(const ArgList &Args) {
1793   Arg *A = Args.getLastArg(options::OPT_march_EQ, options::OPT_mcpu_EQ);
1794   // Select the default CPU (v4) if none was given.
1795   if (!A)
1796     return 4;
1797
1798   // FIXME: produce errors if we cannot parse the version.
1799   StringRef WhichHexagon = A->getValue();
1800   if (WhichHexagon.startswith("hexagonv")) {
1801     int Val;
1802     if (!WhichHexagon.substr(sizeof("hexagonv") - 1).getAsInteger(10, Val))
1803       return Val;
1804   }
1805   if (WhichHexagon.startswith("v")) {
1806     int Val;
1807     if (!WhichHexagon.substr(1).getAsInteger(10, Val))
1808       return Val;
1809   }
1810
1811   // FIXME: should probably be an error.
1812   return 4;
1813 }
1814
1815 StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args)
1816 {
1817   int V = getHexagonVersion(Args);
1818   // FIXME: We don't support versions < 4. We should error on them.
1819   switch (V) {
1820   default:
1821     llvm_unreachable("Unexpected version");
1822   case 5:
1823     return "v5";
1824   case 4:
1825     return "v4";
1826   case 3:
1827     return "v3";
1828   case 2:
1829     return "v2";
1830   case 1:
1831     return "v1";
1832   }
1833 }
1834 // End Hexagon
1835
1836 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1837 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1838 /// Currently does not support anything else but compilation.
1839
1840 TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple,
1841                            const ArgList &Args)
1842   : ToolChain(D, Triple, Args) {
1843   // Path mangling to find libexec
1844   std::string Path(getDriver().Dir);
1845
1846   Path += "/../libexec";
1847   getProgramPaths().push_back(Path);
1848 }
1849
1850 TCEToolChain::~TCEToolChain() {
1851 }
1852
1853 bool TCEToolChain::IsMathErrnoDefault() const {
1854   return true;
1855 }
1856
1857 bool TCEToolChain::isPICDefault() const {
1858   return false;
1859 }
1860
1861 bool TCEToolChain::isPIEDefault() const {
1862   return false;
1863 }
1864
1865 bool TCEToolChain::isPICDefaultForced() const {
1866   return false;
1867 }
1868
1869 /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1870
1871 OpenBSD::OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1872   : Generic_ELF(D, Triple, Args) {
1873   getFilePaths().push_back(getDriver().Dir + "/../lib");
1874   getFilePaths().push_back("/usr/lib");
1875 }
1876
1877 Tool *OpenBSD::buildAssembler() const {
1878   return new tools::openbsd::Assemble(*this);
1879 }
1880
1881 Tool *OpenBSD::buildLinker() const {
1882   return new tools::openbsd::Link(*this);
1883 }
1884
1885 /// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
1886
1887 Bitrig::Bitrig(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1888   : Generic_ELF(D, Triple, Args) {
1889   getFilePaths().push_back(getDriver().Dir + "/../lib");
1890   getFilePaths().push_back("/usr/lib");
1891 }
1892
1893 Tool *Bitrig::buildAssembler() const {
1894   return new tools::bitrig::Assemble(*this);
1895 }
1896
1897 Tool *Bitrig::buildLinker() const {
1898   return new tools::bitrig::Link(*this);
1899 }
1900
1901 void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1902                                           ArgStringList &CC1Args) const {
1903   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1904       DriverArgs.hasArg(options::OPT_nostdincxx))
1905     return;
1906
1907   switch (GetCXXStdlibType(DriverArgs)) {
1908   case ToolChain::CST_Libcxx:
1909     addSystemInclude(DriverArgs, CC1Args,
1910                      getDriver().SysRoot + "/usr/include/c++/");
1911     break;
1912   case ToolChain::CST_Libstdcxx:
1913     addSystemInclude(DriverArgs, CC1Args,
1914                      getDriver().SysRoot + "/usr/include/c++/stdc++");
1915     addSystemInclude(DriverArgs, CC1Args,
1916                      getDriver().SysRoot + "/usr/include/c++/stdc++/backward");
1917
1918     StringRef Triple = getTriple().str();
1919     if (Triple.startswith("amd64"))
1920       addSystemInclude(DriverArgs, CC1Args,
1921                        getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" +
1922                        Triple.substr(5));
1923     else
1924       addSystemInclude(DriverArgs, CC1Args,
1925                        getDriver().SysRoot + "/usr/include/c++/stdc++/" +
1926                        Triple);
1927     break;
1928   }
1929 }
1930
1931 void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
1932                                  ArgStringList &CmdArgs) const {
1933   switch (GetCXXStdlibType(Args)) {
1934   case ToolChain::CST_Libcxx:
1935     CmdArgs.push_back("-lc++");
1936     CmdArgs.push_back("-lcxxrt");
1937     // Include supc++ to provide Unwind until provided by libcxx.
1938     CmdArgs.push_back("-lgcc");
1939     break;
1940   case ToolChain::CST_Libstdcxx:
1941     CmdArgs.push_back("-lstdc++");
1942     break;
1943   }
1944 }
1945
1946 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1947
1948 FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1949   : Generic_ELF(D, Triple, Args) {
1950
1951   // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
1952   // back to '/usr/lib' if it doesn't exist.
1953   if ((Triple.getArch() == llvm::Triple::x86 ||
1954        Triple.getArch() == llvm::Triple::ppc) &&
1955       llvm::sys::fs::exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
1956     getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
1957   else
1958     getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
1959 }
1960
1961 ToolChain::CXXStdlibType
1962 FreeBSD::GetCXXStdlibType(const ArgList &Args) const {
1963   if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
1964     StringRef Value = A->getValue();
1965     if (Value == "libstdc++")
1966       return ToolChain::CST_Libstdcxx;
1967     if (Value == "libc++")
1968       return ToolChain::CST_Libcxx;
1969
1970     getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1971       << A->getAsString(Args);
1972   }
1973   if (getTriple().getOSMajorVersion() >= 10)
1974     return ToolChain::CST_Libcxx;
1975   return ToolChain::CST_Libstdcxx;
1976 }
1977
1978 void FreeBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1979                                            ArgStringList &CC1Args) const {
1980   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1981       DriverArgs.hasArg(options::OPT_nostdincxx))
1982     return;
1983
1984   switch (GetCXXStdlibType(DriverArgs)) {
1985   case ToolChain::CST_Libcxx:
1986     addSystemInclude(DriverArgs, CC1Args,
1987                      getDriver().SysRoot + "/usr/include/c++/v1");
1988     break;
1989   case ToolChain::CST_Libstdcxx:
1990     addSystemInclude(DriverArgs, CC1Args,
1991                      getDriver().SysRoot + "/usr/include/c++/4.2");
1992     addSystemInclude(DriverArgs, CC1Args,
1993                      getDriver().SysRoot + "/usr/include/c++/4.2/backward");
1994     break;
1995   }
1996 }
1997
1998 Tool *FreeBSD::buildAssembler() const {
1999   return new tools::freebsd::Assemble(*this);
2000 }
2001
2002 Tool *FreeBSD::buildLinker() const {
2003   return new tools::freebsd::Link(*this);
2004 }
2005
2006 bool FreeBSD::UseSjLjExceptions() const {
2007   // FreeBSD uses SjLj exceptions on ARM oabi.
2008   switch (getTriple().getEnvironment()) {
2009   case llvm::Triple::GNUEABI:
2010   case llvm::Triple::EABI:
2011     return false;
2012
2013   default:
2014     return (getTriple().getArch() == llvm::Triple::arm ||
2015             getTriple().getArch() == llvm::Triple::thumb);
2016   }
2017 }
2018
2019 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
2020
2021 NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2022   : Generic_ELF(D, Triple, Args) {
2023
2024   if (getDriver().UseStdLib) {
2025     // When targeting a 32-bit platform, try the special directory used on
2026     // 64-bit hosts, and only fall back to the main library directory if that
2027     // doesn't work.
2028     // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
2029     // what all logic is needed to emulate the '=' prefix here.
2030     if (Triple.getArch() == llvm::Triple::x86)
2031       getFilePaths().push_back("=/usr/lib/i386");
2032
2033     getFilePaths().push_back("=/usr/lib");
2034   }
2035 }
2036
2037 Tool *NetBSD::buildAssembler() const {
2038   return new tools::netbsd::Assemble(*this);
2039 }
2040
2041 Tool *NetBSD::buildLinker() const {
2042   return new tools::netbsd::Link(*this);
2043 }
2044
2045 ToolChain::CXXStdlibType
2046 NetBSD::GetCXXStdlibType(const ArgList &Args) const {
2047   if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2048     StringRef Value = A->getValue();
2049     if (Value == "libstdc++")
2050       return ToolChain::CST_Libstdcxx;
2051     if (Value == "libc++")
2052       return ToolChain::CST_Libcxx;
2053
2054     getDriver().Diag(diag::err_drv_invalid_stdlib_name)
2055       << A->getAsString(Args);
2056   }
2057
2058   unsigned Major, Minor, Micro;
2059   getTriple().getOSVersion(Major, Minor, Micro);
2060   if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
2061     if (getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64)
2062       return ToolChain::CST_Libcxx;
2063   }
2064   return ToolChain::CST_Libstdcxx;
2065 }
2066
2067 void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2068                                           ArgStringList &CC1Args) const {
2069   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2070       DriverArgs.hasArg(options::OPT_nostdincxx))
2071     return;
2072
2073   switch (GetCXXStdlibType(DriverArgs)) {
2074   case ToolChain::CST_Libcxx:
2075     addSystemInclude(DriverArgs, CC1Args,
2076                      getDriver().SysRoot + "/usr/include/c++/");
2077     break;
2078   case ToolChain::CST_Libstdcxx:
2079     addSystemInclude(DriverArgs, CC1Args,
2080                      getDriver().SysRoot + "/usr/include/g++");
2081     addSystemInclude(DriverArgs, CC1Args,
2082                      getDriver().SysRoot + "/usr/include/g++/backward");
2083     break;
2084   }
2085 }
2086
2087 /// Minix - Minix tool chain which can call as(1) and ld(1) directly.
2088
2089 Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2090   : Generic_ELF(D, Triple, Args) {
2091   getFilePaths().push_back(getDriver().Dir + "/../lib");
2092   getFilePaths().push_back("/usr/lib");
2093 }
2094
2095 Tool *Minix::buildAssembler() const {
2096   return new tools::minix::Assemble(*this);
2097 }
2098
2099 Tool *Minix::buildLinker() const {
2100   return new tools::minix::Link(*this);
2101 }
2102
2103 /// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
2104
2105 AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple,
2106                    const ArgList &Args)
2107   : Generic_GCC(D, Triple, Args) {
2108
2109   getProgramPaths().push_back(getDriver().getInstalledDir());
2110   if (getDriver().getInstalledDir() != getDriver().Dir)
2111     getProgramPaths().push_back(getDriver().Dir);
2112
2113   getFilePaths().push_back(getDriver().Dir + "/../lib");
2114   getFilePaths().push_back("/usr/lib");
2115   getFilePaths().push_back("/usr/sfw/lib");
2116   getFilePaths().push_back("/opt/gcc4/lib");
2117   getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
2118
2119 }
2120
2121 Tool *AuroraUX::buildAssembler() const {
2122   return new tools::auroraux::Assemble(*this);
2123 }
2124
2125 Tool *AuroraUX::buildLinker() const {
2126   return new tools::auroraux::Link(*this);
2127 }
2128
2129 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
2130
2131 Solaris::Solaris(const Driver &D, const llvm::Triple& Triple,
2132                  const ArgList &Args)
2133   : Generic_GCC(D, Triple, Args) {
2134
2135   getProgramPaths().push_back(getDriver().getInstalledDir());
2136   if (getDriver().getInstalledDir() != getDriver().Dir)
2137     getProgramPaths().push_back(getDriver().Dir);
2138
2139   getFilePaths().push_back(getDriver().Dir + "/../lib");
2140   getFilePaths().push_back("/usr/lib");
2141 }
2142
2143 Tool *Solaris::buildAssembler() const {
2144   return new tools::solaris::Assemble(*this);
2145 }
2146
2147 Tool *Solaris::buildLinker() const {
2148   return new tools::solaris::Link(*this);
2149 }
2150
2151 /// Distribution (very bare-bones at the moment).
2152
2153 enum Distro {
2154   ArchLinux,
2155   DebianLenny,
2156   DebianSqueeze,
2157   DebianWheezy,
2158   DebianJessie,
2159   Exherbo,
2160   RHEL4,
2161   RHEL5,
2162   RHEL6,
2163   Fedora,
2164   OpenSUSE,
2165   UbuntuHardy,
2166   UbuntuIntrepid,
2167   UbuntuJaunty,
2168   UbuntuKarmic,
2169   UbuntuLucid,
2170   UbuntuMaverick,
2171   UbuntuNatty,
2172   UbuntuOneiric,
2173   UbuntuPrecise,
2174   UbuntuQuantal,
2175   UbuntuRaring,
2176   UbuntuSaucy,
2177   UbuntuTrusty,
2178   UnknownDistro
2179 };
2180
2181 static bool IsRedhat(enum Distro Distro) {
2182   return Distro == Fedora || (Distro >= RHEL4 && Distro <= RHEL6);
2183 }
2184
2185 static bool IsOpenSUSE(enum Distro Distro) {
2186   return Distro == OpenSUSE;
2187 }
2188
2189 static bool IsDebian(enum Distro Distro) {
2190   return Distro >= DebianLenny && Distro <= DebianJessie;
2191 }
2192
2193 static bool IsUbuntu(enum Distro Distro) {
2194   return Distro >= UbuntuHardy && Distro <= UbuntuTrusty;
2195 }
2196
2197 static Distro DetectDistro(llvm::Triple::ArchType Arch) {
2198   OwningPtr<llvm::MemoryBuffer> File;
2199   if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
2200     StringRef Data = File.get()->getBuffer();
2201     SmallVector<StringRef, 8> Lines;
2202     Data.split(Lines, "\n");
2203     Distro Version = UnknownDistro;
2204     for (unsigned i = 0, s = Lines.size(); i != s; ++i)
2205       if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME="))
2206         Version = llvm::StringSwitch<Distro>(Lines[i].substr(17))
2207           .Case("hardy", UbuntuHardy)
2208           .Case("intrepid", UbuntuIntrepid)
2209           .Case("jaunty", UbuntuJaunty)
2210           .Case("karmic", UbuntuKarmic)
2211           .Case("lucid", UbuntuLucid)
2212           .Case("maverick", UbuntuMaverick)
2213           .Case("natty", UbuntuNatty)
2214           .Case("oneiric", UbuntuOneiric)
2215           .Case("precise", UbuntuPrecise)
2216           .Case("quantal", UbuntuQuantal)
2217           .Case("raring", UbuntuRaring)
2218           .Case("saucy", UbuntuSaucy)
2219           .Case("trusty", UbuntuTrusty)
2220           .Default(UnknownDistro);
2221     return Version;
2222   }
2223
2224   if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
2225     StringRef Data = File.get()->getBuffer();
2226     if (Data.startswith("Fedora release"))
2227       return Fedora;
2228     else if (Data.startswith("Red Hat Enterprise Linux") &&
2229              Data.find("release 6") != StringRef::npos)
2230       return RHEL6;
2231     else if ((Data.startswith("Red Hat Enterprise Linux") ||
2232               Data.startswith("CentOS")) &&
2233              Data.find("release 5") != StringRef::npos)
2234       return RHEL5;
2235     else if ((Data.startswith("Red Hat Enterprise Linux") ||
2236               Data.startswith("CentOS")) &&
2237              Data.find("release 4") != StringRef::npos)
2238       return RHEL4;
2239     return UnknownDistro;
2240   }
2241
2242   if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
2243     StringRef Data = File.get()->getBuffer();
2244     if (Data[0] == '5')
2245       return DebianLenny;
2246     else if (Data.startswith("squeeze/sid") || Data[0] == '6')
2247       return DebianSqueeze;
2248     else if (Data.startswith("wheezy/sid")  || Data[0] == '7')
2249       return DebianWheezy;
2250     else if (Data.startswith("jessie/sid")  || Data[0] == '8')
2251       return DebianJessie;
2252     return UnknownDistro;
2253   }
2254
2255   if (llvm::sys::fs::exists("/etc/SuSE-release"))
2256     return OpenSUSE;
2257
2258   if (llvm::sys::fs::exists("/etc/exherbo-release"))
2259     return Exherbo;
2260
2261   if (llvm::sys::fs::exists("/etc/arch-release"))
2262     return ArchLinux;
2263
2264   return UnknownDistro;
2265 }
2266
2267 /// \brief Get our best guess at the multiarch triple for a target.
2268 ///
2269 /// Debian-based systems are starting to use a multiarch setup where they use
2270 /// a target-triple directory in the library and header search paths.
2271 /// Unfortunately, this triple does not align with the vanilla target triple,
2272 /// so we provide a rough mapping here.
2273 static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
2274                                       StringRef SysRoot) {
2275   // For most architectures, just use whatever we have rather than trying to be
2276   // clever.
2277   switch (TargetTriple.getArch()) {
2278   default:
2279     return TargetTriple.str();
2280
2281     // We use the existence of '/lib/<triple>' as a directory to detect some
2282     // common linux triples that don't quite match the Clang triple for both
2283     // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
2284     // regardless of what the actual target triple is.
2285   case llvm::Triple::arm:
2286   case llvm::Triple::thumb:
2287     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2288       if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabihf"))
2289         return "arm-linux-gnueabihf";
2290     } else {
2291       if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabi"))
2292         return "arm-linux-gnueabi";
2293     }
2294     return TargetTriple.str();
2295   case llvm::Triple::x86:
2296     if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
2297       return "i386-linux-gnu";
2298     return TargetTriple.str();
2299   case llvm::Triple::x86_64:
2300     if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
2301       return "x86_64-linux-gnu";
2302     return TargetTriple.str();
2303   case llvm::Triple::aarch64:
2304     if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64-linux-gnu"))
2305       return "aarch64-linux-gnu";
2306     return TargetTriple.str();
2307   case llvm::Triple::mips:
2308     if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu"))
2309       return "mips-linux-gnu";
2310     return TargetTriple.str();
2311   case llvm::Triple::mipsel:
2312     if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu"))
2313       return "mipsel-linux-gnu";
2314     return TargetTriple.str();
2315   case llvm::Triple::ppc:
2316     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
2317       return "powerpc-linux-gnuspe";
2318     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu"))
2319       return "powerpc-linux-gnu";
2320     return TargetTriple.str();
2321   case llvm::Triple::ppc64:
2322     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu"))
2323       return "powerpc64-linux-gnu";
2324   case llvm::Triple::ppc64le:
2325     if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64le-linux-gnu"))
2326       return "powerpc64le-linux-gnu";
2327     return TargetTriple.str();
2328   }
2329 }
2330
2331 static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) {
2332   if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str());
2333 }
2334
2335 static StringRef getMultilibDir(const llvm::Triple &Triple,
2336                                 const ArgList &Args) {
2337   if (isMipsArch(Triple.getArch())) {
2338     // lib32 directory has a special meaning on MIPS targets.
2339     // It contains N32 ABI binaries. Use this folder if produce
2340     // code for N32 ABI only.
2341     if (hasMipsN32ABIArg(Args))
2342       return "lib32";
2343     return Triple.isArch32Bit() ? "lib" : "lib64";
2344   }
2345
2346   // It happens that only x86 and PPC use the 'lib32' variant of multilib, and
2347   // using that variant while targeting other architectures causes problems
2348   // because the libraries are laid out in shared system roots that can't cope
2349   // with a 'lib32' multilib search path being considered. So we only enable
2350   // them when we know we may need it.
2351   //
2352   // FIXME: This is a bit of a hack. We should really unify this code for
2353   // reasoning about multilib spellings with the lib dir spellings in the
2354   // GCCInstallationDetector, but that is a more significant refactoring.
2355   if (Triple.getArch() == llvm::Triple::x86 ||
2356       Triple.getArch() == llvm::Triple::ppc)
2357     return "lib32";
2358
2359   return Triple.isArch32Bit() ? "lib" : "lib64";
2360 }
2361
2362 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2363   : Generic_ELF(D, Triple, Args) {
2364   llvm::Triple::ArchType Arch = Triple.getArch();
2365   std::string SysRoot = computeSysRoot();
2366
2367   // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
2368   // least) put various tools in a triple-prefixed directory off of the parent
2369   // of the GCC installation. We use the GCC triple here to ensure that we end
2370   // up with tools that support the same amount of cross compiling as the
2371   // detected GCC installation. For example, if we find a GCC installation
2372   // targeting x86_64, but it is a bi-arch GCC installation, it can also be
2373   // used to target i386.
2374   // FIXME: This seems unlikely to be Linux-specific.
2375   ToolChain::path_list &PPaths = getProgramPaths();
2376   PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
2377                          GCCInstallation.getTriple().str() + "/bin").str());
2378
2379   Linker = GetProgramPath("ld");
2380
2381   Distro Distro = DetectDistro(Arch);
2382
2383   if (IsOpenSUSE(Distro) || IsUbuntu(Distro)) {
2384     ExtraOpts.push_back("-z");
2385     ExtraOpts.push_back("relro");
2386   }
2387
2388   if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
2389     ExtraOpts.push_back("-X");
2390
2391   const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::Android;
2392   const bool IsMips = isMipsArch(Arch);
2393
2394   if (IsMips && !SysRoot.empty())
2395     ExtraOpts.push_back("--sysroot=" + SysRoot);
2396
2397   // Do not use 'gnu' hash style for Mips targets because .gnu.hash
2398   // and the MIPS ABI require .dynsym to be sorted in different ways.
2399   // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
2400   // ABI requires a mapping between the GOT and the symbol table.
2401   // Android loader does not support .gnu.hash.
2402   if (!IsMips && !IsAndroid) {
2403     if (IsRedhat(Distro) || IsOpenSUSE(Distro) ||
2404         (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
2405       ExtraOpts.push_back("--hash-style=gnu");
2406
2407     if (IsDebian(Distro) || IsOpenSUSE(Distro) || Distro == UbuntuLucid ||
2408         Distro == UbuntuJaunty || Distro == UbuntuKarmic)
2409       ExtraOpts.push_back("--hash-style=both");
2410   }
2411
2412   if (IsRedhat(Distro))
2413     ExtraOpts.push_back("--no-add-needed");
2414
2415   if (Distro == DebianSqueeze || Distro == DebianWheezy ||
2416       Distro == DebianJessie || IsOpenSUSE(Distro) ||
2417       (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
2418       (IsUbuntu(Distro) && Distro >= UbuntuKarmic))
2419     ExtraOpts.push_back("--build-id");
2420
2421   if (IsOpenSUSE(Distro))
2422     ExtraOpts.push_back("--enable-new-dtags");
2423
2424   // The selection of paths to try here is designed to match the patterns which
2425   // the GCC driver itself uses, as this is part of the GCC-compatible driver.
2426   // This was determined by running GCC in a fake filesystem, creating all
2427   // possible permutations of these directories, and seeing which ones it added
2428   // to the link paths.
2429   path_list &Paths = getFilePaths();
2430
2431   const std::string Multilib = getMultilibDir(Triple, Args);
2432   const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
2433
2434   // Add the multilib suffixed paths where they are available.
2435   if (GCCInstallation.isValid()) {
2436     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2437     const std::string &LibPath = GCCInstallation.getParentLibPath();
2438
2439     // Sourcery CodeBench MIPS toolchain holds some libraries under
2440     // a biarch-like suffix of the GCC installation.
2441     //
2442     // FIXME: It would be cleaner to model this as a variant of bi-arch. IE,
2443     // instead of a '64' biarch suffix it would be 'el' or something.
2444     if (IsAndroid && IsMips && isMips32r2(Args)) {
2445       assert(GCCInstallation.getBiarchSuffix().empty() &&
2446              "Unexpected bi-arch suffix");
2447       addPathIfExists(GCCInstallation.getInstallPath() + "/mips-r2", Paths);
2448     } else {
2449       addPathIfExists((GCCInstallation.getInstallPath() +
2450                        GCCInstallation.getMIPSABIDirSuffix() +
2451                        GCCInstallation.getBiarchSuffix()),
2452                       Paths);
2453     }
2454
2455     // GCC cross compiling toolchains will install target libraries which ship
2456     // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
2457     // any part of the GCC installation in
2458     // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
2459     // debatable, but is the reality today. We need to search this tree even
2460     // when we have a sysroot somewhere else. It is the responsibility of
2461     // whomever is doing the cross build targetting a sysroot using a GCC
2462     // installation that is *not* within the system root to ensure two things:
2463     //
2464     //  1) Any DSOs that are linked in from this tree or from the install path
2465     //     above must be preasant on the system root and found via an
2466     //     appropriate rpath.
2467     //  2) There must not be libraries installed into
2468     //     <prefix>/<triple>/<libdir> unless they should be preferred over
2469     //     those within the system root.
2470     //
2471     // Note that this matches the GCC behavior. See the below comment for where
2472     // Clang diverges from GCC's behavior.
2473     addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + Multilib +
2474                     GCCInstallation.getMIPSABIDirSuffix(),
2475                     Paths);
2476
2477     // If the GCC installation we found is inside of the sysroot, we want to
2478     // prefer libraries installed in the parent prefix of the GCC installation.
2479     // It is important to *not* use these paths when the GCC installation is
2480     // outside of the system root as that can pick up unintended libraries.
2481     // This usually happens when there is an external cross compiler on the
2482     // host system, and a more minimal sysroot available that is the target of
2483     // the cross. Note that GCC does include some of these directories in some
2484     // configurations but this seems somewhere between questionable and simply
2485     // a bug.
2486     if (StringRef(LibPath).startswith(SysRoot)) {
2487       addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
2488       addPathIfExists(LibPath + "/../" + Multilib, Paths);
2489     }
2490   }
2491   addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
2492   addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
2493   addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
2494   addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
2495
2496   // Try walking via the GCC triple path in case of biarch or multiarch GCC
2497   // installations with strange symlinks.
2498   if (GCCInstallation.isValid()) {
2499     addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
2500                     "/../../" + Multilib, Paths);
2501
2502     // Add the non-multilib suffixed paths (if potentially different).
2503     const std::string &LibPath = GCCInstallation.getParentLibPath();
2504     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2505     if (!GCCInstallation.getBiarchSuffix().empty())
2506       addPathIfExists(GCCInstallation.getInstallPath() +
2507                       GCCInstallation.getMIPSABIDirSuffix(), Paths);
2508
2509     // See comments above on the multilib variant for details of why this is
2510     // included even from outside the sysroot.
2511     addPathIfExists(LibPath + "/../" + GCCTriple.str() +
2512                     "/lib" + GCCInstallation.getMIPSABIDirSuffix(), Paths);
2513
2514     // See comments above on the multilib variant for details of why this is
2515     // only included from within the sysroot.
2516     if (StringRef(LibPath).startswith(SysRoot))
2517       addPathIfExists(LibPath, Paths);
2518   }
2519   addPathIfExists(SysRoot + "/lib", Paths);
2520   addPathIfExists(SysRoot + "/usr/lib", Paths);
2521 }
2522
2523 bool FreeBSD::HasNativeLLVMSupport() const {
2524   return true;
2525 }
2526
2527 bool Linux::HasNativeLLVMSupport() const {
2528   return true;
2529 }
2530
2531 Tool *Linux::buildLinker() const {
2532   return new tools::gnutools::Link(*this);
2533 }
2534
2535 Tool *Linux::buildAssembler() const {
2536   return new tools::gnutools::Assemble(*this);
2537 }
2538
2539 void Linux::addClangTargetOptions(const ArgList &DriverArgs,
2540                                   ArgStringList &CC1Args) const {
2541   const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2542   bool UseInitArrayDefault =
2543       !V.isOlderThan(4, 7, 0) ||
2544       getTriple().getArch() == llvm::Triple::aarch64 ||
2545       getTriple().getEnvironment() == llvm::Triple::Android;
2546   if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2547                          options::OPT_fno_use_init_array,
2548                          UseInitArrayDefault))
2549     CC1Args.push_back("-fuse-init-array");
2550 }
2551
2552 std::string Linux::computeSysRoot() const {
2553   if (!getDriver().SysRoot.empty())
2554     return getDriver().SysRoot;
2555
2556   if (!GCCInstallation.isValid() || !isMipsArch(getTriple().getArch()))
2557     return std::string();
2558
2559   // Standalone MIPS toolchains use different names for sysroot folder
2560   // and put it into different places. Here we try to check some known
2561   // variants.
2562
2563   const StringRef InstallDir = GCCInstallation.getInstallPath();
2564   const StringRef TripleStr = GCCInstallation.getTriple().str();
2565   const StringRef MIPSABIDirSuffix = GCCInstallation.getMIPSABIDirSuffix();
2566
2567   std::string Path = (InstallDir + "/../../../../" + TripleStr + "/libc" +
2568                       MIPSABIDirSuffix).str();
2569
2570   if (llvm::sys::fs::exists(Path))
2571     return Path;
2572
2573   Path = (InstallDir + "/../../../../sysroot" + MIPSABIDirSuffix).str();
2574
2575   if (llvm::sys::fs::exists(Path))
2576     return Path;
2577
2578   return std::string();
2579 }
2580
2581 void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2582                                       ArgStringList &CC1Args) const {
2583   const Driver &D = getDriver();
2584   std::string SysRoot = computeSysRoot();
2585
2586   if (DriverArgs.hasArg(options::OPT_nostdinc))
2587     return;
2588
2589   if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
2590     addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
2591
2592   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2593     SmallString<128> P(D.ResourceDir);
2594     llvm::sys::path::append(P, "include");
2595     addSystemInclude(DriverArgs, CC1Args, P.str());
2596   }
2597
2598   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2599     return;
2600
2601   // Check for configure-time C include directories.
2602   StringRef CIncludeDirs(C_INCLUDE_DIRS);
2603   if (CIncludeDirs != "") {
2604     SmallVector<StringRef, 5> dirs;
2605     CIncludeDirs.split(dirs, ":");
2606     for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
2607          I != E; ++I) {
2608       StringRef Prefix = llvm::sys::path::is_absolute(*I) ? SysRoot : "";
2609       addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
2610     }
2611     return;
2612   }
2613
2614   // Lacking those, try to detect the correct set of system includes for the
2615   // target triple.
2616
2617   // Sourcery CodeBench and modern FSF Mips toolchains put extern C
2618   // system includes under three additional directories.
2619   if (GCCInstallation.isValid() && isMipsArch(getTriple().getArch())) {
2620     addExternCSystemIncludeIfExists(
2621         DriverArgs, CC1Args, GCCInstallation.getInstallPath() + "/include");
2622
2623     addExternCSystemIncludeIfExists(
2624         DriverArgs, CC1Args,
2625         GCCInstallation.getInstallPath() + "/../../../../" +
2626             GCCInstallation.getTriple().str() + "/libc/usr/include");
2627
2628     addExternCSystemIncludeIfExists(
2629         DriverArgs, CC1Args,
2630         GCCInstallation.getInstallPath() + "/../../../../sysroot/usr/include");
2631   }
2632
2633   // Implement generic Debian multiarch support.
2634   const StringRef X86_64MultiarchIncludeDirs[] = {
2635     "/usr/include/x86_64-linux-gnu",
2636
2637     // FIXME: These are older forms of multiarch. It's not clear that they're
2638     // in use in any released version of Debian, so we should consider
2639     // removing them.
2640     "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"
2641   };
2642   const StringRef X86MultiarchIncludeDirs[] = {
2643     "/usr/include/i386-linux-gnu",
2644
2645     // FIXME: These are older forms of multiarch. It's not clear that they're
2646     // in use in any released version of Debian, so we should consider
2647     // removing them.
2648     "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",
2649     "/usr/include/i486-linux-gnu"
2650   };
2651   const StringRef AArch64MultiarchIncludeDirs[] = {
2652     "/usr/include/aarch64-linux-gnu"
2653   };
2654   const StringRef ARMMultiarchIncludeDirs[] = {
2655     "/usr/include/arm-linux-gnueabi"
2656   };
2657   const StringRef ARMHFMultiarchIncludeDirs[] = {
2658     "/usr/include/arm-linux-gnueabihf"
2659   };
2660   const StringRef MIPSMultiarchIncludeDirs[] = {
2661     "/usr/include/mips-linux-gnu"
2662   };
2663   const StringRef MIPSELMultiarchIncludeDirs[] = {
2664     "/usr/include/mipsel-linux-gnu"
2665   };
2666   const StringRef PPCMultiarchIncludeDirs[] = {
2667     "/usr/include/powerpc-linux-gnu"
2668   };
2669   const StringRef PPC64MultiarchIncludeDirs[] = {
2670     "/usr/include/powerpc64-linux-gnu"
2671   };
2672   ArrayRef<StringRef> MultiarchIncludeDirs;
2673   if (getTriple().getArch() == llvm::Triple::x86_64) {
2674     MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
2675   } else if (getTriple().getArch() == llvm::Triple::x86) {
2676     MultiarchIncludeDirs = X86MultiarchIncludeDirs;
2677   } else if (getTriple().getArch() == llvm::Triple::aarch64) {
2678     MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
2679   } else if (getTriple().getArch() == llvm::Triple::arm) {
2680     if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
2681       MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
2682     else
2683       MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
2684   } else if (getTriple().getArch() == llvm::Triple::mips) {
2685     MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
2686   } else if (getTriple().getArch() == llvm::Triple::mipsel) {
2687     MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
2688   } else if (getTriple().getArch() == llvm::Triple::ppc) {
2689     MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
2690   } else if (getTriple().getArch() == llvm::Triple::ppc64) {
2691     MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
2692   }
2693   for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(),
2694                                      E = MultiarchIncludeDirs.end();
2695        I != E; ++I) {
2696     if (llvm::sys::fs::exists(SysRoot + *I)) {
2697       addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + *I);
2698       break;
2699     }
2700   }
2701
2702   if (getTriple().getOS() == llvm::Triple::RTEMS)
2703     return;
2704
2705   // Add an include of '/include' directly. This isn't provided by default by
2706   // system GCCs, but is often used with cross-compiling GCCs, and harmless to
2707   // add even when Clang is acting as-if it were a system compiler.
2708   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
2709
2710   addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
2711 }
2712
2713 /// \brief Helper to add the three variant paths for a libstdc++ installation.
2714 /*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
2715                                                 const ArgList &DriverArgs,
2716                                                 ArgStringList &CC1Args) {
2717   if (!llvm::sys::fs::exists(Base))
2718     return false;
2719   addSystemInclude(DriverArgs, CC1Args, Base);
2720   addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir);
2721   addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
2722   return true;
2723 }
2724
2725 /// \brief Helper to add an extra variant path for an (Ubuntu) multilib
2726 /// libstdc++ installation.
2727 /*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
2728                                                 Twine TargetArchDir,
2729                                                 Twine BiarchSuffix,
2730                                                 Twine MIPSABIDirSuffix,
2731                                                 const ArgList &DriverArgs,
2732                                                 ArgStringList &CC1Args) {
2733   if (!addLibStdCXXIncludePaths(Base + Suffix,
2734                                 TargetArchDir + MIPSABIDirSuffix + BiarchSuffix,
2735                                 DriverArgs, CC1Args))
2736     return false;
2737
2738   addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir + Suffix
2739                    + MIPSABIDirSuffix + BiarchSuffix);
2740   return true;
2741 }
2742
2743 void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2744                                          ArgStringList &CC1Args) const {
2745   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2746       DriverArgs.hasArg(options::OPT_nostdincxx))
2747     return;
2748
2749   // Check if libc++ has been enabled and provide its include paths if so.
2750   if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
2751     // libc++ is always installed at a fixed path on Linux currently.
2752     addSystemInclude(DriverArgs, CC1Args,
2753                      getDriver().SysRoot + "/usr/include/c++/v1");
2754     return;
2755   }
2756
2757   // We need a detected GCC installation on Linux to provide libstdc++'s
2758   // headers. We handled the libc++ case above.
2759   if (!GCCInstallation.isValid())
2760     return;
2761
2762   // By default, look for the C++ headers in an include directory adjacent to
2763   // the lib directory of the GCC installation. Note that this is expect to be
2764   // equivalent to '/usr/include/c++/X.Y' in almost all cases.
2765   StringRef LibDir = GCCInstallation.getParentLibPath();
2766   StringRef InstallDir = GCCInstallation.getInstallPath();
2767   StringRef TripleStr = GCCInstallation.getTriple().str();
2768   StringRef MIPSABIDirSuffix = GCCInstallation.getMIPSABIDirSuffix();
2769   StringRef BiarchSuffix = GCCInstallation.getBiarchSuffix();
2770   const GCCVersion &Version = GCCInstallation.getVersion();
2771
2772   if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
2773                                "/c++/" + Version.Text, TripleStr, BiarchSuffix,
2774                                MIPSABIDirSuffix, DriverArgs, CC1Args))
2775     return;
2776
2777   const std::string IncludePathCandidates[] = {
2778     // Gentoo is weird and places its headers inside the GCC install, so if the
2779     // first attempt to find the headers fails, try these patterns.
2780     InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
2781         Version.MinorStr,
2782     InstallDir.str() + "/include/g++-v" + Version.MajorStr,
2783     // Android standalone toolchain has C++ headers in yet another place.
2784     LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
2785     // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
2786     // without a subdirectory corresponding to the gcc version.
2787     LibDir.str() + "/../include/c++",
2788   };
2789
2790   for (unsigned i = 0; i < llvm::array_lengthof(IncludePathCandidates); ++i) {
2791     if (addLibStdCXXIncludePaths(IncludePathCandidates[i],
2792                                  TripleStr + MIPSABIDirSuffix + BiarchSuffix,
2793                                  DriverArgs, CC1Args))
2794       break;
2795   }
2796 }
2797
2798 bool Linux::isPIEDefault() const {
2799   return getSanitizerArgs().hasZeroBaseShadow();
2800 }
2801
2802 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2803
2804 DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2805   : Generic_ELF(D, Triple, Args) {
2806
2807   // Path mangling to find libexec
2808   getProgramPaths().push_back(getDriver().getInstalledDir());
2809   if (getDriver().getInstalledDir() != getDriver().Dir)
2810     getProgramPaths().push_back(getDriver().Dir);
2811
2812   getFilePaths().push_back(getDriver().Dir + "/../lib");
2813   getFilePaths().push_back("/usr/lib");
2814   if (llvm::sys::fs::exists("/usr/lib/gcc47"))
2815     getFilePaths().push_back("/usr/lib/gcc47");
2816   else
2817     getFilePaths().push_back("/usr/lib/gcc44");
2818 }
2819
2820 Tool *DragonFly::buildAssembler() const {
2821   return new tools::dragonfly::Assemble(*this);
2822 }
2823
2824 Tool *DragonFly::buildLinker() const {
2825   return new tools::dragonfly::Link(*this);
2826 }
2827
2828
2829 /// XCore tool chain
2830 XCore::XCore(const Driver &D, const llvm::Triple &Triple,
2831              const ArgList &Args) : ToolChain(D, Triple, Args) {
2832   // ProgramPaths are found via 'PATH' environment variable.
2833 }
2834
2835 Tool *XCore::buildAssembler() const {
2836   return new tools::XCore::Assemble(*this);
2837 }
2838
2839 Tool *XCore::buildLinker() const {
2840   return new tools::XCore::Link(*this);
2841 }
2842
2843 bool XCore::isPICDefault() const {
2844   return false;
2845 }
2846
2847 bool XCore::isPIEDefault() const {
2848   return false;
2849 }
2850
2851 bool XCore::isPICDefaultForced() const {
2852   return false;
2853 }
2854
2855 bool XCore::SupportsProfiling() const {
2856   return false;
2857 }
2858
2859 bool XCore::hasBlocksRuntime() const {
2860   return false;
2861 }
2862
2863
2864 void XCore::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2865                                       ArgStringList &CC1Args) const {
2866   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2867       DriverArgs.hasArg(options::OPT_nostdlibinc))
2868     return;
2869   if (const char *cl_include_dir = getenv("XCC_C_INCLUDE_PATH")) {
2870     SmallVector<StringRef, 4> Dirs;
2871     const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,'\0'};
2872     StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
2873     ArrayRef<StringRef> DirVec(Dirs);
2874     addSystemIncludes(DriverArgs, CC1Args, DirVec);
2875   }
2876 }
2877
2878 void XCore::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
2879                                      llvm::opt::ArgStringList &CC1Args) const {
2880   CC1Args.push_back("-nostdsysteminc");
2881 }
2882
2883 void XCore::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2884                                          ArgStringList &CC1Args) const {
2885   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2886       DriverArgs.hasArg(options::OPT_nostdlibinc))
2887     return;
2888   if (const char *cl_include_dir = getenv("XCC_CPLUS_INCLUDE_PATH")) {
2889     SmallVector<StringRef, 4> Dirs;
2890     const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,'\0'};
2891     StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
2892     ArrayRef<StringRef> DirVec(Dirs);
2893     addSystemIncludes(DriverArgs, CC1Args, DirVec);
2894   }
2895 }
2896
2897 void XCore::AddCXXStdlibLibArgs(const ArgList &Args,
2898                                 ArgStringList &CmdArgs) const {
2899   // We don't output any lib args. This is handled by xcc.
2900 }