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 "SanitizerArgs.h"
12#include "clang/Basic/ObjCRuntime.h"
13#include "clang/Basic/Version.h"
14#include "clang/Driver/Compilation.h"
15#include "clang/Driver/Driver.h"
16#include "clang/Driver/DriverDiagnostic.h"
17#include "clang/Driver/Options.h"
18#include "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  SanitizerArgs Sanitize(*this, 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  if (Second.first.getAsInteger(10, GoodVersion.Minor) ||
919      GoodVersion.Minor < 0)
920    return BadVersion;
921
922  // First look for a number prefix and parse that if present. Otherwise just
923  // stash the entire patch string in the suffix, and leave the number
924  // unspecified. This covers versions strings such as:
925  //   4.4
926  //   4.4.0
927  //   4.4.x
928  //   4.4.2-rc4
929  //   4.4.x-patched
930  // And retains any patch number it finds.
931  StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
932  if (!PatchText.empty()) {
933    if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
934      // Try to parse the number and any suffix.
935      if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
936          GoodVersion.Patch < 0)
937        return BadVersion;
938      GoodVersion.PatchSuffix = PatchText.substr(EndNumber).str();
939    }
940  }
941
942  return GoodVersion;
943}
944
945/// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering.
946bool Generic_GCC::GCCVersion::operator<(const GCCVersion &RHS) const {
947  if (Major != RHS.Major)
948    return Major < RHS.Major;
949  if (Minor != RHS.Minor)
950    return Minor < RHS.Minor;
951  if (Patch != RHS.Patch) {
952    // Note that versions without a specified patch sort higher than those with
953    // a patch.
954    if (RHS.Patch == -1)
955      return true;
956    if (Patch == -1)
957      return false;
958
959    // Otherwise just sort on the patch itself.
960    return Patch < RHS.Patch;
961  }
962  if (PatchSuffix != RHS.PatchSuffix) {
963    // Sort empty suffixes higher.
964    if (RHS.PatchSuffix.empty())
965      return true;
966    if (PatchSuffix.empty())
967      return false;
968
969    // Provide a lexicographic sort to make this a total ordering.
970    return PatchSuffix < RHS.PatchSuffix;
971  }
972
973  // The versions are equal.
974  return false;
975}
976
977static StringRef getGCCToolchainDir(const ArgList &Args) {
978  const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
979  if (A)
980    return A->getValue();
981  return GCC_INSTALL_PREFIX;
982}
983
984/// \brief Construct a GCCInstallationDetector from the driver.
985///
986/// This performs all of the autodetection and sets up the various paths.
987/// Once constructed, a GCCInstallationDetector is essentially immutable.
988///
989/// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
990/// should instead pull the target out of the driver. This is currently
991/// necessary because the driver doesn't store the final version of the target
992/// triple.
993Generic_GCC::GCCInstallationDetector::GCCInstallationDetector(
994    const Driver &D, const llvm::Triple &TargetTriple, const ArgList &Args)
995    : IsValid(false) {
996  llvm::Triple BiarchVariantTriple =
997      TargetTriple.isArch32Bit() ? TargetTriple.get64BitArchVariant()
998                                 : TargetTriple.get32BitArchVariant();
999  llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1000  // The library directories which may contain GCC installations.
1001  SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
1002  // The compatible GCC triples for this particular architecture.
1003  SmallVector<StringRef, 10> CandidateTripleAliases;
1004  SmallVector<StringRef, 10> CandidateBiarchTripleAliases;
1005  CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1006                           CandidateTripleAliases, CandidateBiarchLibDirs,
1007                           CandidateBiarchTripleAliases);
1008
1009  // Compute the set of prefixes for our search.
1010  SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1011                                       D.PrefixDirs.end());
1012
1013  StringRef GCCToolchainDir = getGCCToolchainDir(Args);
1014  if (GCCToolchainDir != "") {
1015    if (GCCToolchainDir.back() == '/')
1016      GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1017
1018    Prefixes.push_back(GCCToolchainDir);
1019  } else {
1020    Prefixes.push_back(D.SysRoot);
1021    Prefixes.push_back(D.SysRoot + "/usr");
1022    Prefixes.push_back(D.InstalledDir + "/..");
1023  }
1024
1025  // Loop over the various components which exist and select the best GCC
1026  // installation available. GCC installs are ranked by version number.
1027  Version = GCCVersion::Parse("0.0.0");
1028  for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) {
1029    if (!llvm::sys::fs::exists(Prefixes[i]))
1030      continue;
1031    for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) {
1032      const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str();
1033      if (!llvm::sys::fs::exists(LibDir))
1034        continue;
1035      for (unsigned k = 0, ke = CandidateTripleAliases.size(); k < ke; ++k)
1036        ScanLibDirForGCCTriple(TargetArch, Args, LibDir,
1037                               CandidateTripleAliases[k]);
1038    }
1039    for (unsigned j = 0, je = CandidateBiarchLibDirs.size(); j < je; ++j) {
1040      const std::string LibDir = Prefixes[i] + CandidateBiarchLibDirs[j].str();
1041      if (!llvm::sys::fs::exists(LibDir))
1042        continue;
1043      for (unsigned k = 0, ke = CandidateBiarchTripleAliases.size(); k < ke;
1044           ++k)
1045        ScanLibDirForGCCTriple(TargetArch, Args, LibDir,
1046                               CandidateBiarchTripleAliases[k],
1047                               /*NeedsBiarchSuffix=*/ true);
1048    }
1049  }
1050}
1051
1052void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
1053  for (SmallVectorImpl<std::string>::const_iterator
1054           I = CandidateGCCInstallPaths.begin(),
1055           E = CandidateGCCInstallPaths.end();
1056       I != E; ++I)
1057    OS << "Found candidate GCC installation: " << *I << "\n";
1058
1059  OS << "Selected GCC installation: " << GCCInstallPath << "\n";
1060}
1061
1062/*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1063    const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
1064    SmallVectorImpl<StringRef> &LibDirs,
1065    SmallVectorImpl<StringRef> &TripleAliases,
1066    SmallVectorImpl<StringRef> &BiarchLibDirs,
1067    SmallVectorImpl<StringRef> &BiarchTripleAliases) {
1068  // Declare a bunch of static data sets that we'll select between below. These
1069  // are specifically designed to always refer to string literals to avoid any
1070  // lifetime or initialization issues.
1071  static const char *const AArch64LibDirs[] = { "/lib" };
1072  static const char *const AArch64Triples[] = { "aarch64-none-linux-gnu",
1073                                                "aarch64-linux-gnu" };
1074
1075  static const char *const ARMLibDirs[] = { "/lib" };
1076  static const char *const ARMTriples[] = { "arm-linux-gnueabi",
1077                                            "arm-linux-androideabi" };
1078  static const char *const ARMHFTriples[] = { "arm-linux-gnueabihf",
1079                                              "armv7hl-redhat-linux-gnueabi" };
1080
1081  static const char *const X86_64LibDirs[] = { "/lib64", "/lib" };
1082  static const char *const X86_64Triples[] = {
1083    "x86_64-linux-gnu", "x86_64-unknown-linux-gnu", "x86_64-pc-linux-gnu",
1084    "x86_64-redhat-linux6E", "x86_64-redhat-linux", "x86_64-suse-linux",
1085    "x86_64-manbo-linux-gnu", "x86_64-linux-gnu", "x86_64-slackware-linux"
1086  };
1087  static const char *const X86LibDirs[] = { "/lib32", "/lib" };
1088  static const char *const X86Triples[] = {
1089    "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu", "i386-linux-gnu",
1090    "i386-redhat-linux6E", "i686-redhat-linux", "i586-redhat-linux",
1091    "i386-redhat-linux", "i586-suse-linux", "i486-slackware-linux",
1092    "i686-montavista-linux"
1093  };
1094
1095  static const char *const MIPSLibDirs[] = { "/lib" };
1096  static const char *const MIPSTriples[] = { "mips-linux-gnu" };
1097  static const char *const MIPSELLibDirs[] = { "/lib" };
1098  static const char *const MIPSELTriples[] = { "mipsel-linux-gnu",
1099                                               "mipsel-linux-android",
1100                                               "mips-linux-gnu" };
1101
1102  static const char *const MIPS64LibDirs[] = { "/lib64", "/lib" };
1103  static const char *const MIPS64Triples[] = { "mips64-linux-gnu" };
1104  static const char *const MIPS64ELLibDirs[] = { "/lib64", "/lib" };
1105  static const char *const MIPS64ELTriples[] = { "mips64el-linux-gnu" };
1106
1107  static const char *const PPCLibDirs[] = { "/lib32", "/lib" };
1108  static const char *const PPCTriples[] = {
1109    "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
1110    "powerpc-suse-linux", "powerpc-montavista-linuxspe"
1111  };
1112  static const char *const PPC64LibDirs[] = { "/lib64", "/lib" };
1113  static const char *const PPC64Triples[] = { "powerpc64-linux-gnu",
1114                                              "powerpc64-unknown-linux-gnu",
1115                                              "powerpc64-suse-linux",
1116                                              "ppc64-redhat-linux" };
1117  static const char *const PPC64LELibDirs[] = { "/lib64", "/lib" };
1118  static const char *const PPC64LETriples[] = { "powerpc64le-linux-gnu",
1119                                                "powerpc64le-unknown-linux-gnu",
1120                                                "powerpc64le-suse-linux",
1121                                                "ppc64le-redhat-linux" };
1122
1123  static const char *const SystemZLibDirs[] = { "/lib64", "/lib" };
1124  static const char *const SystemZTriples[] = {
1125    "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
1126    "s390x-suse-linux", "s390x-redhat-linux"
1127  };
1128
1129  switch (TargetTriple.getArch()) {
1130  case llvm::Triple::aarch64:
1131    LibDirs.append(AArch64LibDirs,
1132                   AArch64LibDirs + llvm::array_lengthof(AArch64LibDirs));
1133    TripleAliases.append(AArch64Triples,
1134                         AArch64Triples + llvm::array_lengthof(AArch64Triples));
1135    BiarchLibDirs.append(AArch64LibDirs,
1136                         AArch64LibDirs + llvm::array_lengthof(AArch64LibDirs));
1137    BiarchTripleAliases.append(
1138        AArch64Triples, AArch64Triples + llvm::array_lengthof(AArch64Triples));
1139    break;
1140  case llvm::Triple::arm:
1141  case llvm::Triple::thumb:
1142    LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs));
1143    if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1144      TripleAliases.append(ARMHFTriples,
1145                           ARMHFTriples + llvm::array_lengthof(ARMHFTriples));
1146    } else {
1147      TripleAliases.append(ARMTriples,
1148                           ARMTriples + llvm::array_lengthof(ARMTriples));
1149    }
1150    break;
1151  case llvm::Triple::x86_64:
1152    LibDirs.append(X86_64LibDirs,
1153                   X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1154    TripleAliases.append(X86_64Triples,
1155                         X86_64Triples + llvm::array_lengthof(X86_64Triples));
1156    BiarchLibDirs.append(X86LibDirs,
1157                         X86LibDirs + llvm::array_lengthof(X86LibDirs));
1158    BiarchTripleAliases.append(X86Triples,
1159                               X86Triples + llvm::array_lengthof(X86Triples));
1160    break;
1161  case llvm::Triple::x86:
1162    LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1163    TripleAliases.append(X86Triples,
1164                         X86Triples + llvm::array_lengthof(X86Triples));
1165    BiarchLibDirs.append(X86_64LibDirs,
1166                         X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1167    BiarchTripleAliases.append(
1168        X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples));
1169    break;
1170  case llvm::Triple::mips:
1171    LibDirs.append(MIPSLibDirs,
1172                   MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1173    TripleAliases.append(MIPSTriples,
1174                         MIPSTriples + llvm::array_lengthof(MIPSTriples));
1175    BiarchLibDirs.append(MIPS64LibDirs,
1176                         MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1177    BiarchTripleAliases.append(
1178        MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1179    break;
1180  case llvm::Triple::mipsel:
1181    LibDirs.append(MIPSELLibDirs,
1182                   MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1183    TripleAliases.append(MIPSELTriples,
1184                         MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1185    BiarchLibDirs.append(
1186        MIPS64ELLibDirs,
1187        MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1188    BiarchTripleAliases.append(
1189        MIPS64ELTriples,
1190        MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1191    break;
1192  case llvm::Triple::mips64:
1193    LibDirs.append(MIPS64LibDirs,
1194                   MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1195    TripleAliases.append(MIPS64Triples,
1196                         MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1197    BiarchLibDirs.append(MIPSLibDirs,
1198                         MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1199    BiarchTripleAliases.append(MIPSTriples,
1200                               MIPSTriples + llvm::array_lengthof(MIPSTriples));
1201    break;
1202  case llvm::Triple::mips64el:
1203    LibDirs.append(MIPS64ELLibDirs,
1204                   MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1205    TripleAliases.append(
1206        MIPS64ELTriples,
1207        MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1208    BiarchLibDirs.append(MIPSELLibDirs,
1209                         MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1210    BiarchTripleAliases.append(
1211        MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1212    break;
1213  case llvm::Triple::ppc:
1214    LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1215    TripleAliases.append(PPCTriples,
1216                         PPCTriples + llvm::array_lengthof(PPCTriples));
1217    BiarchLibDirs.append(PPC64LibDirs,
1218                         PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1219    BiarchTripleAliases.append(
1220        PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples));
1221    break;
1222  case llvm::Triple::ppc64:
1223    LibDirs.append(PPC64LibDirs,
1224                   PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1225    TripleAliases.append(PPC64Triples,
1226                         PPC64Triples + llvm::array_lengthof(PPC64Triples));
1227    BiarchLibDirs.append(PPCLibDirs,
1228                         PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1229    BiarchTripleAliases.append(PPCTriples,
1230                               PPCTriples + llvm::array_lengthof(PPCTriples));
1231    break;
1232  case llvm::Triple::ppc64le:
1233    LibDirs.append(PPC64LELibDirs,
1234                   PPC64LELibDirs + llvm::array_lengthof(PPC64LELibDirs));
1235    TripleAliases.append(PPC64LETriples,
1236                         PPC64LETriples + llvm::array_lengthof(PPC64LETriples));
1237    break;
1238  case llvm::Triple::systemz:
1239    LibDirs.append(SystemZLibDirs,
1240                   SystemZLibDirs + llvm::array_lengthof(SystemZLibDirs));
1241    TripleAliases.append(SystemZTriples,
1242                         SystemZTriples + llvm::array_lengthof(SystemZTriples));
1243    break;
1244
1245  default:
1246    // By default, just rely on the standard lib directories and the original
1247    // triple.
1248    break;
1249  }
1250
1251  // Always append the drivers target triple to the end, in case it doesn't
1252  // match any of our aliases.
1253  TripleAliases.push_back(TargetTriple.str());
1254
1255  // Also include the multiarch variant if it's different.
1256  if (TargetTriple.str() != BiarchTriple.str())
1257    BiarchTripleAliases.push_back(BiarchTriple.str());
1258}
1259
1260static bool isSoftFloatABI(const ArgList &Args) {
1261  Arg *A = Args.getLastArg(options::OPT_msoft_float,
1262                           options::OPT_mhard_float,
1263                           options::OPT_mfloat_abi_EQ);
1264  if (!A) return false;
1265
1266  return A->getOption().matches(options::OPT_msoft_float) ||
1267         (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
1268          A->getValue() == StringRef("soft"));
1269}
1270
1271static bool isMipsArch(llvm::Triple::ArchType Arch) {
1272  return Arch == llvm::Triple::mips ||
1273         Arch == llvm::Triple::mipsel ||
1274         Arch == llvm::Triple::mips64 ||
1275         Arch == llvm::Triple::mips64el;
1276}
1277
1278static bool isMips16(const ArgList &Args) {
1279  Arg *A = Args.getLastArg(options::OPT_mips16,
1280                           options::OPT_mno_mips16);
1281  return A && A->getOption().matches(options::OPT_mips16);
1282}
1283
1284static bool isMicroMips(const ArgList &Args) {
1285  Arg *A = Args.getLastArg(options::OPT_mmicromips,
1286                           options::OPT_mno_micromips);
1287  return A && A->getOption().matches(options::OPT_mmicromips);
1288}
1289
1290// FIXME: There is the same routine in the Tools.cpp.
1291static bool hasMipsN32ABIArg(const ArgList &Args) {
1292  Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1293  return A && (A->getValue() == StringRef("n32"));
1294}
1295
1296static void appendMipsTargetSuffix(std::string &Path,
1297                                   llvm::Triple::ArchType TargetArch,
1298                                   const ArgList &Args) {
1299  if (isMips16(Args))
1300    Path += "/mips16";
1301  else if (isMicroMips(Args))
1302    Path += "/micromips";
1303
1304  if (isSoftFloatABI(Args))
1305    Path += "/soft-float";
1306
1307  if (TargetArch == llvm::Triple::mipsel ||
1308      TargetArch == llvm::Triple::mips64el)
1309    Path += "/el";
1310}
1311
1312static StringRef getMipsTargetABISuffix(llvm::Triple::ArchType TargetArch,
1313                                        const ArgList &Args) {
1314  if (TargetArch == llvm::Triple::mips64 ||
1315      TargetArch == llvm::Triple::mips64el)
1316    return hasMipsN32ABIArg(Args) ? "/n32" : "/64";
1317
1318  return "/32";
1319}
1320
1321static bool findTargetBiarchSuffix(std::string &Suffix, StringRef Path,
1322                                   llvm::Triple::ArchType TargetArch,
1323                                   const ArgList &Args) {
1324  // FIXME: This routine was only intended to model bi-arch toolchains which
1325  // use -m32 and -m64 to swap between variants of a target. It shouldn't be
1326  // doing ABI-based builtin location for MIPS.
1327  if (isMipsArch(TargetArch)) {
1328    StringRef ABISuffix = getMipsTargetABISuffix(TargetArch, Args);
1329
1330    // First build and check a complex path to crtbegin.o
1331    // depends on command line options (-mips16, -msoft-float, ...)
1332    // like mips-linux-gnu/4.7/mips16/soft-float/el/crtbegin.o
1333    appendMipsTargetSuffix(Suffix, TargetArch, Args);
1334
1335    if (TargetArch == llvm::Triple::mips64 ||
1336        TargetArch == llvm::Triple::mips64el)
1337      Suffix += ABISuffix;
1338
1339    if (llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o"))
1340      return true;
1341
1342    // Then fall back and probe a simple case like
1343    // mips-linux-gnu/4.7/32/crtbegin.o
1344    Suffix = ABISuffix;
1345    return llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o");
1346  }
1347
1348  if (TargetArch == llvm::Triple::x86_64 ||
1349      TargetArch == llvm::Triple::ppc64 ||
1350      TargetArch == llvm::Triple::systemz)
1351    Suffix = "/64";
1352  else
1353    Suffix = "/32";
1354
1355  return llvm::sys::fs::exists(Path + Suffix + "/crtbegin.o");
1356}
1357
1358void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
1359    llvm::Triple::ArchType TargetArch, const ArgList &Args,
1360    const std::string &LibDir, StringRef CandidateTriple,
1361    bool NeedsBiarchSuffix) {
1362  // There are various different suffixes involving the triple we
1363  // check for. We also record what is necessary to walk from each back
1364  // up to the lib directory.
1365  const std::string LibSuffixes[] = {
1366    "/gcc/" + CandidateTriple.str(),
1367    // Debian puts cross-compilers in gcc-cross
1368    "/gcc-cross/" + CandidateTriple.str(),
1369    "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
1370
1371    // The Freescale PPC SDK has the gcc libraries in
1372    // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well.
1373    "/" + CandidateTriple.str(),
1374
1375    // Ubuntu has a strange mis-matched pair of triples that this happens to
1376    // match.
1377    // FIXME: It may be worthwhile to generalize this and look for a second
1378    // triple.
1379    "/i386-linux-gnu/gcc/" + CandidateTriple.str()
1380  };
1381  const std::string InstallSuffixes[] = {
1382    "/../../..",    // gcc/
1383    "/../../..",    // gcc-cross/
1384    "/../../../..", // <triple>/gcc/
1385    "/../..",       // <triple>/
1386    "/../../../.."  // i386-linux-gnu/gcc/<triple>/
1387  };
1388  // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
1389  const unsigned NumLibSuffixes =
1390      (llvm::array_lengthof(LibSuffixes) - (TargetArch != llvm::Triple::x86));
1391  for (unsigned i = 0; i < NumLibSuffixes; ++i) {
1392    StringRef LibSuffix = LibSuffixes[i];
1393    llvm::error_code EC;
1394    for (llvm::sys::fs::directory_iterator LI(LibDir + LibSuffix, EC), LE;
1395         !EC && LI != LE; LI = LI.increment(EC)) {
1396      CandidateGCCInstallPaths.push_back(LI->path());
1397      StringRef VersionText = llvm::sys::path::filename(LI->path());
1398      GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1399      static const GCCVersion MinVersion = { "4.1.1", 4, 1, 1, "" };
1400      if (CandidateVersion < MinVersion)
1401        continue;
1402      if (CandidateVersion <= Version)
1403        continue;
1404
1405      // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1406      // in what would normally be GCCInstallPath and put the 64-bit
1407      // libs in a subdirectory named 64. The simple logic we follow is that
1408      // *if* there is a subdirectory of the right name with crtbegin.o in it,
1409      // we use that. If not, and if not a biarch triple alias, we look for
1410      // crtbegin.o without the subdirectory.
1411
1412      std::string BiarchSuffix;
1413      if (findTargetBiarchSuffix(BiarchSuffix, LI->path(), TargetArch, Args)) {
1414        GCCBiarchSuffix = BiarchSuffix;
1415      } else {
1416        if (NeedsBiarchSuffix ||
1417            !llvm::sys::fs::exists(LI->path() + "/crtbegin.o"))
1418          continue;
1419        GCCBiarchSuffix.clear();
1420      }
1421
1422      Version = CandidateVersion;
1423      GCCTriple.setTriple(CandidateTriple);
1424      // FIXME: We hack together the directory name here instead of
1425      // using LI to ensure stable path separators across Windows and
1426      // Linux.
1427      GCCInstallPath = LibDir + LibSuffixes[i] + "/" + VersionText.str();
1428      GCCParentLibPath = GCCInstallPath + InstallSuffixes[i];
1429      IsValid = true;
1430    }
1431  }
1432}
1433
1434Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple& Triple,
1435                         const ArgList &Args)
1436  : ToolChain(D, Triple, Args), GCCInstallation(getDriver(), Triple, Args) {
1437  getProgramPaths().push_back(getDriver().getInstalledDir());
1438  if (getDriver().getInstalledDir() != getDriver().Dir)
1439    getProgramPaths().push_back(getDriver().Dir);
1440}
1441
1442Generic_GCC::~Generic_GCC() {
1443}
1444
1445Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
1446  switch (AC) {
1447  case Action::PreprocessJobClass:
1448    if (!Preprocess)
1449      Preprocess.reset(new tools::gcc::Preprocess(*this));
1450    return Preprocess.get();
1451  case Action::PrecompileJobClass:
1452    if (!Precompile)
1453      Precompile.reset(new tools::gcc::Precompile(*this));
1454    return Precompile.get();
1455  case Action::CompileJobClass:
1456    if (!Compile)
1457      Compile.reset(new tools::gcc::Compile(*this));
1458    return Compile.get();
1459  default:
1460    return ToolChain::getTool(AC);
1461  }
1462}
1463
1464Tool *Generic_GCC::buildAssembler() const {
1465  return new tools::gcc::Assemble(*this);
1466}
1467
1468Tool *Generic_GCC::buildLinker() const {
1469  return new tools::gcc::Link(*this);
1470}
1471
1472void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
1473  // Print the information about how we detected the GCC installation.
1474  GCCInstallation.print(OS);
1475}
1476
1477bool Generic_GCC::IsUnwindTablesDefault() const {
1478  return getArch() == llvm::Triple::x86_64;
1479}
1480
1481bool Generic_GCC::isPICDefault() const {
1482  return false;
1483}
1484
1485bool Generic_GCC::isPIEDefault() const {
1486  return false;
1487}
1488
1489bool Generic_GCC::isPICDefaultForced() const {
1490  return false;
1491}
1492
1493/// Hexagon Toolchain
1494
1495std::string Hexagon_TC::GetGnuDir(const std::string &InstalledDir) {
1496
1497  // Locate the rest of the toolchain ...
1498  if (strlen(GCC_INSTALL_PREFIX))
1499    return std::string(GCC_INSTALL_PREFIX);
1500
1501  std::string InstallRelDir = InstalledDir + "/../../gnu";
1502  if (llvm::sys::fs::exists(InstallRelDir))
1503    return InstallRelDir;
1504
1505  std::string PrefixRelDir = std::string(LLVM_PREFIX) + "/../gnu";
1506  if (llvm::sys::fs::exists(PrefixRelDir))
1507    return PrefixRelDir;
1508
1509  return InstallRelDir;
1510}
1511
1512static void GetHexagonLibraryPaths(
1513  const ArgList &Args,
1514  const std::string Ver,
1515  const std::string MarchString,
1516  const std::string &InstalledDir,
1517  ToolChain::path_list *LibPaths)
1518{
1519  bool buildingLib = Args.hasArg(options::OPT_shared);
1520
1521  //----------------------------------------------------------------------------
1522  // -L Args
1523  //----------------------------------------------------------------------------
1524  for (arg_iterator
1525         it = Args.filtered_begin(options::OPT_L),
1526         ie = Args.filtered_end();
1527       it != ie;
1528       ++it) {
1529    for (unsigned i = 0, e = (*it)->getNumValues(); i != e; ++i)
1530      LibPaths->push_back((*it)->getValue(i));
1531  }
1532
1533  //----------------------------------------------------------------------------
1534  // Other standard paths
1535  //----------------------------------------------------------------------------
1536  const std::string MarchSuffix = "/" + MarchString;
1537  const std::string G0Suffix = "/G0";
1538  const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
1539  const std::string RootDir = Hexagon_TC::GetGnuDir(InstalledDir) + "/";
1540
1541  // lib/gcc/hexagon/...
1542  std::string LibGCCHexagonDir = RootDir + "lib/gcc/hexagon/";
1543  if (buildingLib) {
1544    LibPaths->push_back(LibGCCHexagonDir + Ver + MarchG0Suffix);
1545    LibPaths->push_back(LibGCCHexagonDir + Ver + G0Suffix);
1546  }
1547  LibPaths->push_back(LibGCCHexagonDir + Ver + MarchSuffix);
1548  LibPaths->push_back(LibGCCHexagonDir + Ver);
1549
1550  // lib/gcc/...
1551  LibPaths->push_back(RootDir + "lib/gcc");
1552
1553  // hexagon/lib/...
1554  std::string HexagonLibDir = RootDir + "hexagon/lib";
1555  if (buildingLib) {
1556    LibPaths->push_back(HexagonLibDir + MarchG0Suffix);
1557    LibPaths->push_back(HexagonLibDir + G0Suffix);
1558  }
1559  LibPaths->push_back(HexagonLibDir + MarchSuffix);
1560  LibPaths->push_back(HexagonLibDir);
1561}
1562
1563Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple,
1564                       const ArgList &Args)
1565  : Linux(D, Triple, Args) {
1566  const std::string InstalledDir(getDriver().getInstalledDir());
1567  const std::string GnuDir = Hexagon_TC::GetGnuDir(InstalledDir);
1568
1569  // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
1570  // program paths
1571  const std::string BinDir(GnuDir + "/bin");
1572  if (llvm::sys::fs::exists(BinDir))
1573    getProgramPaths().push_back(BinDir);
1574
1575  // Determine version of GCC libraries and headers to use.
1576  const std::string HexagonDir(GnuDir + "/lib/gcc/hexagon");
1577  llvm::error_code ec;
1578  GCCVersion MaxVersion= GCCVersion::Parse("0.0.0");
1579  for (llvm::sys::fs::directory_iterator di(HexagonDir, ec), de;
1580       !ec && di != de; di = di.increment(ec)) {
1581    GCCVersion cv = GCCVersion::Parse(llvm::sys::path::filename(di->path()));
1582    if (MaxVersion < cv)
1583      MaxVersion = cv;
1584  }
1585  GCCLibAndIncVersion = MaxVersion;
1586
1587  ToolChain::path_list *LibPaths= &getFilePaths();
1588
1589  // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
1590  // 'elf' OS type, so the Linux paths are not appropriate. When we actually
1591  // support 'linux' we'll need to fix this up
1592  LibPaths->clear();
1593
1594  GetHexagonLibraryPaths(
1595    Args,
1596    GetGCCLibAndIncVersion(),
1597    GetTargetCPU(Args),
1598    InstalledDir,
1599    LibPaths);
1600}
1601
1602Hexagon_TC::~Hexagon_TC() {
1603}
1604
1605Tool *Hexagon_TC::buildAssembler() const {
1606  return new tools::hexagon::Assemble(*this);
1607}
1608
1609Tool *Hexagon_TC::buildLinker() const {
1610  return new tools::hexagon::Link(*this);
1611}
1612
1613void Hexagon_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
1614                                           ArgStringList &CC1Args) const {
1615  const Driver &D = getDriver();
1616
1617  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
1618      DriverArgs.hasArg(options::OPT_nostdlibinc))
1619    return;
1620
1621  std::string Ver(GetGCCLibAndIncVersion());
1622  std::string GnuDir = Hexagon_TC::GetGnuDir(D.InstalledDir);
1623  std::string HexagonDir(GnuDir + "/lib/gcc/hexagon/" + Ver);
1624  addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include");
1625  addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include-fixed");
1626  addExternCSystemInclude(DriverArgs, CC1Args, GnuDir + "/hexagon/include");
1627}
1628
1629void Hexagon_TC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1630                                              ArgStringList &CC1Args) const {
1631
1632  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1633      DriverArgs.hasArg(options::OPT_nostdincxx))
1634    return;
1635
1636  const Driver &D = getDriver();
1637  std::string Ver(GetGCCLibAndIncVersion());
1638  SmallString<128> IncludeDir(Hexagon_TC::GetGnuDir(D.InstalledDir));
1639
1640  llvm::sys::path::append(IncludeDir, "hexagon/include/c++/");
1641  llvm::sys::path::append(IncludeDir, Ver);
1642  addSystemInclude(DriverArgs, CC1Args, IncludeDir.str());
1643}
1644
1645ToolChain::CXXStdlibType
1646Hexagon_TC::GetCXXStdlibType(const ArgList &Args) const {
1647  Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1648  if (!A)
1649    return ToolChain::CST_Libstdcxx;
1650
1651  StringRef Value = A->getValue();
1652  if (Value != "libstdc++") {
1653    getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1654      << A->getAsString(Args);
1655  }
1656
1657  return ToolChain::CST_Libstdcxx;
1658}
1659
1660static Arg *GetLastHexagonArchArg(const ArgList &Args)
1661{
1662  Arg *A = NULL;
1663
1664  for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
1665       it != ie; ++it) {
1666    if ((*it)->getOption().matches(options::OPT_march_EQ) ||
1667        (*it)->getOption().matches(options::OPT_mcpu_EQ)) {
1668      A = *it;
1669      A->claim();
1670    } else if ((*it)->getOption().matches(options::OPT_m_Joined)) {
1671      StringRef Value = (*it)->getValue(0);
1672      if (Value.startswith("v")) {
1673        A = *it;
1674        A->claim();
1675      }
1676    }
1677  }
1678  return A;
1679}
1680
1681StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args)
1682{
1683  // Select the default CPU (v4) if none was given or detection failed.
1684  Arg *A = GetLastHexagonArchArg (Args);
1685  if (A) {
1686    StringRef WhichHexagon = A->getValue();
1687    if (WhichHexagon.startswith("hexagon"))
1688      return WhichHexagon.substr(sizeof("hexagon") - 1);
1689    if (WhichHexagon != "")
1690      return WhichHexagon;
1691  }
1692
1693  return "v4";
1694}
1695// End Hexagon
1696
1697/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1698/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1699/// Currently does not support anything else but compilation.
1700
1701TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple,
1702                           const ArgList &Args)
1703  : ToolChain(D, Triple, Args) {
1704  // Path mangling to find libexec
1705  std::string Path(getDriver().Dir);
1706
1707  Path += "/../libexec";
1708  getProgramPaths().push_back(Path);
1709}
1710
1711TCEToolChain::~TCEToolChain() {
1712}
1713
1714bool TCEToolChain::IsMathErrnoDefault() const {
1715  return true;
1716}
1717
1718bool TCEToolChain::isPICDefault() const {
1719  return false;
1720}
1721
1722bool TCEToolChain::isPIEDefault() const {
1723  return false;
1724}
1725
1726bool TCEToolChain::isPICDefaultForced() const {
1727  return false;
1728}
1729
1730/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1731
1732OpenBSD::OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1733  : Generic_ELF(D, Triple, Args) {
1734  getFilePaths().push_back(getDriver().Dir + "/../lib");
1735  getFilePaths().push_back("/usr/lib");
1736}
1737
1738Tool *OpenBSD::buildAssembler() const {
1739  return new tools::openbsd::Assemble(*this);
1740}
1741
1742Tool *OpenBSD::buildLinker() const {
1743  return new tools::openbsd::Link(*this);
1744}
1745
1746/// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
1747
1748Bitrig::Bitrig(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1749  : Generic_ELF(D, Triple, Args) {
1750  getFilePaths().push_back(getDriver().Dir + "/../lib");
1751  getFilePaths().push_back("/usr/lib");
1752}
1753
1754Tool *Bitrig::buildAssembler() const {
1755  return new tools::bitrig::Assemble(*this);
1756}
1757
1758Tool *Bitrig::buildLinker() const {
1759  return new tools::bitrig::Link(*this);
1760}
1761
1762void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1763                                          ArgStringList &CC1Args) const {
1764  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1765      DriverArgs.hasArg(options::OPT_nostdincxx))
1766    return;
1767
1768  switch (GetCXXStdlibType(DriverArgs)) {
1769  case ToolChain::CST_Libcxx:
1770    addSystemInclude(DriverArgs, CC1Args,
1771                     getDriver().SysRoot + "/usr/include/c++/");
1772    break;
1773  case ToolChain::CST_Libstdcxx:
1774    addSystemInclude(DriverArgs, CC1Args,
1775                     getDriver().SysRoot + "/usr/include/c++/stdc++");
1776    addSystemInclude(DriverArgs, CC1Args,
1777                     getDriver().SysRoot + "/usr/include/c++/stdc++/backward");
1778
1779    StringRef Triple = getTriple().str();
1780    if (Triple.startswith("amd64"))
1781      addSystemInclude(DriverArgs, CC1Args,
1782                       getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" +
1783                       Triple.substr(5));
1784    else
1785      addSystemInclude(DriverArgs, CC1Args,
1786                       getDriver().SysRoot + "/usr/include/c++/stdc++/" +
1787                       Triple);
1788    break;
1789  }
1790}
1791
1792void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
1793                                 ArgStringList &CmdArgs) const {
1794  switch (GetCXXStdlibType(Args)) {
1795  case ToolChain::CST_Libcxx:
1796    CmdArgs.push_back("-lc++");
1797    CmdArgs.push_back("-lcxxrt");
1798    // Include supc++ to provide Unwind until provided by libcxx.
1799    CmdArgs.push_back("-lgcc");
1800    break;
1801  case ToolChain::CST_Libstdcxx:
1802    CmdArgs.push_back("-lstdc++");
1803    break;
1804  }
1805}
1806
1807/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1808
1809FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1810  : Generic_ELF(D, Triple, Args) {
1811
1812  // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
1813  // back to '/usr/lib' if it doesn't exist.
1814  if ((Triple.getArch() == llvm::Triple::x86 ||
1815       Triple.getArch() == llvm::Triple::ppc) &&
1816      llvm::sys::fs::exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
1817    getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
1818  else
1819    getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
1820}
1821
1822Tool *FreeBSD::buildAssembler() const {
1823  return new tools::freebsd::Assemble(*this);
1824}
1825
1826Tool *FreeBSD::buildLinker() const {
1827  return new tools::freebsd::Link(*this);
1828}
1829
1830bool FreeBSD::UseSjLjExceptions() const {
1831  // FreeBSD uses SjLj exceptions on ARM oabi.
1832  switch (getTriple().getEnvironment()) {
1833  case llvm::Triple::GNUEABI:
1834  case llvm::Triple::EABI:
1835    return false;
1836
1837  default:
1838    return (getTriple().getArch() == llvm::Triple::arm ||
1839            getTriple().getArch() == llvm::Triple::thumb);
1840  }
1841}
1842
1843/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
1844
1845NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1846  : Generic_ELF(D, Triple, Args) {
1847
1848  if (getDriver().UseStdLib) {
1849    // When targeting a 32-bit platform, try the special directory used on
1850    // 64-bit hosts, and only fall back to the main library directory if that
1851    // doesn't work.
1852    // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
1853    // what all logic is needed to emulate the '=' prefix here.
1854    if (Triple.getArch() == llvm::Triple::x86)
1855      getFilePaths().push_back("=/usr/lib/i386");
1856
1857    getFilePaths().push_back("=/usr/lib");
1858  }
1859}
1860
1861Tool *NetBSD::buildAssembler() const {
1862  return new tools::netbsd::Assemble(*this);
1863}
1864
1865Tool *NetBSD::buildLinker() const {
1866  return new tools::netbsd::Link(*this);
1867}
1868
1869ToolChain::CXXStdlibType
1870NetBSD::GetCXXStdlibType(const ArgList &Args) const {
1871  if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
1872    StringRef Value = A->getValue();
1873    if (Value == "libstdc++")
1874      return ToolChain::CST_Libstdcxx;
1875    if (Value == "libc++")
1876      return ToolChain::CST_Libcxx;
1877
1878    getDriver().Diag(diag::err_drv_invalid_stdlib_name)
1879      << A->getAsString(Args);
1880  }
1881
1882  return ToolChain::CST_Libstdcxx;
1883}
1884
1885void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1886                                          ArgStringList &CC1Args) const {
1887  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1888      DriverArgs.hasArg(options::OPT_nostdincxx))
1889    return;
1890
1891  switch (GetCXXStdlibType(DriverArgs)) {
1892  case ToolChain::CST_Libcxx:
1893    addSystemInclude(DriverArgs, CC1Args,
1894                     getDriver().SysRoot + "/usr/include/c++/");
1895    break;
1896  case ToolChain::CST_Libstdcxx:
1897    addSystemInclude(DriverArgs, CC1Args,
1898                     getDriver().SysRoot + "/usr/include/g++");
1899    addSystemInclude(DriverArgs, CC1Args,
1900                     getDriver().SysRoot + "/usr/include/g++/backward");
1901    break;
1902  }
1903}
1904
1905/// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1906
1907Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1908  : Generic_ELF(D, Triple, Args) {
1909  getFilePaths().push_back(getDriver().Dir + "/../lib");
1910  getFilePaths().push_back("/usr/lib");
1911}
1912
1913Tool *Minix::buildAssembler() const {
1914  return new tools::minix::Assemble(*this);
1915}
1916
1917Tool *Minix::buildLinker() const {
1918  return new tools::minix::Link(*this);
1919}
1920
1921/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1922
1923AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple,
1924                   const ArgList &Args)
1925  : Generic_GCC(D, Triple, Args) {
1926
1927  getProgramPaths().push_back(getDriver().getInstalledDir());
1928  if (getDriver().getInstalledDir() != getDriver().Dir)
1929    getProgramPaths().push_back(getDriver().Dir);
1930
1931  getFilePaths().push_back(getDriver().Dir + "/../lib");
1932  getFilePaths().push_back("/usr/lib");
1933  getFilePaths().push_back("/usr/sfw/lib");
1934  getFilePaths().push_back("/opt/gcc4/lib");
1935  getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
1936
1937}
1938
1939Tool *AuroraUX::buildAssembler() const {
1940  return new tools::auroraux::Assemble(*this);
1941}
1942
1943Tool *AuroraUX::buildLinker() const {
1944  return new tools::auroraux::Link(*this);
1945}
1946
1947/// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
1948
1949Solaris::Solaris(const Driver &D, const llvm::Triple& Triple,
1950                 const ArgList &Args)
1951  : Generic_GCC(D, Triple, Args) {
1952
1953  getProgramPaths().push_back(getDriver().getInstalledDir());
1954  if (getDriver().getInstalledDir() != getDriver().Dir)
1955    getProgramPaths().push_back(getDriver().Dir);
1956
1957  getFilePaths().push_back(getDriver().Dir + "/../lib");
1958  getFilePaths().push_back("/usr/lib");
1959}
1960
1961Tool *Solaris::buildAssembler() const {
1962  return new tools::solaris::Assemble(*this);
1963}
1964
1965Tool *Solaris::buildLinker() const {
1966  return new tools::solaris::Link(*this);
1967}
1968
1969/// Distribution (very bare-bones at the moment).
1970
1971enum Distro {
1972  ArchLinux,
1973  DebianLenny,
1974  DebianSqueeze,
1975  DebianWheezy,
1976  DebianJessie,
1977  Exherbo,
1978  RHEL4,
1979  RHEL5,
1980  RHEL6,
1981  Fedora13,
1982  Fedora14,
1983  Fedora15,
1984  Fedora16,
1985  FedoraRawhide,
1986  OpenSUSE,
1987  UbuntuHardy,
1988  UbuntuIntrepid,
1989  UbuntuJaunty,
1990  UbuntuKarmic,
1991  UbuntuLucid,
1992  UbuntuMaverick,
1993  UbuntuNatty,
1994  UbuntuOneiric,
1995  UbuntuPrecise,
1996  UbuntuQuantal,
1997  UbuntuRaring,
1998  UbuntuSaucy,
1999  UnknownDistro
2000};
2001
2002static bool IsRedhat(enum Distro Distro) {
2003  return (Distro >= Fedora13 && Distro <= FedoraRawhide) ||
2004         (Distro >= RHEL4    && Distro <= RHEL6);
2005}
2006
2007static bool IsOpenSUSE(enum Distro Distro) {
2008  return Distro == OpenSUSE;
2009}
2010
2011static bool IsDebian(enum Distro Distro) {
2012  return Distro >= DebianLenny && Distro <= DebianJessie;
2013}
2014
2015static bool IsUbuntu(enum Distro Distro) {
2016  return Distro >= UbuntuHardy && Distro <= UbuntuSaucy;
2017}
2018
2019static Distro DetectDistro(llvm::Triple::ArchType Arch) {
2020  OwningPtr<llvm::MemoryBuffer> File;
2021  if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
2022    StringRef Data = File.get()->getBuffer();
2023    SmallVector<StringRef, 8> Lines;
2024    Data.split(Lines, "\n");
2025    Distro Version = UnknownDistro;
2026    for (unsigned i = 0, s = Lines.size(); i != s; ++i)
2027      if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME="))
2028        Version = llvm::StringSwitch<Distro>(Lines[i].substr(17))
2029          .Case("hardy", UbuntuHardy)
2030          .Case("intrepid", UbuntuIntrepid)
2031          .Case("jaunty", UbuntuJaunty)
2032          .Case("karmic", UbuntuKarmic)
2033          .Case("lucid", UbuntuLucid)
2034          .Case("maverick", UbuntuMaverick)
2035          .Case("natty", UbuntuNatty)
2036          .Case("oneiric", UbuntuOneiric)
2037          .Case("precise", UbuntuPrecise)
2038          .Case("quantal", UbuntuQuantal)
2039          .Case("raring", UbuntuRaring)
2040          .Case("saucy", UbuntuSaucy)
2041          .Default(UnknownDistro);
2042    return Version;
2043  }
2044
2045  if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
2046    StringRef Data = File.get()->getBuffer();
2047    if (Data.startswith("Fedora release 16"))
2048      return Fedora16;
2049    else if (Data.startswith("Fedora release 15"))
2050      return Fedora15;
2051    else if (Data.startswith("Fedora release 14"))
2052      return Fedora14;
2053    else if (Data.startswith("Fedora release 13"))
2054      return Fedora13;
2055    else if (Data.startswith("Fedora release") &&
2056             Data.find("Rawhide") != StringRef::npos)
2057      return FedoraRawhide;
2058    else if (Data.startswith("Red Hat Enterprise Linux") &&
2059             Data.find("release 6") != StringRef::npos)
2060      return RHEL6;
2061    else if ((Data.startswith("Red Hat Enterprise Linux") ||
2062              Data.startswith("CentOS")) &&
2063             Data.find("release 5") != StringRef::npos)
2064      return RHEL5;
2065    else if ((Data.startswith("Red Hat Enterprise Linux") ||
2066              Data.startswith("CentOS")) &&
2067             Data.find("release 4") != StringRef::npos)
2068      return RHEL4;
2069    return UnknownDistro;
2070  }
2071
2072  if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
2073    StringRef Data = File.get()->getBuffer();
2074    if (Data[0] == '5')
2075      return DebianLenny;
2076    else if (Data.startswith("squeeze/sid") || Data[0] == '6')
2077      return DebianSqueeze;
2078    else if (Data.startswith("wheezy/sid")  || Data[0] == '7')
2079      return DebianWheezy;
2080    else if (Data.startswith("jessie/sid")  || Data[0] == '8')
2081      return DebianJessie;
2082    return UnknownDistro;
2083  }
2084
2085  if (llvm::sys::fs::exists("/etc/SuSE-release"))
2086    return OpenSUSE;
2087
2088  if (llvm::sys::fs::exists("/etc/exherbo-release"))
2089    return Exherbo;
2090
2091  if (llvm::sys::fs::exists("/etc/arch-release"))
2092    return ArchLinux;
2093
2094  return UnknownDistro;
2095}
2096
2097/// \brief Get our best guess at the multiarch triple for a target.
2098///
2099/// Debian-based systems are starting to use a multiarch setup where they use
2100/// a target-triple directory in the library and header search paths.
2101/// Unfortunately, this triple does not align with the vanilla target triple,
2102/// so we provide a rough mapping here.
2103static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
2104                                      StringRef SysRoot) {
2105  // For most architectures, just use whatever we have rather than trying to be
2106  // clever.
2107  switch (TargetTriple.getArch()) {
2108  default:
2109    return TargetTriple.str();
2110
2111    // We use the existence of '/lib/<triple>' as a directory to detect some
2112    // common linux triples that don't quite match the Clang triple for both
2113    // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
2114    // regardless of what the actual target triple is.
2115  case llvm::Triple::arm:
2116  case llvm::Triple::thumb:
2117    if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2118      if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabihf"))
2119        return "arm-linux-gnueabihf";
2120    } else {
2121      if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabi"))
2122        return "arm-linux-gnueabi";
2123    }
2124    return TargetTriple.str();
2125  case llvm::Triple::x86:
2126    if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
2127      return "i386-linux-gnu";
2128    return TargetTriple.str();
2129  case llvm::Triple::x86_64:
2130    if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
2131      return "x86_64-linux-gnu";
2132    return TargetTriple.str();
2133  case llvm::Triple::aarch64:
2134    if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64-linux-gnu"))
2135      return "aarch64-linux-gnu";
2136    return TargetTriple.str();
2137  case llvm::Triple::mips:
2138    if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu"))
2139      return "mips-linux-gnu";
2140    return TargetTriple.str();
2141  case llvm::Triple::mipsel:
2142    if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu"))
2143      return "mipsel-linux-gnu";
2144    return TargetTriple.str();
2145  case llvm::Triple::ppc:
2146    if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
2147      return "powerpc-linux-gnuspe";
2148    if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu"))
2149      return "powerpc-linux-gnu";
2150    return TargetTriple.str();
2151  case llvm::Triple::ppc64:
2152    if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu"))
2153      return "powerpc64-linux-gnu";
2154  case llvm::Triple::ppc64le:
2155    if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64le-linux-gnu"))
2156      return "powerpc64le-linux-gnu";
2157    return TargetTriple.str();
2158  }
2159}
2160
2161static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) {
2162  if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str());
2163}
2164
2165static bool isMipsR2Arch(llvm::Triple::ArchType Arch,
2166                         const ArgList &Args) {
2167  if (Arch != llvm::Triple::mips &&
2168      Arch != llvm::Triple::mipsel)
2169    return false;
2170
2171  Arg *A = Args.getLastArg(options::OPT_march_EQ,
2172                           options::OPT_mcpu_EQ,
2173                           options::OPT_mips_CPUs_Group);
2174
2175  if (!A)
2176    return false;
2177
2178  if (A->getOption().matches(options::OPT_mips_CPUs_Group))
2179    return A->getOption().matches(options::OPT_mips32r2);
2180
2181  return A->getValue() == StringRef("mips32r2");
2182}
2183
2184static StringRef getMultilibDir(const llvm::Triple &Triple,
2185                                const ArgList &Args) {
2186  if (!isMipsArch(Triple.getArch()))
2187    return Triple.isArch32Bit() ? "lib32" : "lib64";
2188
2189  // lib32 directory has a special meaning on MIPS targets.
2190  // It contains N32 ABI binaries. Use this folder if produce
2191  // code for N32 ABI only.
2192  if (hasMipsN32ABIArg(Args))
2193    return "lib32";
2194
2195  return Triple.isArch32Bit() ? "lib" : "lib64";
2196}
2197
2198Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2199  : Generic_ELF(D, Triple, Args) {
2200  llvm::Triple::ArchType Arch = Triple.getArch();
2201  std::string SysRoot = computeSysRoot(Args);
2202
2203  // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
2204  // least) put various tools in a triple-prefixed directory off of the parent
2205  // of the GCC installation. We use the GCC triple here to ensure that we end
2206  // up with tools that support the same amount of cross compiling as the
2207  // detected GCC installation. For example, if we find a GCC installation
2208  // targeting x86_64, but it is a bi-arch GCC installation, it can also be
2209  // used to target i386.
2210  // FIXME: This seems unlikely to be Linux-specific.
2211  ToolChain::path_list &PPaths = getProgramPaths();
2212  PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
2213                         GCCInstallation.getTriple().str() + "/bin").str());
2214
2215  Linker = GetProgramPath("ld");
2216
2217  Distro Distro = DetectDistro(Arch);
2218
2219  if (IsOpenSUSE(Distro) || IsUbuntu(Distro)) {
2220    ExtraOpts.push_back("-z");
2221    ExtraOpts.push_back("relro");
2222  }
2223
2224  if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
2225    ExtraOpts.push_back("-X");
2226
2227  const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::Android;
2228  const bool IsMips = isMipsArch(Arch);
2229
2230  if (IsMips && !SysRoot.empty())
2231    ExtraOpts.push_back("--sysroot=" + SysRoot);
2232
2233  // Do not use 'gnu' hash style for Mips targets because .gnu.hash
2234  // and the MIPS ABI require .dynsym to be sorted in different ways.
2235  // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
2236  // ABI requires a mapping between the GOT and the symbol table.
2237  // Android loader does not support .gnu.hash.
2238  if (!IsMips && !IsAndroid) {
2239    if (IsRedhat(Distro) || IsOpenSUSE(Distro) ||
2240        (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
2241      ExtraOpts.push_back("--hash-style=gnu");
2242
2243    if (IsDebian(Distro) || IsOpenSUSE(Distro) || Distro == UbuntuLucid ||
2244        Distro == UbuntuJaunty || Distro == UbuntuKarmic)
2245      ExtraOpts.push_back("--hash-style=both");
2246  }
2247
2248  if (IsRedhat(Distro))
2249    ExtraOpts.push_back("--no-add-needed");
2250
2251  if (Distro == DebianSqueeze || Distro == DebianWheezy ||
2252      Distro == DebianJessie || IsOpenSUSE(Distro) ||
2253      (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
2254      (IsUbuntu(Distro) && Distro >= UbuntuKarmic))
2255    ExtraOpts.push_back("--build-id");
2256
2257  if (IsOpenSUSE(Distro))
2258    ExtraOpts.push_back("--enable-new-dtags");
2259
2260  // The selection of paths to try here is designed to match the patterns which
2261  // the GCC driver itself uses, as this is part of the GCC-compatible driver.
2262  // This was determined by running GCC in a fake filesystem, creating all
2263  // possible permutations of these directories, and seeing which ones it added
2264  // to the link paths.
2265  path_list &Paths = getFilePaths();
2266
2267  const std::string Multilib = getMultilibDir(Triple, Args);
2268  const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
2269
2270  // Add the multilib suffixed paths where they are available.
2271  if (GCCInstallation.isValid()) {
2272    const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2273    const std::string &LibPath = GCCInstallation.getParentLibPath();
2274
2275    if (IsAndroid && isMipsR2Arch(Triple.getArch(), Args))
2276      addPathIfExists(GCCInstallation.getInstallPath() +
2277                          GCCInstallation.getBiarchSuffix() + "/mips-r2",
2278                      Paths);
2279    else
2280      addPathIfExists((GCCInstallation.getInstallPath() +
2281                       GCCInstallation.getBiarchSuffix()),
2282                      Paths);
2283
2284    // Sourcery CodeBench MIPS toolchain holds some libraries under
2285    // the parent prefix of the GCC installation.
2286    // FIXME: It would be cleaner to model this as a variant of multilib. IE,
2287    // instead of 'lib64' it would be 'lib/el'.
2288    std::string MultilibSuffix;
2289    appendMipsTargetSuffix(MultilibSuffix, Arch, Args);
2290
2291    // GCC cross compiling toolchains will install target libraries which ship
2292    // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
2293    // any part of the GCC installation in
2294    // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
2295    // debatable, but is the reality today. We need to search this tree even
2296    // when we have a sysroot somewhere else. It is the responsibility of
2297    // whomever is doing the cross build targetting a sysroot using a GCC
2298    // installation that is *not* within the system root to ensure two things:
2299    //
2300    //  1) Any DSOs that are linked in from this tree or from the install path
2301    //     above must be preasant on the system root and found via an
2302    //     appropriate rpath.
2303    //  2) There must not be libraries installed into
2304    //     <prefix>/<triple>/<libdir> unless they should be preferred over
2305    //     those within the system root.
2306    //
2307    // Note that this matches the GCC behavior. See the below comment for where
2308    // Clang diverges from GCC's behavior.
2309    addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + Multilib +
2310                        MultilibSuffix,
2311                    Paths);
2312
2313    // If the GCC installation we found is inside of the sysroot, we want to
2314    // prefer libraries installed in the parent prefix of the GCC installation.
2315    // It is important to *not* use these paths when the GCC installation is
2316    // outside of the system root as that can pick up unintended libraries.
2317    // This usually happens when there is an external cross compiler on the
2318    // host system, and a more minimal sysroot available that is the target of
2319    // the cross. Note that GCC does include some of these directories in some
2320    // configurations but this seems somewhere between questionable and simply
2321    // a bug.
2322    if (StringRef(LibPath).startswith(SysRoot)) {
2323      addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
2324      addPathIfExists(LibPath + "/../" + Multilib, Paths);
2325    }
2326  }
2327  addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
2328  addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
2329  addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
2330  addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
2331
2332  // Try walking via the GCC triple path in case of biarch or multiarch GCC
2333  // installations with strange symlinks.
2334  if (GCCInstallation.isValid())
2335    addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
2336                    "/../../" + Multilib, Paths);
2337
2338  // Add the non-multilib suffixed paths (if potentially different).
2339  if (GCCInstallation.isValid()) {
2340    const std::string &LibPath = GCCInstallation.getParentLibPath();
2341    const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2342    if (!GCCInstallation.getBiarchSuffix().empty())
2343      addPathIfExists(GCCInstallation.getInstallPath(), Paths);
2344
2345    // See comments above on the multilib variant for details of why this is
2346    // included even from outside the sysroot.
2347    addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths);
2348
2349    // See comments above on the multilib variant for details of why this is
2350    // only included from within the sysroot.
2351    if (StringRef(LibPath).startswith(SysRoot))
2352      addPathIfExists(LibPath, Paths);
2353  }
2354  addPathIfExists(SysRoot + "/lib", Paths);
2355  addPathIfExists(SysRoot + "/usr/lib", Paths);
2356
2357  IsPIEDefault = SanitizerArgs(*this, Args).hasZeroBaseShadow();
2358}
2359
2360bool Linux::HasNativeLLVMSupport() const {
2361  return true;
2362}
2363
2364Tool *Linux::buildLinker() const {
2365  return new tools::gnutools::Link(*this);
2366}
2367
2368Tool *Linux::buildAssembler() const {
2369  return new tools::gnutools::Assemble(*this);
2370}
2371
2372void Linux::addClangTargetOptions(const ArgList &DriverArgs,
2373                                  ArgStringList &CC1Args) const {
2374  const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2375  bool UseInitArrayDefault
2376    = V >= Generic_GCC::GCCVersion::Parse("4.7.0") ||
2377      getTriple().getArch() == llvm::Triple::aarch64 ||
2378      getTriple().getEnvironment() == llvm::Triple::Android;
2379  if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2380                         options::OPT_fno_use_init_array,
2381                         UseInitArrayDefault))
2382    CC1Args.push_back("-fuse-init-array");
2383}
2384
2385std::string Linux::computeSysRoot(const ArgList &Args) const {
2386  if (!getDriver().SysRoot.empty())
2387    return getDriver().SysRoot;
2388
2389  if (!GCCInstallation.isValid() || !isMipsArch(getTriple().getArch()))
2390    return std::string();
2391
2392  std::string Path =
2393    (GCCInstallation.getInstallPath() +
2394     "/../../../../" + GCCInstallation.getTriple().str() + "/libc").str();
2395  appendMipsTargetSuffix(Path, getTriple().getArch(), Args);
2396
2397  return llvm::sys::fs::exists(Path) ? Path : "";
2398}
2399
2400void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2401                                      ArgStringList &CC1Args) const {
2402  const Driver &D = getDriver();
2403  std::string SysRoot = computeSysRoot(DriverArgs);
2404
2405  if (DriverArgs.hasArg(options::OPT_nostdinc))
2406    return;
2407
2408  if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
2409    addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
2410
2411  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2412    SmallString<128> P(D.ResourceDir);
2413    llvm::sys::path::append(P, "include");
2414    addSystemInclude(DriverArgs, CC1Args, P.str());
2415  }
2416
2417  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2418    return;
2419
2420  // Check for configure-time C include directories.
2421  StringRef CIncludeDirs(C_INCLUDE_DIRS);
2422  if (CIncludeDirs != "") {
2423    SmallVector<StringRef, 5> dirs;
2424    CIncludeDirs.split(dirs, ":");
2425    for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
2426         I != E; ++I) {
2427      StringRef Prefix = llvm::sys::path::is_absolute(*I) ? SysRoot : "";
2428      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
2429    }
2430    return;
2431  }
2432
2433  // Lacking those, try to detect the correct set of system includes for the
2434  // target triple.
2435
2436  // Sourcery CodeBench and modern FSF Mips toolchains put extern C
2437  // system includes under three additional directories.
2438  if (GCCInstallation.isValid() && isMipsArch(getTriple().getArch())) {
2439    addExternCSystemIncludeIfExists(
2440        DriverArgs, CC1Args, GCCInstallation.getInstallPath() + "/include");
2441
2442    addExternCSystemIncludeIfExists(
2443        DriverArgs, CC1Args,
2444        GCCInstallation.getInstallPath() + "/../../../../" +
2445            GCCInstallation.getTriple().str() + "/libc/usr/include");
2446  }
2447
2448  // Implement generic Debian multiarch support.
2449  const StringRef X86_64MultiarchIncludeDirs[] = {
2450    "/usr/include/x86_64-linux-gnu",
2451
2452    // FIXME: These are older forms of multiarch. It's not clear that they're
2453    // in use in any released version of Debian, so we should consider
2454    // removing them.
2455    "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"
2456  };
2457  const StringRef X86MultiarchIncludeDirs[] = {
2458    "/usr/include/i386-linux-gnu",
2459
2460    // FIXME: These are older forms of multiarch. It's not clear that they're
2461    // in use in any released version of Debian, so we should consider
2462    // removing them.
2463    "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",
2464    "/usr/include/i486-linux-gnu"
2465  };
2466  const StringRef AArch64MultiarchIncludeDirs[] = {
2467    "/usr/include/aarch64-linux-gnu"
2468  };
2469  const StringRef ARMMultiarchIncludeDirs[] = {
2470    "/usr/include/arm-linux-gnueabi"
2471  };
2472  const StringRef ARMHFMultiarchIncludeDirs[] = {
2473    "/usr/include/arm-linux-gnueabihf"
2474  };
2475  const StringRef MIPSMultiarchIncludeDirs[] = {
2476    "/usr/include/mips-linux-gnu"
2477  };
2478  const StringRef MIPSELMultiarchIncludeDirs[] = {
2479    "/usr/include/mipsel-linux-gnu"
2480  };
2481  const StringRef PPCMultiarchIncludeDirs[] = {
2482    "/usr/include/powerpc-linux-gnu"
2483  };
2484  const StringRef PPC64MultiarchIncludeDirs[] = {
2485    "/usr/include/powerpc64-linux-gnu"
2486  };
2487  ArrayRef<StringRef> MultiarchIncludeDirs;
2488  if (getTriple().getArch() == llvm::Triple::x86_64) {
2489    MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
2490  } else if (getTriple().getArch() == llvm::Triple::x86) {
2491    MultiarchIncludeDirs = X86MultiarchIncludeDirs;
2492  } else if (getTriple().getArch() == llvm::Triple::aarch64) {
2493    MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
2494  } else if (getTriple().getArch() == llvm::Triple::arm) {
2495    if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
2496      MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
2497    else
2498      MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
2499  } else if (getTriple().getArch() == llvm::Triple::mips) {
2500    MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
2501  } else if (getTriple().getArch() == llvm::Triple::mipsel) {
2502    MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
2503  } else if (getTriple().getArch() == llvm::Triple::ppc) {
2504    MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
2505  } else if (getTriple().getArch() == llvm::Triple::ppc64) {
2506    MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
2507  }
2508  for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(),
2509                                     E = MultiarchIncludeDirs.end();
2510       I != E; ++I) {
2511    if (llvm::sys::fs::exists(SysRoot + *I)) {
2512      addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + *I);
2513      break;
2514    }
2515  }
2516
2517  if (getTriple().getOS() == llvm::Triple::RTEMS)
2518    return;
2519
2520  // Add an include of '/include' directly. This isn't provided by default by
2521  // system GCCs, but is often used with cross-compiling GCCs, and harmless to
2522  // add even when Clang is acting as-if it were a system compiler.
2523  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
2524
2525  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
2526}
2527
2528/// \brief Helper to add the three variant paths for a libstdc++ installation.
2529/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
2530                                                const ArgList &DriverArgs,
2531                                                ArgStringList &CC1Args) {
2532  if (!llvm::sys::fs::exists(Base))
2533    return false;
2534  addSystemInclude(DriverArgs, CC1Args, Base);
2535  addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir);
2536  addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
2537  return true;
2538}
2539
2540/// \brief Helper to add an extra variant path for an (Ubuntu) multilib
2541/// libstdc++ installation.
2542/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
2543                                                Twine TargetArchDir,
2544                                                Twine MultiLibSuffix,
2545                                                const ArgList &DriverArgs,
2546                                                ArgStringList &CC1Args) {
2547  if (!addLibStdCXXIncludePaths(Base+Suffix, TargetArchDir + MultiLibSuffix,
2548                                DriverArgs, CC1Args))
2549    return false;
2550
2551  addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir + Suffix
2552                   + MultiLibSuffix);
2553  return true;
2554}
2555
2556void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2557                                         ArgStringList &CC1Args) const {
2558  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2559      DriverArgs.hasArg(options::OPT_nostdincxx))
2560    return;
2561
2562  // Check if libc++ has been enabled and provide its include paths if so.
2563  if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
2564    // libc++ is always installed at a fixed path on Linux currently.
2565    addSystemInclude(DriverArgs, CC1Args,
2566                     getDriver().SysRoot + "/usr/include/c++/v1");
2567    return;
2568  }
2569
2570  // We need a detected GCC installation on Linux to provide libstdc++'s
2571  // headers. We handled the libc++ case above.
2572  if (!GCCInstallation.isValid())
2573    return;
2574
2575  // By default, look for the C++ headers in an include directory adjacent to
2576  // the lib directory of the GCC installation. Note that this is expect to be
2577  // equivalent to '/usr/include/c++/X.Y' in almost all cases.
2578  StringRef LibDir = GCCInstallation.getParentLibPath();
2579  StringRef InstallDir = GCCInstallation.getInstallPath();
2580  StringRef Version = GCCInstallation.getVersion().Text;
2581  StringRef TripleStr = GCCInstallation.getTriple().str();
2582
2583  if (addLibStdCXXIncludePaths(
2584          LibDir.str() + "/../include", "/c++/" + Version.str(), TripleStr,
2585          GCCInstallation.getBiarchSuffix(), DriverArgs, CC1Args))
2586    return;
2587
2588  const std::string IncludePathCandidates[] = {
2589    // Gentoo is weird and places its headers inside the GCC install, so if the
2590    // first attempt to find the headers fails, try this pattern.
2591    InstallDir.str() + "/include/g++-v4",
2592    // Android standalone toolchain has C++ headers in yet another place.
2593    LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.str(),
2594    // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
2595    // without a subdirectory corresponding to the gcc version.
2596    LibDir.str() + "/../include/c++",
2597  };
2598
2599  for (unsigned i = 0; i < llvm::array_lengthof(IncludePathCandidates); ++i) {
2600    if (addLibStdCXXIncludePaths(
2601            IncludePathCandidates[i],
2602            (TripleStr + GCCInstallation.getBiarchSuffix()), DriverArgs,
2603            CC1Args))
2604      break;
2605  }
2606}
2607
2608bool Linux::isPIEDefault() const {
2609  return IsPIEDefault;
2610}
2611
2612/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2613
2614DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2615  : Generic_ELF(D, Triple, Args) {
2616
2617  // Path mangling to find libexec
2618  getProgramPaths().push_back(getDriver().getInstalledDir());
2619  if (getDriver().getInstalledDir() != getDriver().Dir)
2620    getProgramPaths().push_back(getDriver().Dir);
2621
2622  getFilePaths().push_back(getDriver().Dir + "/../lib");
2623  getFilePaths().push_back("/usr/lib");
2624  if (llvm::sys::fs::exists("/usr/lib/gcc47"))
2625    getFilePaths().push_back("/usr/lib/gcc47");
2626  else
2627    getFilePaths().push_back("/usr/lib/gcc44");
2628}
2629
2630Tool *DragonFly::buildAssembler() const {
2631  return new tools::dragonfly::Assemble(*this);
2632}
2633
2634Tool *DragonFly::buildLinker() const {
2635  return new tools::dragonfly::Link(*this);
2636}
2637