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