ToolChains.cpp revision 69ca5e263feb5d231a81bbd28f96bca6a630bd50 
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-a8", "cortex-r4", "cortex-a9", "cortex-a15", "armv7")
128    .Case("cortex-a9-mp", "armv7f")
129    .Case("cortex-m3", "armv7m")
130    .Case("cortex-m4", "armv7em")
131    .Case("swift", "armv7s")
132    .Default(0);
133}
134
135StringRef Darwin::getDarwinArchName(const ArgList &Args) const {
136  switch (getTriple().getArch()) {
137  default:
138    return getArchName();
139
140  case llvm::Triple::thumb:
141  case llvm::Triple::arm: {
142    if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
143      if (const char *Arch = GetArmArchForMArch(A->getValue()))
144        return Arch;
145
146    if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
147      if (const char *Arch = GetArmArchForMCpu(A->getValue()))
148        return Arch;
149
150    return "arm";
151  }
152  }
153}
154
155Darwin::~Darwin() {
156}
157
158std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
159                                                types::ID InputType) const {
160  llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
161
162  // If the target isn't initialized (e.g., an unknown Darwin platform, return
163  // the default triple).
164  if (!isTargetInitialized())
165    return Triple.getTriple();
166
167  SmallString<16> Str;
168  Str += isTargetIPhoneOS() ? "ios" : "macosx";
169  Str += getTargetVersion().getAsString();
170  Triple.setOSName(Str);
171
172  return Triple.getTriple();
173}
174
175void Generic_ELF::anchor() {}
176
177Tool *Darwin::getTool(Action::ActionClass AC) const {
178  switch (AC) {
179  case Action::LipoJobClass:
180    if (!Lipo)
181      Lipo.reset(new tools::darwin::Lipo(*this));
182    return Lipo.get();
183  case Action::DsymutilJobClass:
184    if (!Dsymutil)
185      Dsymutil.reset(new tools::darwin::Dsymutil(*this));
186    return Dsymutil.get();
187  case Action::VerifyJobClass:
188    if (!VerifyDebug)
189      VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
190    return VerifyDebug.get();
191  default:
192    return ToolChain::getTool(AC);
193  }
194}
195
196Tool *Darwin::buildLinker() const {
197  return new tools::darwin::Link(*this);
198}
199
200Tool *Darwin::buildAssembler() const {
201  return new tools::darwin::Assemble(*this);
202}
203
204DarwinClang::DarwinClang(const Driver &D, const llvm::Triple& Triple,
205                         const ArgList &Args)
206  : Darwin(D, Triple, Args)
207{
208  getProgramPaths().push_back(getDriver().getInstalledDir());
209  if (getDriver().getInstalledDir() != getDriver().Dir)
210    getProgramPaths().push_back(getDriver().Dir);
211
212  // We expect 'as', 'ld', etc. to be adjacent to our install dir.
213  getProgramPaths().push_back(getDriver().getInstalledDir());
214  if (getDriver().getInstalledDir() != getDriver().Dir)
215    getProgramPaths().push_back(getDriver().Dir);
216}
217
218void DarwinClang::AddLinkARCArgs(const ArgList &Args,
219                                 ArgStringList &CmdArgs) const {
220
221  CmdArgs.push_back("-force_load");
222  SmallString<128> P(getDriver().ClangExecutable);
223  llvm::sys::path::remove_filename(P); // 'clang'
224  llvm::sys::path::remove_filename(P); // 'bin'
225  llvm::sys::path::append(P, "lib", "arc", "libarclite_");
226  // Mash in the platform.
227  if (isTargetIOSSimulator())
228    P += "iphonesimulator";
229  else if (isTargetIPhoneOS())
230    P += "iphoneos";
231  else
232    P += "macosx";
233  P += ".a";
234
235  CmdArgs.push_back(Args.MakeArgString(P));
236}
237
238void DarwinClang::AddLinkRuntimeLib(const ArgList &Args,
239                                    ArgStringList &CmdArgs,
240                                    const char *DarwinStaticLib,
241                                    bool AlwaysLink) const {
242  SmallString<128> P(getDriver().ResourceDir);
243  llvm::sys::path::append(P, "lib", "darwin", DarwinStaticLib);
244
245  // For now, allow missing resource libraries to support developers who may
246  // not have compiler-rt checked out or integrated into their build (unless
247  // we explicitly force linking with this library).
248  if (AlwaysLink || llvm::sys::fs::exists(P.str()))
249    CmdArgs.push_back(Args.MakeArgString(P.str()));
250}
251
252void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
253                                        ArgStringList &CmdArgs) const {
254  // Darwin only supports the compiler-rt based runtime libraries.
255  switch (GetRuntimeLibType(Args)) {
256  case ToolChain::RLT_CompilerRT:
257    break;
258  default:
259    getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
260      << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "darwin";
261    return;
262  }
263
264  // Darwin doesn't support real static executables, don't link any runtime
265  // libraries with -static.
266  if (Args.hasArg(options::OPT_static) ||
267      Args.hasArg(options::OPT_fapple_kext) ||
268      Args.hasArg(options::OPT_mkernel))
269    return;
270
271  // Reject -static-libgcc for now, we can deal with this when and if someone
272  // cares. This is useful in situations where someone wants to statically link
273  // something like libstdc++, and needs its runtime support routines.
274  if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
275    getDriver().Diag(diag::err_drv_unsupported_opt)
276      << A->getAsString(Args);
277    return;
278  }
279
280  // If we are building profile support, link that library in.
281  if (Args.hasArg(options::OPT_fprofile_arcs) ||
282      Args.hasArg(options::OPT_fprofile_generate) ||
283      Args.hasArg(options::OPT_fcreate_profile) ||
284      Args.hasArg(options::OPT_coverage)) {
285    // Select the appropriate runtime library for the target.
286    if (isTargetIPhoneOS()) {
287      AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_ios.a");
288    } else {
289      AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_osx.a");
290    }
291  }
292
293  const SanitizerArgs &Sanitize = getDriver().getOrParseSanitizerArgs(Args);
294
295  // Add Ubsan runtime library, if required.
296  if (Sanitize.needsUbsanRt()) {
297    if (isTargetIPhoneOS()) {
298      getDriver().Diag(diag::err_drv_clang_unsupported_per_platform)
299        << "-fsanitize=undefined";
300    } else {
301      AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ubsan_osx.a", true);
302
303      // The Ubsan runtime library requires C++.
304      AddCXXStdlibLibArgs(Args, CmdArgs);
305    }
306  }
307
308  // Add ASAN runtime library, if required. Dynamic libraries and bundles
309  // should not be linked with the runtime library.
310  if (Sanitize.needsAsanRt()) {
311    if (isTargetIPhoneOS() && !isTargetIOSSimulator()) {
312      getDriver().Diag(diag::err_drv_clang_unsupported_per_platform)
313        << "-fsanitize=address";
314    } else {
315      if (Args.hasArg(options::OPT_dynamiclib) ||
316          Args.hasArg(options::OPT_bundle)) {
317        // Assume the binary will provide the ASan runtime.
318      } else {
319        AddLinkRuntimeLib(Args, CmdArgs,
320                          "libclang_rt.asan_osx_dynamic.dylib", true);
321        // The ASAN runtime library requires C++.
322        AddCXXStdlibLibArgs(Args, CmdArgs);
323      }
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 isMicroMips(const ArgList &Args) {
1298  Arg *A = Args.getLastArg(options::OPT_mmicromips,
1299                           options::OPT_mno_micromips);
1300  return A && A->getOption().matches(options::OPT_mmicromips);
1301}
1302
1303// FIXME: There is the same routine in the Tools.cpp.
1304static bool hasMipsN32ABIArg(const ArgList &Args) {
1305  Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1306  return A && (A->getValue() == StringRef("n32"));
1307}
1308
1309static void appendMipsTargetSuffix(std::string &Path,
1310                                   llvm::Triple::ArchType TargetArch,
1311                                   const ArgList &Args) {
1312  if (isMips16(Args))
1313    Path += "/mips16";
1314  else if (isMicroMips(Args))
1315    Path += "/micromips";
1316
1317  if (isSoftFloatABI(Args))
1318    Path += "/soft-float";
1319
1320  if (TargetArch == llvm::Triple::mipsel ||
1321      TargetArch == llvm::Triple::mips64el)
1322    Path += "/el";
1323}
1324
1325static StringRef getMipsTargetABISuffix(llvm::Triple::ArchType TargetArch,
1326                                        const ArgList &Args) {
1327  if (TargetArch == llvm::Triple::mips64 ||
1328      TargetArch == llvm::Triple::mips64el)
1329    return hasMipsN32ABIArg(Args) ? "/n32" : "/64";
1330
1331  return "/32";
1332}
1333
1334static bool findTargetBiarchSuffix(std::string &Suffix, StringRef Path,
1335                                   llvm::Triple::ArchType TargetArch,
1336                                   const ArgList &Args) {
1337  // FIXME: This routine was only intended to model bi-arch toolchains which
1338  // use -m32 and -m64 to swap between variants of a target. It shouldn't be
1339  // doing ABI-based builtin location for MIPS.
1340  if (isMipsArch(TargetArch)) {
1341    StringRef ABISuffix = getMipsTargetABISuffix(TargetArch, Args);
1342
1343    // First build and check a complex path to crtbegin.o
1344    // depends on command line options (-mips16, -msoft-float, ...)
1345    // like mips-linux-gnu/4.7/mips16/soft-float/el/crtbegin.o
1346    appendMipsTargetSuffix(Suffix, TargetArch, Args);
1347
1348    if (TargetArch == llvm::Triple::mips64 ||
1349        TargetArch == llvm::Triple::mips64el)
1350      Suffix += ABISuffix;
1351
1352    if (llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o"))
1353      return true;
1354
1355    // Then fall back and probe a simple case like
1356    // mips-linux-gnu/4.7/32/crtbegin.o
1357    Suffix = ABISuffix;
1358    return llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o");
1359  }
1360
1361  if (TargetArch == llvm::Triple::x86_64 ||
1362      TargetArch == llvm::Triple::ppc64 ||
1363      TargetArch == llvm::Triple::systemz)
1364    Suffix = "/64";
1365  else
1366    Suffix = "/32";
1367
1368  return llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o");
1369}
1370
1371void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
1372    llvm::Triple::ArchType TargetArch, const ArgList &Args,
1373    const std::string &LibDir, StringRef CandidateTriple,
1374    bool NeedsBiarchSuffix) {
1375  // There are various different suffixes involving the triple we
1376  // check for. We also record what is necessary to walk from each back
1377  // up to the lib directory.
1378  const std::string LibSuffixes[] = {
1379    "/gcc/" + CandidateTriple.str(),
1380    // Debian puts cross-compilers in gcc-cross
1381    "/gcc-cross/" + CandidateTriple.str(),
1382    "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
1383
1384    // The Freescale PPC SDK has the gcc libraries in
1385    // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well.
1386    "/" + CandidateTriple.str(),
1387
1388    // Ubuntu has a strange mis-matched pair of triples that this happens to
1389    // match.
1390    // FIXME: It may be worthwhile to generalize this and look for a second
1391    // triple.
1392    "/i386-linux-gnu/gcc/" + CandidateTriple.str()
1393  };
1394  const std::string InstallSuffixes[] = {
1395    "/../../..",    // gcc/
1396    "/../../..",    // gcc-cross/
1397    "/../../../..", // <triple>/gcc/
1398    "/../..",       // <triple>/
1399    "/../../../.."  // i386-linux-gnu/gcc/<triple>/
1400  };
1401  // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
1402  const unsigned NumLibSuffixes =
1403      (llvm::array_lengthof(LibSuffixes) - (TargetArch != llvm::Triple::x86));
1404  for (unsigned i = 0; i < NumLibSuffixes; ++i) {
1405    StringRef LibSuffix = LibSuffixes[i];
1406    llvm::error_code EC;
1407    for (llvm::sys::fs::directory_iterator LI(LibDir + LibSuffix, EC), LE;
1408         !EC && LI != LE; LI = LI.increment(EC)) {
1409      StringRef VersionText = llvm::sys::path::filename(LI->path());
1410      GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1411      if (CandidateVersion.Major != -1) // Filter obviously bad entries.
1412        if (!CandidateGCCInstallPaths.insert(LI->path()).second)
1413          continue; // Saw this path before; no need to look at it again.
1414      if (CandidateVersion.isOlderThan(4, 1, 1))
1415        continue;
1416      if (CandidateVersion <= Version)
1417        continue;
1418
1419      // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1420      // in what would normally be GCCInstallPath and put the 64-bit
1421      // libs in a subdirectory named 64. The simple logic we follow is that
1422      // *if* there is a subdirectory of the right name with crtbegin.o in it,
1423      // we use that. If not, and if not a biarch triple alias, we look for
1424      // crtbegin.o without the subdirectory.
1425
1426      std::string BiarchSuffix;
1427      if (findTargetBiarchSuffix(BiarchSuffix, LI->path(), TargetArch, Args)) {
1428        GCCBiarchSuffix = BiarchSuffix;
1429      } else {
1430        if (NeedsBiarchSuffix ||
1431            !llvm::sys::fs::exists(LI->path() + "/crtbegin.o"))
1432          continue;
1433        GCCBiarchSuffix.clear();
1434      }
1435
1436      Version = CandidateVersion;
1437      GCCTriple.setTriple(CandidateTriple);
1438      // FIXME: We hack together the directory name here instead of
1439      // using LI to ensure stable path separators across Windows and
1440      // Linux.
1441      GCCInstallPath = LibDir + LibSuffixes[i] + "/" + VersionText.str();
1442      GCCParentLibPath = GCCInstallPath + InstallSuffixes[i];
1443      IsValid = true;
1444    }
1445  }
1446}
1447
1448Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple& Triple,
1449                         const ArgList &Args)
1450  : ToolChain(D, Triple, Args), GCCInstallation(getDriver(), Triple, Args) {
1451  getProgramPaths().push_back(getDriver().getInstalledDir());
1452  if (getDriver().getInstalledDir() != getDriver().Dir)
1453    getProgramPaths().push_back(getDriver().Dir);
1454}
1455
1456Generic_GCC::~Generic_GCC() {
1457}
1458
1459Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
1460  switch (AC) {
1461  case Action::PreprocessJobClass:
1462    if (!Preprocess)
1463      Preprocess.reset(new tools::gcc::Preprocess(*this));
1464    return Preprocess.get();
1465  case Action::PrecompileJobClass:
1466    if (!Precompile)
1467      Precompile.reset(new tools::gcc::Precompile(*this));
1468    return Precompile.get();
1469  case Action::CompileJobClass:
1470    if (!Compile)
1471      Compile.reset(new tools::gcc::Compile(*this));
1472    return Compile.get();
1473  default:
1474    return ToolChain::getTool(AC);
1475  }
1476}
1477
1478Tool *Generic_GCC::buildAssembler() const {
1479  return new tools::gcc::Assemble(*this);
1480}
1481
1482Tool *Generic_GCC::buildLinker() const {
1483  return new tools::gcc::Link(*this);
1484}
1485
1486void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
1487  // Print the information about how we detected the GCC installation.
1488  GCCInstallation.print(OS);
1489}
1490
1491bool Generic_GCC::IsUnwindTablesDefault() const {
1492  return getArch() == llvm::Triple::x86_64;
1493}
1494
1495bool Generic_GCC::isPICDefault() const {
1496  return false;
1497}
1498
1499bool Generic_GCC::isPIEDefault() const {
1500  return false;
1501}
1502
1503bool Generic_GCC::isPICDefaultForced() const {
1504  return false;
1505}
1506
1507/// Hexagon Toolchain
1508
1509std::string Hexagon_TC::GetGnuDir(const std::string &InstalledDir) {
1510
1511  // Locate the rest of the toolchain ...
1512  if (strlen(GCC_INSTALL_PREFIX))
1513    return std::string(GCC_INSTALL_PREFIX);
1514
1515  std::string InstallRelDir = InstalledDir + "/../../gnu";
1516  if (llvm::sys::fs::exists(InstallRelDir))
1517    return InstallRelDir;
1518
1519  std::string PrefixRelDir = std::string(LLVM_PREFIX) + "/../gnu";
1520  if (llvm::sys::fs::exists(PrefixRelDir))
1521    return PrefixRelDir;
1522
1523  return InstallRelDir;
1524}
1525
1526static void GetHexagonLibraryPaths(
1527  const ArgList &Args,
1528  const std::string Ver,
1529  const std::string MarchString,
1530  const std::string &InstalledDir,
1531  ToolChain::path_list *LibPaths)
1532{
1533  bool buildingLib = Args.hasArg(options::OPT_shared);
1534
1535  //----------------------------------------------------------------------------
1536  // -L Args
1537  //----------------------------------------------------------------------------
1538  for (arg_iterator
1539         it = Args.filtered_begin(options::OPT_L),
1540         ie = Args.filtered_end();
1541       it != ie;
1542       ++it) {
1543    for (unsigned i = 0, e = (*it)->getNumValues(); i != e; ++i)
1544      LibPaths->push_back((*it)->getValue(i));
1545  }
1546
1547  //----------------------------------------------------------------------------
1548  // Other standard paths
1549  //----------------------------------------------------------------------------
1550  const std::string MarchSuffix = "/" + MarchString;
1551  const std::string G0Suffix = "/G0";
1552  const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
1553  const std::string RootDir = Hexagon_TC::GetGnuDir(InstalledDir) + "/";
1554
1555  // lib/gcc/hexagon/...
1556  std::string LibGCCHexagonDir = RootDir + "lib/gcc/hexagon/";
1557  if (buildingLib) {
1558    LibPaths->push_back(LibGCCHexagonDir + Ver + MarchG0Suffix);
1559    LibPaths->push_back(LibGCCHexagonDir + Ver + G0Suffix);
1560  }
1561  LibPaths->push_back(LibGCCHexagonDir + Ver + MarchSuffix);
1562  LibPaths->push_back(LibGCCHexagonDir + Ver);
1563
1564  // lib/gcc/...
1565  LibPaths->push_back(RootDir + "lib/gcc");
1566
1567  // hexagon/lib/...
1568  std::string HexagonLibDir = RootDir + "hexagon/lib";
1569  if (buildingLib) {
1570    LibPaths->push_back(HexagonLibDir + MarchG0Suffix);
1571    LibPaths->push_back(HexagonLibDir + G0Suffix);
1572  }
1573  LibPaths->push_back(HexagonLibDir + MarchSuffix);
1574  LibPaths->push_back(HexagonLibDir);
1575}
1576
1577Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple,
1578                       const ArgList &Args)
1579  : Linux(D, Triple, Args) {
1580  const std::string InstalledDir(getDriver().getInstalledDir());
1581  const std::string GnuDir = Hexagon_TC::GetGnuDir(InstalledDir);
1582
1583  // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
1584  // program paths
1585  const std::string BinDir(GnuDir + "/bin");
1586  if (llvm::sys::fs::exists(BinDir))
1587    getProgramPaths().push_back(BinDir);
1588
1589  // Determine version of GCC libraries and headers to use.
1590  const std::string HexagonDir(GnuDir + "/lib/gcc/hexagon");
1591  llvm::error_code ec;
1592  GCCVersion MaxVersion= GCCVersion::Parse("0.0.0");
1593  for (llvm::sys::fs::directory_iterator di(HexagonDir, ec), de;
1594       !ec && di != de; di = di.increment(ec)) {
1595    GCCVersion cv = GCCVersion::Parse(llvm::sys::path::filename(di->path()));
1596    if (MaxVersion < cv)
1597      MaxVersion = cv;
1598  }
1599  GCCLibAndIncVersion = MaxVersion;
1600
1601  ToolChain::path_list *LibPaths= &getFilePaths();
1602
1603  // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
1604  // 'elf' OS type, so the Linux paths are not appropriate. When we actually
1605  // support 'linux' we'll need to fix this up
1606  LibPaths->clear();
1607
1608  GetHexagonLibraryPaths(
1609    Args,
1610    GetGCCLibAndIncVersion(),
1611    GetTargetCPU(Args),
1612    InstalledDir,
1613    LibPaths);
1614}
1615
1616Hexagon_TC::~Hexagon_TC() {
1617}
1618
1619Tool *Hexagon_TC::buildAssembler() const {
1620  return new tools::hexagon::Assemble(*this);
1621}
1622
1623Tool *Hexagon_TC::buildLinker() const {
1624  return new tools::hexagon::Link(*this);
1625}
1626
1627void Hexagon_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
1628                                           ArgStringList &CC1Args) const {
1629  const Driver &D = getDriver();
1630
1631  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
1632      DriverArgs.hasArg(options::OPT_nostdlibinc))
1633    return;
1634
1635  std::string Ver(GetGCCLibAndIncVersion());
1636  std::string GnuDir = Hexagon_TC::GetGnuDir(D.InstalledDir);
1637  std::string HexagonDir(GnuDir + "/lib/gcc/hexagon/" + Ver);
1638  addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include");
1639  addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include-fixed");
1640  addExternCSystemInclude(DriverArgs, CC1Args, GnuDir + "/hexagon/include");
1641}
1642
1643void Hexagon_TC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1644                                              ArgStringList &CC1Args) const {
1645
1646  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1647      DriverArgs.hasArg(options::OPT_nostdincxx))
1648    return;
1649
1650  const Driver &D = getDriver();
1651  std::string Ver(GetGCCLibAndIncVersion());
1652  SmallString<128> IncludeDir(Hexagon_TC::GetGnuDir(D.InstalledDir));
1653
1654  llvm::sys::path::append(IncludeDir, "hexagon/include/c++/");
1655  llvm::sys::path::append(IncludeDir, Ver);
1656  addSystemInclude(DriverArgs, CC1Args, IncludeDir.str());
1657}
1658
1659ToolChain::CXXStdlibType
1660Hexagon_TC::GetCXXStdlibType(const ArgList &Args) const {
1661  Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1662  if (!A)
1663    return ToolChain::CST_Libstdcxx;
1664
1665  StringRef Value = A->getValue();
1666  if (Value != "libstdc++") {
1667    getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1668      << A->getAsString(Args);
1669  }
1670
1671  return ToolChain::CST_Libstdcxx;
1672}
1673
1674static Arg *GetLastHexagonArchArg(const ArgList &Args)
1675{
1676  Arg *A = NULL;
1677
1678  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
1679       it != ie; ++it) {
1680    if ((*it)->getOption().matches(options::OPT_march_EQ) ||
1681        (*it)->getOption().matches(options::OPT_mcpu_EQ)) {
1682      A = *it;
1683      A->claim();
1684    } else if ((*it)->getOption().matches(options::OPT_m_Joined)) {
1685      StringRef Value = (*it)->getValue(0);
1686      if (Value.startswith("v")) {
1687        A = *it;
1688        A->claim();
1689      }
1690    }
1691  }
1692  return A;
1693}
1694
1695StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args)
1696{
1697  // Select the default CPU (v4) if none was given or detection failed.
1698  Arg *A = GetLastHexagonArchArg (Args);
1699  if (A) {
1700    StringRef WhichHexagon = A->getValue();
1701    if (WhichHexagon.startswith("hexagon"))
1702      return WhichHexagon.substr(sizeof("hexagon") - 1);
1703    if (WhichHexagon != "")
1704      return WhichHexagon;
1705  }
1706
1707  return "v4";
1708}
1709// End Hexagon
1710
1711/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1712/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1713/// Currently does not support anything else but compilation.
1714
1715TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple,
1716                           const ArgList &Args)
1717  : ToolChain(D, Triple, Args) {
1718  // Path mangling to find libexec
1719  std::string Path(getDriver().Dir);
1720
1721  Path += "/../libexec";
1722  getProgramPaths().push_back(Path);
1723}
1724
1725TCEToolChain::~TCEToolChain() {
1726}
1727
1728bool TCEToolChain::IsMathErrnoDefault() const {
1729  return true;
1730}
1731
1732bool TCEToolChain::isPICDefault() const {
1733  return false;
1734}
1735
1736bool TCEToolChain::isPIEDefault() const {
1737  return false;
1738}
1739
1740bool TCEToolChain::isPICDefaultForced() const {
1741  return false;
1742}
1743
1744/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1745
1746OpenBSD::OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1747  : Generic_ELF(D, Triple, Args) {
1748  getFilePaths().push_back(getDriver().Dir + "/../lib");
1749  getFilePaths().push_back("/usr/lib");
1750}
1751
1752Tool *OpenBSD::buildAssembler() const {
1753  return new tools::openbsd::Assemble(*this);
1754}
1755
1756Tool *OpenBSD::buildLinker() const {
1757  return new tools::openbsd::Link(*this);
1758}
1759
1760/// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
1761
1762Bitrig::Bitrig(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1763  : Generic_ELF(D, Triple, Args) {
1764  getFilePaths().push_back(getDriver().Dir + "/../lib");
1765  getFilePaths().push_back("/usr/lib");
1766}
1767
1768Tool *Bitrig::buildAssembler() const {
1769  return new tools::bitrig::Assemble(*this);
1770}
1771
1772Tool *Bitrig::buildLinker() const {
1773  return new tools::bitrig::Link(*this);
1774}
1775
1776void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1777                                          ArgStringList &CC1Args) const {
1778  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1779      DriverArgs.hasArg(options::OPT_nostdincxx))
1780    return;
1781
1782  switch (GetCXXStdlibType(DriverArgs)) {
1783  case ToolChain::CST_Libcxx:
1784    addSystemInclude(DriverArgs, CC1Args,
1785                     getDriver().SysRoot + "/usr/include/c++/");
1786    break;
1787  case ToolChain::CST_Libstdcxx:
1788    addSystemInclude(DriverArgs, CC1Args,
1789                     getDriver().SysRoot + "/usr/include/c++/stdc++");
1790    addSystemInclude(DriverArgs, CC1Args,
1791                     getDriver().SysRoot + "/usr/include/c++/stdc++/backward");
1792
1793    StringRef Triple = getTriple().str();
1794    if (Triple.startswith("amd64"))
1795      addSystemInclude(DriverArgs, CC1Args,
1796                       getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" +
1797                       Triple.substr(5));
1798    else
1799      addSystemInclude(DriverArgs, CC1Args,
1800                       getDriver().SysRoot + "/usr/include/c++/stdc++/" +
1801                       Triple);
1802    break;
1803  }
1804}
1805
1806void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
1807                                 ArgStringList &CmdArgs) const {
1808  switch (GetCXXStdlibType(Args)) {
1809  case ToolChain::CST_Libcxx:
1810    CmdArgs.push_back("-lc++");
1811    CmdArgs.push_back("-lcxxrt");
1812    // Include supc++ to provide Unwind until provided by libcxx.
1813    CmdArgs.push_back("-lgcc");
1814    break;
1815  case ToolChain::CST_Libstdcxx:
1816    CmdArgs.push_back("-lstdc++");
1817    break;
1818  }
1819}
1820
1821/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1822
1823FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1824  : Generic_ELF(D, Triple, Args) {
1825
1826  // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
1827  // back to '/usr/lib' if it doesn't exist.
1828  if ((Triple.getArch() == llvm::Triple::x86 ||
1829       Triple.getArch() == llvm::Triple::ppc) &&
1830      llvm::sys::fs::exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
1831    getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
1832  else
1833    getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
1834}
1835
1836Tool *FreeBSD::buildAssembler() const {
1837  return new tools::freebsd::Assemble(*this);
1838}
1839
1840Tool *FreeBSD::buildLinker() const {
1841  return new tools::freebsd::Link(*this);
1842}
1843
1844bool FreeBSD::UseSjLjExceptions() const {
1845  // FreeBSD uses SjLj exceptions on ARM oabi.
1846  switch (getTriple().getEnvironment()) {
1847  case llvm::Triple::GNUEABI:
1848  case llvm::Triple::EABI:
1849    return false;
1850
1851  default:
1852    return (getTriple().getArch() == llvm::Triple::arm ||
1853            getTriple().getArch() == llvm::Triple::thumb);
1854  }
1855}
1856
1857/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
1858
1859NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1860  : Generic_ELF(D, Triple, Args) {
1861
1862  if (getDriver().UseStdLib) {
1863    // When targeting a 32-bit platform, try the special directory used on
1864    // 64-bit hosts, and only fall back to the main library directory if that
1865    // doesn't work.
1866    // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
1867    // what all logic is needed to emulate the '=' prefix here.
1868    if (Triple.getArch() == llvm::Triple::x86)
1869      getFilePaths().push_back("=/usr/lib/i386");
1870
1871    getFilePaths().push_back("=/usr/lib");
1872  }
1873}
1874
1875Tool *NetBSD::buildAssembler() const {
1876  return new tools::netbsd::Assemble(*this);
1877}
1878
1879Tool *NetBSD::buildLinker() const {
1880  return new tools::netbsd::Link(*this);
1881}
1882
1883ToolChain::CXXStdlibType
1884NetBSD::GetCXXStdlibType(const ArgList &Args) const {
1885  if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
1886    StringRef Value = A->getValue();
1887    if (Value == "libstdc++")
1888      return ToolChain::CST_Libstdcxx;
1889    if (Value == "libc++")
1890      return ToolChain::CST_Libcxx;
1891
1892    getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1893      << A->getAsString(Args);
1894  }
1895
1896  return ToolChain::CST_Libstdcxx;
1897}
1898
1899void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1900                                          ArgStringList &CC1Args) const {
1901  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1902      DriverArgs.hasArg(options::OPT_nostdincxx))
1903    return;
1904
1905  switch (GetCXXStdlibType(DriverArgs)) {
1906  case ToolChain::CST_Libcxx:
1907    addSystemInclude(DriverArgs, CC1Args,
1908                     getDriver().SysRoot + "/usr/include/c++/");
1909    break;
1910  case ToolChain::CST_Libstdcxx:
1911    addSystemInclude(DriverArgs, CC1Args,
1912                     getDriver().SysRoot + "/usr/include/g++");
1913    addSystemInclude(DriverArgs, CC1Args,
1914                     getDriver().SysRoot + "/usr/include/g++/backward");
1915    break;
1916  }
1917}
1918
1919/// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1920
1921Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1922  : Generic_ELF(D, Triple, Args) {
1923  getFilePaths().push_back(getDriver().Dir + "/../lib");
1924  getFilePaths().push_back("/usr/lib");
1925}
1926
1927Tool *Minix::buildAssembler() const {
1928  return new tools::minix::Assemble(*this);
1929}
1930
1931Tool *Minix::buildLinker() const {
1932  return new tools::minix::Link(*this);
1933}
1934
1935/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1936
1937AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple,
1938                   const ArgList &Args)
1939  : Generic_GCC(D, Triple, Args) {
1940
1941  getProgramPaths().push_back(getDriver().getInstalledDir());
1942  if (getDriver().getInstalledDir() != getDriver().Dir)
1943    getProgramPaths().push_back(getDriver().Dir);
1944
1945  getFilePaths().push_back(getDriver().Dir + "/../lib");
1946  getFilePaths().push_back("/usr/lib");
1947  getFilePaths().push_back("/usr/sfw/lib");
1948  getFilePaths().push_back("/opt/gcc4/lib");
1949  getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
1950
1951}
1952
1953Tool *AuroraUX::buildAssembler() const {
1954  return new tools::auroraux::Assemble(*this);
1955}
1956
1957Tool *AuroraUX::buildLinker() const {
1958  return new tools::auroraux::Link(*this);
1959}
1960
1961/// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
1962
1963Solaris::Solaris(const Driver &D, const llvm::Triple& Triple,
1964                 const ArgList &Args)
1965  : Generic_GCC(D, Triple, Args) {
1966
1967  getProgramPaths().push_back(getDriver().getInstalledDir());
1968  if (getDriver().getInstalledDir() != getDriver().Dir)
1969    getProgramPaths().push_back(getDriver().Dir);
1970
1971  getFilePaths().push_back(getDriver().Dir + "/../lib");
1972  getFilePaths().push_back("/usr/lib");
1973}
1974
1975Tool *Solaris::buildAssembler() const {
1976  return new tools::solaris::Assemble(*this);
1977}
1978
1979Tool *Solaris::buildLinker() const {
1980  return new tools::solaris::Link(*this);
1981}
1982
1983/// Distribution (very bare-bones at the moment).
1984
1985enum Distro {
1986  ArchLinux,
1987  DebianLenny,
1988  DebianSqueeze,
1989  DebianWheezy,
1990  DebianJessie,
1991  Exherbo,
1992  RHEL4,
1993  RHEL5,
1994  RHEL6,
1995  Fedora13,
1996  Fedora14,
1997  Fedora15,
1998  Fedora16,
1999  FedoraRawhide,
2000  OpenSUSE,
2001  UbuntuHardy,
2002  UbuntuIntrepid,
2003  UbuntuJaunty,
2004  UbuntuKarmic,
2005  UbuntuLucid,
2006  UbuntuMaverick,
2007  UbuntuNatty,
2008  UbuntuOneiric,
2009  UbuntuPrecise,
2010  UbuntuQuantal,
2011  UbuntuRaring,
2012  UbuntuSaucy,
2013  UnknownDistro
2014};
2015
2016static bool IsRedhat(enum Distro Distro) {
2017  return (Distro >= Fedora13 && Distro <= FedoraRawhide) ||
2018         (Distro >= RHEL4    && Distro <= RHEL6);
2019}
2020
2021static bool IsOpenSUSE(enum Distro Distro) {
2022  return Distro == OpenSUSE;
2023}
2024
2025static bool IsDebian(enum Distro Distro) {
2026  return Distro >= DebianLenny && Distro <= DebianJessie;
2027}
2028
2029static bool IsUbuntu(enum Distro Distro) {
2030  return Distro >= UbuntuHardy && Distro <= UbuntuSaucy;
2031}
2032
2033static Distro DetectDistro(llvm::Triple::ArchType Arch) {
2034  OwningPtr<llvm::MemoryBuffer> File;
2035  if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
2036    StringRef Data = File.get()->getBuffer();
2037    SmallVector<StringRef, 8> Lines;
2038    Data.split(Lines, "\n");
2039    Distro Version = UnknownDistro;
2040    for (unsigned i = 0, s = Lines.size(); i != s; ++i)
2041      if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME="))
2042        Version = llvm::StringSwitch<Distro>(Lines[i].substr(17))
2043          .Case("hardy", UbuntuHardy)
2044          .Case("intrepid", UbuntuIntrepid)
2045          .Case("jaunty", UbuntuJaunty)
2046          .Case("karmic", UbuntuKarmic)
2047          .Case("lucid", UbuntuLucid)
2048          .Case("maverick", UbuntuMaverick)
2049          .Case("natty", UbuntuNatty)
2050          .Case("oneiric", UbuntuOneiric)
2051          .Case("precise", UbuntuPrecise)
2052          .Case("quantal", UbuntuQuantal)
2053          .Case("raring", UbuntuRaring)
2054          .Case("saucy", UbuntuSaucy)
2055          .Default(UnknownDistro);
2056    return Version;
2057  }
2058
2059  if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
2060    StringRef Data = File.get()->getBuffer();
2061    if (Data.startswith("Fedora release 16"))
2062      return Fedora16;
2063    else if (Data.startswith("Fedora release 15"))
2064      return Fedora15;
2065    else if (Data.startswith("Fedora release 14"))
2066      return Fedora14;
2067    else if (Data.startswith("Fedora release 13"))
2068      return Fedora13;
2069    else if (Data.startswith("Fedora release") &&
2070             Data.find("Rawhide") != StringRef::npos)
2071      return FedoraRawhide;
2072    else if (Data.startswith("Red Hat Enterprise Linux") &&
2073             Data.find("release 6") != StringRef::npos)
2074      return RHEL6;
2075    else if ((Data.startswith("Red Hat Enterprise Linux") ||
2076              Data.startswith("CentOS")) &&
2077             Data.find("release 5") != StringRef::npos)
2078      return RHEL5;
2079    else if ((Data.startswith("Red Hat Enterprise Linux") ||
2080              Data.startswith("CentOS")) &&
2081             Data.find("release 4") != StringRef::npos)
2082      return RHEL4;
2083    return UnknownDistro;
2084  }
2085
2086  if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
2087    StringRef Data = File.get()->getBuffer();
2088    if (Data[0] == '5')
2089      return DebianLenny;
2090    else if (Data.startswith("squeeze/sid") || Data[0] == '6')
2091      return DebianSqueeze;
2092    else if (Data.startswith("wheezy/sid")  || Data[0] == '7')
2093      return DebianWheezy;
2094    else if (Data.startswith("jessie/sid")  || Data[0] == '8')
2095      return DebianJessie;
2096    return UnknownDistro;
2097  }
2098
2099  if (llvm::sys::fs::exists("/etc/SuSE-release"))
2100    return OpenSUSE;
2101
2102  if (llvm::sys::fs::exists("/etc/exherbo-release"))
2103    return Exherbo;
2104
2105  if (llvm::sys::fs::exists("/etc/arch-release"))
2106    return ArchLinux;
2107
2108  return UnknownDistro;
2109}
2110
2111/// \brief Get our best guess at the multiarch triple for a target.
2112///
2113/// Debian-based systems are starting to use a multiarch setup where they use
2114/// a target-triple directory in the library and header search paths.
2115/// Unfortunately, this triple does not align with the vanilla target triple,
2116/// so we provide a rough mapping here.
2117static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
2118                                      StringRef SysRoot) {
2119  // For most architectures, just use whatever we have rather than trying to be
2120  // clever.
2121  switch (TargetTriple.getArch()) {
2122  default:
2123    return TargetTriple.str();
2124
2125    // We use the existence of '/lib/<triple>' as a directory to detect some
2126    // common linux triples that don't quite match the Clang triple for both
2127    // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
2128    // regardless of what the actual target triple is.
2129  case llvm::Triple::arm:
2130  case llvm::Triple::thumb:
2131    if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2132      if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabihf"))
2133        return "arm-linux-gnueabihf";
2134    } else {
2135      if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabi"))
2136        return "arm-linux-gnueabi";
2137    }
2138    return TargetTriple.str();
2139  case llvm::Triple::x86:
2140    if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
2141      return "i386-linux-gnu";
2142    return TargetTriple.str();
2143  case llvm::Triple::x86_64:
2144    if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
2145      return "x86_64-linux-gnu";
2146    return TargetTriple.str();
2147  case llvm::Triple::aarch64:
2148    if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64-linux-gnu"))
2149      return "aarch64-linux-gnu";
2150    return TargetTriple.str();
2151  case llvm::Triple::mips:
2152    if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu"))
2153      return "mips-linux-gnu";
2154    return TargetTriple.str();
2155  case llvm::Triple::mipsel:
2156    if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu"))
2157      return "mipsel-linux-gnu";
2158    return TargetTriple.str();
2159  case llvm::Triple::ppc:
2160    if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
2161      return "powerpc-linux-gnuspe";
2162    if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu"))
2163      return "powerpc-linux-gnu";
2164    return TargetTriple.str();
2165  case llvm::Triple::ppc64:
2166    if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu"))
2167      return "powerpc64-linux-gnu";
2168  case llvm::Triple::ppc64le:
2169    if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64le-linux-gnu"))
2170      return "powerpc64le-linux-gnu";
2171    return TargetTriple.str();
2172  }
2173}
2174
2175static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) {
2176  if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str());
2177}
2178
2179static bool isMipsR2Arch(llvm::Triple::ArchType Arch,
2180                         const ArgList &Args) {
2181  if (Arch != llvm::Triple::mips &&
2182      Arch != llvm::Triple::mipsel)
2183    return false;
2184
2185  Arg *A = Args.getLastArg(options::OPT_march_EQ,
2186                           options::OPT_mcpu_EQ,
2187                           options::OPT_mips_CPUs_Group);
2188
2189  if (!A)
2190    return false;
2191
2192  if (A->getOption().matches(options::OPT_mips_CPUs_Group))
2193    return A->getOption().matches(options::OPT_mips32r2);
2194
2195  return A->getValue() == StringRef("mips32r2");
2196}
2197
2198static StringRef getMultilibDir(const llvm::Triple &Triple,
2199                                const ArgList &Args) {
2200  if (!isMipsArch(Triple.getArch()))
2201    return Triple.isArch32Bit() ? "lib32" : "lib64";
2202
2203  // lib32 directory has a special meaning on MIPS targets.
2204  // It contains N32 ABI binaries. Use this folder if produce
2205  // code for N32 ABI only.
2206  if (hasMipsN32ABIArg(Args))
2207    return "lib32";
2208
2209  return Triple.isArch32Bit() ? "lib" : "lib64";
2210}
2211
2212Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2213  : Generic_ELF(D, Triple, Args) {
2214  llvm::Triple::ArchType Arch = Triple.getArch();
2215  std::string SysRoot = computeSysRoot(Args);
2216
2217  // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
2218  // least) put various tools in a triple-prefixed directory off of the parent
2219  // of the GCC installation. We use the GCC triple here to ensure that we end
2220  // up with tools that support the same amount of cross compiling as the
2221  // detected GCC installation. For example, if we find a GCC installation
2222  // targeting x86_64, but it is a bi-arch GCC installation, it can also be
2223  // used to target i386.
2224  // FIXME: This seems unlikely to be Linux-specific.
2225  ToolChain::path_list &PPaths = getProgramPaths();
2226  PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
2227                         GCCInstallation.getTriple().str() + "/bin").str());
2228
2229  Linker = GetProgramPath("ld");
2230
2231  Distro Distro = DetectDistro(Arch);
2232
2233  if (IsOpenSUSE(Distro) || IsUbuntu(Distro)) {
2234    ExtraOpts.push_back("-z");
2235    ExtraOpts.push_back("relro");
2236  }
2237
2238  if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
2239    ExtraOpts.push_back("-X");
2240
2241  const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::Android;
2242  const bool IsMips = isMipsArch(Arch);
2243
2244  if (IsMips && !SysRoot.empty())
2245    ExtraOpts.push_back("--sysroot=" + SysRoot);
2246
2247  // Do not use 'gnu' hash style for Mips targets because .gnu.hash
2248  // and the MIPS ABI require .dynsym to be sorted in different ways.
2249  // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
2250  // ABI requires a mapping between the GOT and the symbol table.
2251  // Android loader does not support .gnu.hash.
2252  if (!IsMips && !IsAndroid) {
2253    if (IsRedhat(Distro) || IsOpenSUSE(Distro) ||
2254        (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
2255      ExtraOpts.push_back("--hash-style=gnu");
2256
2257    if (IsDebian(Distro) || IsOpenSUSE(Distro) || Distro == UbuntuLucid ||
2258        Distro == UbuntuJaunty || Distro == UbuntuKarmic)
2259      ExtraOpts.push_back("--hash-style=both");
2260  }
2261
2262  if (IsRedhat(Distro))
2263    ExtraOpts.push_back("--no-add-needed");
2264
2265  if (Distro == DebianSqueeze || Distro == DebianWheezy ||
2266      Distro == DebianJessie || IsOpenSUSE(Distro) ||
2267      (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
2268      (IsUbuntu(Distro) && Distro >= UbuntuKarmic))
2269    ExtraOpts.push_back("--build-id");
2270
2271  if (IsOpenSUSE(Distro))
2272    ExtraOpts.push_back("--enable-new-dtags");
2273
2274  // The selection of paths to try here is designed to match the patterns which
2275  // the GCC driver itself uses, as this is part of the GCC-compatible driver.
2276  // This was determined by running GCC in a fake filesystem, creating all
2277  // possible permutations of these directories, and seeing which ones it added
2278  // to the link paths.
2279  path_list &Paths = getFilePaths();
2280
2281  const std::string Multilib = getMultilibDir(Triple, Args);
2282  const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
2283
2284  // Add the multilib suffixed paths where they are available.
2285  if (GCCInstallation.isValid()) {
2286    const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2287    const std::string &LibPath = GCCInstallation.getParentLibPath();
2288
2289    if (IsAndroid && isMipsR2Arch(Triple.getArch(), Args))
2290      addPathIfExists(GCCInstallation.getInstallPath() +
2291                          GCCInstallation.getBiarchSuffix() + "/mips-r2",
2292                      Paths);
2293    else
2294      addPathIfExists((GCCInstallation.getInstallPath() +
2295                       GCCInstallation.getBiarchSuffix()),
2296                      Paths);
2297
2298    // Sourcery CodeBench MIPS toolchain holds some libraries under
2299    // the parent prefix of the GCC installation.
2300    // FIXME: It would be cleaner to model this as a variant of multilib. IE,
2301    // instead of 'lib64' it would be 'lib/el'.
2302    std::string MultilibSuffix;
2303    appendMipsTargetSuffix(MultilibSuffix, Arch, Args);
2304
2305    // GCC cross compiling toolchains will install target libraries which ship
2306    // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
2307    // any part of the GCC installation in
2308    // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
2309    // debatable, but is the reality today. We need to search this tree even
2310    // when we have a sysroot somewhere else. It is the responsibility of
2311    // whomever is doing the cross build targetting a sysroot using a GCC
2312    // installation that is *not* within the system root to ensure two things:
2313    //
2314    //  1) Any DSOs that are linked in from this tree or from the install path
2315    //     above must be preasant on the system root and found via an
2316    //     appropriate rpath.
2317    //  2) There must not be libraries installed into
2318    //     <prefix>/<triple>/<libdir> unless they should be preferred over
2319    //     those within the system root.
2320    //
2321    // Note that this matches the GCC behavior. See the below comment for where
2322    // Clang diverges from GCC's behavior.
2323    addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + Multilib +
2324                        MultilibSuffix,
2325                    Paths);
2326
2327    // If the GCC installation we found is inside of the sysroot, we want to
2328    // prefer libraries installed in the parent prefix of the GCC installation.
2329    // It is important to *not* use these paths when the GCC installation is
2330    // outside of the system root as that can pick up unintended libraries.
2331    // This usually happens when there is an external cross compiler on the
2332    // host system, and a more minimal sysroot available that is the target of
2333    // the cross. Note that GCC does include some of these directories in some
2334    // configurations but this seems somewhere between questionable and simply
2335    // a bug.
2336    if (StringRef(LibPath).startswith(SysRoot)) {
2337      addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
2338      addPathIfExists(LibPath + "/../" + Multilib, Paths);
2339    }
2340  }
2341  addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
2342  addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
2343  addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
2344  addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
2345
2346  // Try walking via the GCC triple path in case of biarch or multiarch GCC
2347  // installations with strange symlinks.
2348  if (GCCInstallation.isValid())
2349    addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
2350                    "/../../" + Multilib, Paths);
2351
2352  // Add the non-multilib suffixed paths (if potentially different).
2353  if (GCCInstallation.isValid()) {
2354    const std::string &LibPath = GCCInstallation.getParentLibPath();
2355    const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2356    if (!GCCInstallation.getBiarchSuffix().empty())
2357      addPathIfExists(GCCInstallation.getInstallPath(), Paths);
2358
2359    // See comments above on the multilib variant for details of why this is
2360    // included even from outside the sysroot.
2361    addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths);
2362
2363    // See comments above on the multilib variant for details of why this is
2364    // only included from within the sysroot.
2365    if (StringRef(LibPath).startswith(SysRoot))
2366      addPathIfExists(LibPath, Paths);
2367  }
2368  addPathIfExists(SysRoot + "/lib", Paths);
2369  addPathIfExists(SysRoot + "/usr/lib", Paths);
2370}
2371
2372bool Linux::HasNativeLLVMSupport() const {
2373  return true;
2374}
2375
2376Tool *Linux::buildLinker() const {
2377  return new tools::gnutools::Link(*this);
2378}
2379
2380Tool *Linux::buildAssembler() const {
2381  return new tools::gnutools::Assemble(*this);
2382}
2383
2384void Linux::addClangTargetOptions(const ArgList &DriverArgs,
2385                                  ArgStringList &CC1Args) const {
2386  const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2387  bool UseInitArrayDefault =
2388      !V.isOlderThan(4, 7, 0) ||
2389      getTriple().getArch() == llvm::Triple::aarch64 ||
2390      getTriple().getEnvironment() == llvm::Triple::Android;
2391  if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2392                         options::OPT_fno_use_init_array,
2393                         UseInitArrayDefault))
2394    CC1Args.push_back("-fuse-init-array");
2395}
2396
2397std::string Linux::computeSysRoot(const ArgList &Args) const {
2398  if (!getDriver().SysRoot.empty())
2399    return getDriver().SysRoot;
2400
2401  if (!GCCInstallation.isValid() || !isMipsArch(getTriple().getArch()))
2402    return std::string();
2403
2404  std::string Path =
2405    (GCCInstallation.getInstallPath() +
2406     "/../../../../" + GCCInstallation.getTriple().str() + "/libc").str();
2407  appendMipsTargetSuffix(Path, getTriple().getArch(), Args);
2408
2409  return llvm::sys::fs::exists(Path) ? Path : "";
2410}
2411
2412void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2413                                      ArgStringList &CC1Args) const {
2414  const Driver &D = getDriver();
2415  std::string SysRoot = computeSysRoot(DriverArgs);
2416
2417  if (DriverArgs.hasArg(options::OPT_nostdinc))
2418    return;
2419
2420  if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
2421    addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
2422
2423  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2424    SmallString<128> P(D.ResourceDir);
2425    llvm::sys::path::append(P, "include");
2426    addSystemInclude(DriverArgs, CC1Args, P.str());
2427  }
2428
2429  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2430    return;
2431
2432  // Check for configure-time C include directories.
2433  StringRef CIncludeDirs(C_INCLUDE_DIRS);
2434  if (CIncludeDirs != "") {
2435    SmallVector<StringRef, 5> dirs;
2436    CIncludeDirs.split(dirs, ":");
2437    for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
2438         I != E; ++I) {
2439      StringRef Prefix = llvm::sys::path::is_absolute(*I) ? SysRoot : "";
2440      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
2441    }
2442    return;
2443  }
2444
2445  // Lacking those, try to detect the correct set of system includes for the
2446  // target triple.
2447
2448  // Sourcery CodeBench and modern FSF Mips toolchains put extern C
2449  // system includes under three additional directories.
2450  if (GCCInstallation.isValid() && isMipsArch(getTriple().getArch())) {
2451    addExternCSystemIncludeIfExists(
2452        DriverArgs, CC1Args, GCCInstallation.getInstallPath() + "/include");
2453
2454    addExternCSystemIncludeIfExists(
2455        DriverArgs, CC1Args,
2456        GCCInstallation.getInstallPath() + "/../../../../" +
2457            GCCInstallation.getTriple().str() + "/libc/usr/include");
2458  }
2459
2460  // Implement generic Debian multiarch support.
2461  const StringRef X86_64MultiarchIncludeDirs[] = {
2462    "/usr/include/x86_64-linux-gnu",
2463
2464    // FIXME: These are older forms of multiarch. It's not clear that they're
2465    // in use in any released version of Debian, so we should consider
2466    // removing them.
2467    "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"
2468  };
2469  const StringRef X86MultiarchIncludeDirs[] = {
2470    "/usr/include/i386-linux-gnu",
2471
2472    // FIXME: These are older forms of multiarch. It's not clear that they're
2473    // in use in any released version of Debian, so we should consider
2474    // removing them.
2475    "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",
2476    "/usr/include/i486-linux-gnu"
2477  };
2478  const StringRef AArch64MultiarchIncludeDirs[] = {
2479    "/usr/include/aarch64-linux-gnu"
2480  };
2481  const StringRef ARMMultiarchIncludeDirs[] = {
2482    "/usr/include/arm-linux-gnueabi"
2483  };
2484  const StringRef ARMHFMultiarchIncludeDirs[] = {
2485    "/usr/include/arm-linux-gnueabihf"
2486  };
2487  const StringRef MIPSMultiarchIncludeDirs[] = {
2488    "/usr/include/mips-linux-gnu"
2489  };
2490  const StringRef MIPSELMultiarchIncludeDirs[] = {
2491    "/usr/include/mipsel-linux-gnu"
2492  };
2493  const StringRef PPCMultiarchIncludeDirs[] = {
2494    "/usr/include/powerpc-linux-gnu"
2495  };
2496  const StringRef PPC64MultiarchIncludeDirs[] = {
2497    "/usr/include/powerpc64-linux-gnu"
2498  };
2499  ArrayRef<StringRef> MultiarchIncludeDirs;
2500  if (getTriple().getArch() == llvm::Triple::x86_64) {
2501    MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
2502  } else if (getTriple().getArch() == llvm::Triple::x86) {
2503    MultiarchIncludeDirs = X86MultiarchIncludeDirs;
2504  } else if (getTriple().getArch() == llvm::Triple::aarch64) {
2505    MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
2506  } else if (getTriple().getArch() == llvm::Triple::arm) {
2507    if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
2508      MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
2509    else
2510      MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
2511  } else if (getTriple().getArch() == llvm::Triple::mips) {
2512    MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
2513  } else if (getTriple().getArch() == llvm::Triple::mipsel) {
2514    MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
2515  } else if (getTriple().getArch() == llvm::Triple::ppc) {
2516    MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
2517  } else if (getTriple().getArch() == llvm::Triple::ppc64) {
2518    MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
2519  }
2520  for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(),
2521                                     E = MultiarchIncludeDirs.end();
2522       I != E; ++I) {
2523    if (llvm::sys::fs::exists(SysRoot + *I)) {
2524      addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + *I);
2525      break;
2526    }
2527  }
2528
2529  if (getTriple().getOS() == llvm::Triple::RTEMS)
2530    return;
2531
2532  // Add an include of '/include' directly. This isn't provided by default by
2533  // system GCCs, but is often used with cross-compiling GCCs, and harmless to
2534  // add even when Clang is acting as-if it were a system compiler.
2535  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
2536
2537  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
2538}
2539
2540/// \brief Helper to add the three variant paths for a libstdc++ installation.
2541/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
2542                                                const ArgList &DriverArgs,
2543                                                ArgStringList &CC1Args) {
2544  if (!llvm::sys::fs::exists(Base))
2545    return false;
2546  addSystemInclude(DriverArgs, CC1Args, Base);
2547  addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir);
2548  addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
2549  return true;
2550}
2551
2552/// \brief Helper to add an extra variant path for an (Ubuntu) multilib
2553/// libstdc++ installation.
2554/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
2555                                                Twine TargetArchDir,
2556                                                Twine MultiLibSuffix,
2557                                                const ArgList &DriverArgs,
2558                                                ArgStringList &CC1Args) {
2559  if (!addLibStdCXXIncludePaths(Base+Suffix, TargetArchDir + MultiLibSuffix,
2560                                DriverArgs, CC1Args))
2561    return false;
2562
2563  addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir + Suffix
2564                   + MultiLibSuffix);
2565  return true;
2566}
2567
2568void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2569                                         ArgStringList &CC1Args) const {
2570  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2571      DriverArgs.hasArg(options::OPT_nostdincxx))
2572    return;
2573
2574  // Check if libc++ has been enabled and provide its include paths if so.
2575  if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
2576    // libc++ is always installed at a fixed path on Linux currently.
2577    addSystemInclude(DriverArgs, CC1Args,
2578                     getDriver().SysRoot + "/usr/include/c++/v1");
2579    return;
2580  }
2581
2582  // We need a detected GCC installation on Linux to provide libstdc++'s
2583  // headers. We handled the libc++ case above.
2584  if (!GCCInstallation.isValid())
2585    return;
2586
2587  // By default, look for the C++ headers in an include directory adjacent to
2588  // the lib directory of the GCC installation. Note that this is expect to be
2589  // equivalent to '/usr/include/c++/X.Y' in almost all cases.
2590  StringRef LibDir = GCCInstallation.getParentLibPath();
2591  StringRef InstallDir = GCCInstallation.getInstallPath();
2592  StringRef TripleStr = GCCInstallation.getTriple().str();
2593  const GCCVersion &Version = GCCInstallation.getVersion();
2594
2595  if (addLibStdCXXIncludePaths(
2596          LibDir.str() + "/../include", "/c++/" + Version.Text, TripleStr,
2597          GCCInstallation.getBiarchSuffix(), DriverArgs, CC1Args))
2598    return;
2599
2600  const std::string IncludePathCandidates[] = {
2601    // Gentoo is weird and places its headers inside the GCC install, so if the
2602    // first attempt to find the headers fails, try these patterns.
2603    InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
2604        Version.MinorStr,
2605    InstallDir.str() + "/include/g++-v" + Version.MajorStr,
2606    // Android standalone toolchain has C++ headers in yet another place.
2607    LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
2608    // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
2609    // without a subdirectory corresponding to the gcc version.
2610    LibDir.str() + "/../include/c++",
2611  };
2612
2613  for (unsigned i = 0; i < llvm::array_lengthof(IncludePathCandidates); ++i) {
2614    if (addLibStdCXXIncludePaths(
2615            IncludePathCandidates[i],
2616            (TripleStr + GCCInstallation.getBiarchSuffix()), DriverArgs,
2617            CC1Args))
2618      break;
2619  }
2620}
2621
2622bool Linux::isPIEDefault() const {
2623  return getSanitizerArgs().hasZeroBaseShadow(*this);
2624}
2625
2626/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2627
2628DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2629  : Generic_ELF(D, Triple, Args) {
2630
2631  // Path mangling to find libexec
2632  getProgramPaths().push_back(getDriver().getInstalledDir());
2633  if (getDriver().getInstalledDir() != getDriver().Dir)
2634    getProgramPaths().push_back(getDriver().Dir);
2635
2636  getFilePaths().push_back(getDriver().Dir + "/../lib");
2637  getFilePaths().push_back("/usr/lib");
2638  if (llvm::sys::fs::exists("/usr/lib/gcc47"))
2639    getFilePaths().push_back("/usr/lib/gcc47");
2640  else
2641    getFilePaths().push_back("/usr/lib/gcc44");
2642}
2643
2644Tool *DragonFly::buildAssembler() const {
2645  return new tools::dragonfly::Assemble(*this);
2646}
2647
2648Tool *DragonFly::buildLinker() const {
2649  return new tools::dragonfly::Link(*this);
2650}
2651