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