ToolChains.cpp revision 79cbbdc8affe52591f7ee487a789639aa38331ec 
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
12#ifdef HAVE_CLANG_CONFIG_H
13# include "clang/Config/config.h"
14#endif
15
16#include "clang/Driver/Arg.h"
17#include "clang/Driver/ArgList.h"
18#include "clang/Driver/Compilation.h"
19#include "clang/Driver/Driver.h"
20#include "clang/Driver/DriverDiagnostic.h"
21#include "clang/Driver/HostInfo.h"
22#include "clang/Driver/ObjCRuntime.h"
23#include "clang/Driver/OptTable.h"
24#include "clang/Driver/Option.h"
25#include "clang/Driver/Options.h"
26#include "clang/Basic/Version.h"
27
28#include "llvm/ADT/SmallString.h"
29#include "llvm/ADT/StringExtras.h"
30#include "llvm/ADT/StringSwitch.h"
31#include "llvm/ADT/STLExtras.h"
32#include "llvm/Support/ErrorHandling.h"
33#include "llvm/Support/FileSystem.h"
34#include "llvm/Support/MemoryBuffer.h"
35#include "llvm/Support/raw_ostream.h"
36#include "llvm/Support/Path.h"
37#include "llvm/Support/system_error.h"
38
39#include <cstdlib> // ::getenv
40
41#include "llvm/Config/config.h" // for CXX_INCLUDE_ROOT
42
43using namespace clang::driver;
44using namespace clang::driver::toolchains;
45using namespace clang;
46
47/// Darwin - Darwin tool chain for i386 and x86_64.
48
49Darwin::Darwin(const HostInfo &Host, const llvm::Triple& Triple)
50  : ToolChain(Host, Triple), TargetInitialized(false),
51    ARCRuntimeForSimulator(ARCSimulator_None),
52    LibCXXForSimulator(LibCXXSimulator_None)
53{
54  // Compute the initial Darwin version based on the host.
55  bool HadExtra;
56  std::string OSName = Triple.getOSName();
57  if (!Driver::GetReleaseVersion(&OSName.c_str()[6],
58                                 DarwinVersion[0], DarwinVersion[1],
59                                 DarwinVersion[2], HadExtra))
60    getDriver().Diag(diag::err_drv_invalid_darwin_version) << OSName;
61
62  llvm::raw_string_ostream(MacosxVersionMin)
63    << "10." << std::max(0, (int)DarwinVersion[0] - 4) << '.'
64    << DarwinVersion[1];
65}
66
67types::ID Darwin::LookupTypeForExtension(const char *Ext) const {
68  types::ID Ty = types::lookupTypeForExtension(Ext);
69
70  // Darwin always preprocesses assembly files (unless -x is used explicitly).
71  if (Ty == types::TY_PP_Asm)
72    return types::TY_Asm;
73
74  return Ty;
75}
76
77bool Darwin::HasNativeLLVMSupport() const {
78  return true;
79}
80
81bool Darwin::hasARCRuntime() const {
82  // FIXME: Remove this once there is a proper way to detect an ARC runtime
83  // for the simulator.
84  switch (ARCRuntimeForSimulator) {
85  case ARCSimulator_None:
86    break;
87  case ARCSimulator_HasARCRuntime:
88    return true;
89  case ARCSimulator_NoARCRuntime:
90    return false;
91  }
92
93  if (isTargetIPhoneOS())
94    return !isIPhoneOSVersionLT(5);
95  else
96    return !isMacosxVersionLT(10, 7);
97}
98
99/// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
100void Darwin::configureObjCRuntime(ObjCRuntime &runtime) const {
101  if (runtime.getKind() != ObjCRuntime::NeXT)
102    return ToolChain::configureObjCRuntime(runtime);
103
104  runtime.HasARC = runtime.HasWeak = hasARCRuntime();
105
106  // So far, objc_terminate is only available in iOS 5.
107  // FIXME: do the simulator logic properly.
108  if (!ARCRuntimeForSimulator && isTargetIPhoneOS())
109    runtime.HasTerminate = !isIPhoneOSVersionLT(5);
110  else
111    runtime.HasTerminate = false;
112}
113
114/// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
115bool Darwin::hasBlocksRuntime() const {
116  if (isTargetIPhoneOS())
117    return !isIPhoneOSVersionLT(3, 2);
118  else
119    return !isMacosxVersionLT(10, 6);
120}
121
122static const char *GetArmArchForMArch(StringRef Value) {
123  return llvm::StringSwitch<const char*>(Value)
124    .Case("armv6k", "armv6")
125    .Case("armv5tej", "armv5")
126    .Case("xscale", "xscale")
127    .Case("armv4t", "armv4t")
128    .Case("armv7", "armv7")
129    .Cases("armv7a", "armv7-a", "armv7")
130    .Cases("armv7r", "armv7-r", "armv7")
131    .Cases("armv7m", "armv7-m", "armv7")
132    .Default(0);
133}
134
135static const char *GetArmArchForMCpu(StringRef Value) {
136  return llvm::StringSwitch<const char *>(Value)
137    .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "arm926ej-s","armv5")
138    .Cases("arm10e", "arm10tdmi", "armv5")
139    .Cases("arm1020t", "arm1020e", "arm1022e", "arm1026ej-s", "armv5")
140    .Case("xscale", "xscale")
141    .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s",
142           "arm1176jzf-s", "cortex-m0", "armv6")
143    .Cases("cortex-a8", "cortex-r4", "cortex-m3", "cortex-a9", "armv7")
144    .Default(0);
145}
146
147StringRef Darwin::getDarwinArchName(const ArgList &Args) const {
148  switch (getTriple().getArch()) {
149  default:
150    return getArchName();
151
152  case llvm::Triple::thumb:
153  case llvm::Triple::arm: {
154    if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
155      if (const char *Arch = GetArmArchForMArch(A->getValue(Args)))
156        return Arch;
157
158    if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
159      if (const char *Arch = GetArmArchForMCpu(A->getValue(Args)))
160        return Arch;
161
162    return "arm";
163  }
164  }
165}
166
167Darwin::~Darwin() {
168  // Free tool implementations.
169  for (llvm::DenseMap<unsigned, Tool*>::iterator
170         it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
171    delete it->second;
172}
173
174std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
175                                                types::ID InputType) const {
176  llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
177
178  // If the target isn't initialized (e.g., an unknown Darwin platform, return
179  // the default triple).
180  if (!isTargetInitialized())
181    return Triple.getTriple();
182
183  unsigned Version[3];
184  getTargetVersion(Version);
185
186  llvm::SmallString<16> Str;
187  llvm::raw_svector_ostream(Str)
188    << (isTargetIPhoneOS() ? "ios" : "macosx")
189    << Version[0] << "." << Version[1] << "." << Version[2];
190  Triple.setOSName(Str.str());
191
192  return Triple.getTriple();
193}
194
195Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA,
196                         const ActionList &Inputs) const {
197  Action::ActionClass Key;
198
199  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) {
200    // Fallback to llvm-gcc for i386 kext compiles, we don't support that ABI.
201    if (Inputs.size() == 1 &&
202        types::isCXX(Inputs[0]->getType()) &&
203        getTriple().isOSDarwin() &&
204        getTriple().getArch() == llvm::Triple::x86 &&
205        (C.getArgs().getLastArg(options::OPT_fapple_kext) ||
206         C.getArgs().getLastArg(options::OPT_mkernel)))
207      Key = JA.getKind();
208    else
209      Key = Action::AnalyzeJobClass;
210  } else
211    Key = JA.getKind();
212
213  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
214                                             options::OPT_no_integrated_as,
215                                             IsIntegratedAssemblerDefault());
216
217  Tool *&T = Tools[Key];
218  if (!T) {
219    switch (Key) {
220    case Action::InputClass:
221    case Action::BindArchClass:
222      llvm_unreachable("Invalid tool kind.");
223    case Action::PreprocessJobClass:
224      T = new tools::darwin::Preprocess(*this); break;
225    case Action::AnalyzeJobClass:
226      T = new tools::Clang(*this); break;
227    case Action::PrecompileJobClass:
228    case Action::CompileJobClass:
229      T = new tools::darwin::Compile(*this); break;
230    case Action::AssembleJobClass: {
231      if (UseIntegratedAs)
232        T = new tools::ClangAs(*this);
233      else
234        T = new tools::darwin::Assemble(*this);
235      break;
236    }
237    case Action::LinkJobClass:
238      T = new tools::darwin::Link(*this); break;
239    case Action::LipoJobClass:
240      T = new tools::darwin::Lipo(*this); break;
241    case Action::DsymutilJobClass:
242      T = new tools::darwin::Dsymutil(*this); break;
243    case Action::VerifyJobClass:
244      T = new tools::darwin::VerifyDebug(*this); break;
245    }
246  }
247
248  return *T;
249}
250
251
252DarwinClang::DarwinClang(const HostInfo &Host, const llvm::Triple& Triple)
253  : Darwin(Host, Triple)
254{
255  getProgramPaths().push_back(getDriver().getInstalledDir());
256  if (getDriver().getInstalledDir() != getDriver().Dir)
257    getProgramPaths().push_back(getDriver().Dir);
258
259  // We expect 'as', 'ld', etc. to be adjacent to our install dir.
260  getProgramPaths().push_back(getDriver().getInstalledDir());
261  if (getDriver().getInstalledDir() != getDriver().Dir)
262    getProgramPaths().push_back(getDriver().Dir);
263
264  // For fallback, we need to know how to find the GCC cc1 executables, so we
265  // also add the GCC libexec paths. This is legacy code that can be removed
266  // once fallback is no longer useful.
267  AddGCCLibexecPath(DarwinVersion[0]);
268  AddGCCLibexecPath(DarwinVersion[0] - 2);
269  AddGCCLibexecPath(DarwinVersion[0] - 1);
270  AddGCCLibexecPath(DarwinVersion[0] + 1);
271  AddGCCLibexecPath(DarwinVersion[0] + 2);
272}
273
274void DarwinClang::AddGCCLibexecPath(unsigned darwinVersion) {
275  std::string ToolChainDir = "i686-apple-darwin";
276  ToolChainDir += llvm::utostr(darwinVersion);
277  ToolChainDir += "/4.2.1";
278
279  std::string Path = getDriver().Dir;
280  Path += "/../llvm-gcc-4.2/libexec/gcc/";
281  Path += ToolChainDir;
282  getProgramPaths().push_back(Path);
283
284  Path = "/usr/llvm-gcc-4.2/libexec/gcc/";
285  Path += ToolChainDir;
286  getProgramPaths().push_back(Path);
287}
288
289void DarwinClang::AddLinkSearchPathArgs(const ArgList &Args,
290                                       ArgStringList &CmdArgs) const {
291  // The Clang toolchain uses explicit paths for internal libraries.
292
293  // Unfortunately, we still might depend on a few of the libraries that are
294  // only available in the gcc library directory (in particular
295  // libstdc++.dylib). For now, hardcode the path to the known install location.
296  // FIXME: This should get ripped out someday.  However, when building on
297  // 10.6 (darwin10), we're still relying on this to find libstdc++.dylib.
298  llvm::sys::Path P(getDriver().Dir);
299  P.eraseComponent(); // .../usr/bin -> ../usr
300  P.appendComponent("llvm-gcc-4.2");
301  P.appendComponent("lib");
302  P.appendComponent("gcc");
303  switch (getTriple().getArch()) {
304  default:
305    llvm_unreachable("Invalid Darwin arch!");
306  case llvm::Triple::x86:
307  case llvm::Triple::x86_64:
308    P.appendComponent("i686-apple-darwin10");
309    break;
310  case llvm::Triple::arm:
311  case llvm::Triple::thumb:
312    P.appendComponent("arm-apple-darwin10");
313    break;
314  case llvm::Triple::ppc:
315  case llvm::Triple::ppc64:
316    P.appendComponent("powerpc-apple-darwin10");
317    break;
318  }
319  P.appendComponent("4.2.1");
320
321  // Determine the arch specific GCC subdirectory.
322  const char *ArchSpecificDir = 0;
323  switch (getTriple().getArch()) {
324  default:
325    break;
326  case llvm::Triple::arm:
327  case llvm::Triple::thumb: {
328    std::string Triple = ComputeLLVMTriple(Args);
329    StringRef TripleStr = Triple;
330    if (TripleStr.startswith("armv5") || TripleStr.startswith("thumbv5"))
331      ArchSpecificDir = "v5";
332    else if (TripleStr.startswith("armv6") || TripleStr.startswith("thumbv6"))
333      ArchSpecificDir = "v6";
334    else if (TripleStr.startswith("armv7") || TripleStr.startswith("thumbv7"))
335      ArchSpecificDir = "v7";
336    break;
337  }
338  case llvm::Triple::ppc64:
339    ArchSpecificDir = "ppc64";
340    break;
341  case llvm::Triple::x86_64:
342    ArchSpecificDir = "x86_64";
343    break;
344  }
345
346  if (ArchSpecificDir) {
347    P.appendComponent(ArchSpecificDir);
348    bool Exists;
349    if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
350      CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
351    P.eraseComponent();
352  }
353
354  bool Exists;
355  if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
356    CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
357}
358
359void DarwinClang::AddLinkARCArgs(const ArgList &Args,
360                                 ArgStringList &CmdArgs) const {
361
362  CmdArgs.push_back("-force_load");
363  llvm::sys::Path P(getDriver().ClangExecutable);
364  P.eraseComponent(); // 'clang'
365  P.eraseComponent(); // 'bin'
366  P.appendComponent("lib");
367  P.appendComponent("arc");
368  P.appendComponent("libarclite_");
369  std::string s = P.str();
370  // Mash in the platform.
371  if (isTargetIOSSimulator())
372    s += "iphonesimulator";
373  else if (isTargetIPhoneOS())
374    s += "iphoneos";
375  // FIXME: Remove this once we depend fully on -mios-simulator-version-min.
376  else if (ARCRuntimeForSimulator != ARCSimulator_None)
377    s += "iphonesimulator";
378  else
379    s += "macosx";
380  s += ".a";
381
382  CmdArgs.push_back(Args.MakeArgString(s));
383}
384
385void DarwinClang::AddLinkRuntimeLib(const ArgList &Args,
386                                    ArgStringList &CmdArgs,
387                                    const char *DarwinStaticLib) const {
388  llvm::sys::Path P(getDriver().ResourceDir);
389  P.appendComponent("lib");
390  P.appendComponent("darwin");
391  P.appendComponent(DarwinStaticLib);
392
393  // For now, allow missing resource libraries to support developers who may
394  // not have compiler-rt checked out or integrated into their build.
395  bool Exists;
396  if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
397    CmdArgs.push_back(Args.MakeArgString(P.str()));
398}
399
400void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
401                                        ArgStringList &CmdArgs) const {
402  // Darwin only supports the compiler-rt based runtime libraries.
403  switch (GetRuntimeLibType(Args)) {
404  case ToolChain::RLT_CompilerRT:
405    break;
406  default:
407    getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
408      << Args.getLastArg(options::OPT_rtlib_EQ)->getValue(Args) << "darwin";
409    return;
410  }
411
412  // Darwin doesn't support real static executables, don't link any runtime
413  // libraries with -static.
414  if (Args.hasArg(options::OPT_static))
415    return;
416
417  // Reject -static-libgcc for now, we can deal with this when and if someone
418  // cares. This is useful in situations where someone wants to statically link
419  // something like libstdc++, and needs its runtime support routines.
420  if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
421    getDriver().Diag(diag::err_drv_unsupported_opt)
422      << A->getAsString(Args);
423    return;
424  }
425
426  // If we are building profile support, link that library in.
427  if (Args.hasArg(options::OPT_fprofile_arcs) ||
428      Args.hasArg(options::OPT_fprofile_generate) ||
429      Args.hasArg(options::OPT_fcreate_profile) ||
430      Args.hasArg(options::OPT_coverage)) {
431    // Select the appropriate runtime library for the target.
432    if (isTargetIPhoneOS()) {
433      AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_ios.a");
434    } else {
435      AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_osx.a");
436    }
437  }
438
439  // Add ASAN runtime library, if required. Dynamic libraries and bundles
440  // should not be linked with the runtime library.
441  if (Args.hasFlag(options::OPT_faddress_sanitizer,
442                   options::OPT_fno_address_sanitizer, false)) {
443    if (Args.hasArg(options::OPT_dynamiclib) ||
444        Args.hasArg(options::OPT_bundle)) return;
445    if (isTargetIPhoneOS()) {
446      getDriver().Diag(diag::err_drv_clang_unsupported_per_platform)
447        << "-faddress-sanitizer";
448    } else {
449      AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.asan_osx.a");
450
451      // The ASAN runtime library requires C++ and CoreFoundation.
452      AddCXXStdlibLibArgs(Args, CmdArgs);
453      CmdArgs.push_back("-framework");
454      CmdArgs.push_back("CoreFoundation");
455    }
456  }
457
458  // Otherwise link libSystem, then the dynamic runtime library, and finally any
459  // target specific static runtime library.
460  CmdArgs.push_back("-lSystem");
461
462  // Select the dynamic runtime library and the target specific static library.
463  if (isTargetIPhoneOS()) {
464    // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
465    // it never went into the SDK.
466    // Linking against libgcc_s.1 isn't needed for iOS 5.0+
467    if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator())
468      CmdArgs.push_back("-lgcc_s.1");
469
470    // We currently always need a static runtime library for iOS.
471    AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
472  } else {
473    // The dynamic runtime library was merged with libSystem for 10.6 and
474    // beyond; only 10.4 and 10.5 need an additional runtime library.
475    if (isMacosxVersionLT(10, 5))
476      CmdArgs.push_back("-lgcc_s.10.4");
477    else if (isMacosxVersionLT(10, 6))
478      CmdArgs.push_back("-lgcc_s.10.5");
479
480    // For OS X, we thought we would only need a static runtime library when
481    // targeting 10.4, to provide versions of the static functions which were
482    // omitted from 10.4.dylib.
483    //
484    // Unfortunately, that turned out to not be true, because Darwin system
485    // headers can still use eprintf on i386, and it is not exported from
486    // libSystem. Therefore, we still must provide a runtime library just for
487    // the tiny tiny handful of projects that *might* use that symbol.
488    if (isMacosxVersionLT(10, 5)) {
489      AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
490    } else {
491      if (getTriple().getArch() == llvm::Triple::x86)
492        AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.eprintf.a");
493      AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
494    }
495  }
496}
497
498static inline StringRef SimulatorVersionDefineName() {
499  return "__IPHONE_OS_VERSION_MIN_REQUIRED";
500}
501
502/// \brief Parse the simulator version define:
503/// __IPHONE_OS_VERSION_MIN_REQUIRED=([0-9])([0-9][0-9])([0-9][0-9])
504// and return the grouped values as integers, e.g:
505//   __IPHONE_OS_VERSION_MIN_REQUIRED=40201
506// will return Major=4, Minor=2, Micro=1.
507static bool GetVersionFromSimulatorDefine(StringRef define,
508                                          unsigned &Major, unsigned &Minor,
509                                          unsigned &Micro) {
510  assert(define.startswith(SimulatorVersionDefineName()));
511  StringRef name, version;
512  llvm::tie(name, version) = define.split('=');
513  if (version.empty())
514    return false;
515  std::string verstr = version.str();
516  char *end;
517  unsigned num = (unsigned) strtol(verstr.c_str(), &end, 10);
518  if (*end != '\0')
519    return false;
520  Major = num / 10000;
521  num = num % 10000;
522  Minor = num / 100;
523  Micro = num % 100;
524  return true;
525}
526
527void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
528  const OptTable &Opts = getDriver().getOpts();
529
530  Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
531  Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
532  Arg *iOSSimVersion = Args.getLastArg(
533    options::OPT_mios_simulator_version_min_EQ);
534
535  // FIXME: HACK! When compiling for the simulator we don't get a
536  // '-miphoneos-version-min' to help us know whether there is an ARC runtime
537  // or not; try to parse a __IPHONE_OS_VERSION_MIN_REQUIRED
538  // define passed in command-line.
539  if (!iOSVersion && !iOSSimVersion) {
540    for (arg_iterator it = Args.filtered_begin(options::OPT_D),
541           ie = Args.filtered_end(); it != ie; ++it) {
542      StringRef define = (*it)->getValue(Args);
543      if (define.startswith(SimulatorVersionDefineName())) {
544        unsigned Major = 0, Minor = 0, Micro = 0;
545        if (GetVersionFromSimulatorDefine(define, Major, Minor, Micro) &&
546            Major < 10 && Minor < 100 && Micro < 100) {
547          ARCRuntimeForSimulator = Major < 5 ? ARCSimulator_NoARCRuntime
548                                             : ARCSimulator_HasARCRuntime;
549          LibCXXForSimulator = Major < 5 ? LibCXXSimulator_NotAvailable
550                                         : LibCXXSimulator_Available;
551        }
552        break;
553      }
554    }
555  }
556
557  if (OSXVersion && (iOSVersion || iOSSimVersion)) {
558    getDriver().Diag(diag::err_drv_argument_not_allowed_with)
559          << OSXVersion->getAsString(Args)
560          << (iOSVersion ? iOSVersion : iOSSimVersion)->getAsString(Args);
561    iOSVersion = iOSSimVersion = 0;
562  } else if (iOSVersion && iOSSimVersion) {
563    getDriver().Diag(diag::err_drv_argument_not_allowed_with)
564          << iOSVersion->getAsString(Args)
565          << iOSSimVersion->getAsString(Args);
566    iOSSimVersion = 0;
567  } else if (!OSXVersion && !iOSVersion && !iOSSimVersion) {
568    // If no deployment target was specified on the command line, check for
569    // environment defines.
570    StringRef OSXTarget;
571    StringRef iOSTarget;
572    StringRef iOSSimTarget;
573    if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
574      OSXTarget = env;
575    if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
576      iOSTarget = env;
577    if (char *env = ::getenv("IOS_SIMULATOR_DEPLOYMENT_TARGET"))
578      iOSSimTarget = env;
579
580    // If no '-miphoneos-version-min' specified on the command line and
581    // IPHONEOS_DEPLOYMENT_TARGET is not defined, see if we can set the default
582    // based on isysroot.
583    if (iOSTarget.empty()) {
584      if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
585        StringRef first, second;
586        StringRef isysroot = A->getValue(Args);
587        llvm::tie(first, second) = isysroot.split(StringRef("SDKs/iPhoneOS"));
588        if (second != "")
589          iOSTarget = second.substr(0,3);
590      }
591    }
592
593    // If no OSX or iOS target has been specified and we're compiling for armv7,
594    // go ahead as assume we're targeting iOS.
595    if (OSXTarget.empty() && iOSTarget.empty())
596      if (getDarwinArchName(Args) == "armv7")
597        iOSTarget = "0.0";
598
599    // Handle conflicting deployment targets
600    //
601    // FIXME: Don't hardcode default here.
602
603    // Do not allow conflicts with the iOS simulator target.
604    if (!iOSSimTarget.empty() && (!OSXTarget.empty() || !iOSTarget.empty())) {
605      getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
606        << "IOS_SIMULATOR_DEPLOYMENT_TARGET"
607        << (!OSXTarget.empty() ? "MACOSX_DEPLOYMENT_TARGET" :
608            "IPHONEOS_DEPLOYMENT_TARGET");
609    }
610
611    // Allow conflicts among OSX and iOS for historical reasons, but choose the
612    // default platform.
613    if (!OSXTarget.empty() && !iOSTarget.empty()) {
614      if (getTriple().getArch() == llvm::Triple::arm ||
615          getTriple().getArch() == llvm::Triple::thumb)
616        OSXTarget = "";
617      else
618        iOSTarget = "";
619    }
620
621    if (!OSXTarget.empty()) {
622      const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
623      OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget);
624      Args.append(OSXVersion);
625    } else if (!iOSTarget.empty()) {
626      const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
627      iOSVersion = Args.MakeJoinedArg(0, O, iOSTarget);
628      Args.append(iOSVersion);
629    } else if (!iOSSimTarget.empty()) {
630      const Option *O = Opts.getOption(
631        options::OPT_mios_simulator_version_min_EQ);
632      iOSSimVersion = Args.MakeJoinedArg(0, O, iOSSimTarget);
633      Args.append(iOSSimVersion);
634    } else {
635      // Otherwise, assume we are targeting OS X.
636      const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
637      OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin);
638      Args.append(OSXVersion);
639    }
640  }
641
642  // Reject invalid architecture combinations.
643  if (iOSSimVersion && (getTriple().getArch() != llvm::Triple::x86 &&
644                        getTriple().getArch() != llvm::Triple::x86_64)) {
645    getDriver().Diag(diag::err_drv_invalid_arch_for_deployment_target)
646      << getTriple().getArchName() << iOSSimVersion->getAsString(Args);
647  }
648
649  // Set the tool chain target information.
650  unsigned Major, Minor, Micro;
651  bool HadExtra;
652  if (OSXVersion) {
653    assert((!iOSVersion && !iOSSimVersion) && "Unknown target platform!");
654    if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor,
655                                   Micro, HadExtra) || HadExtra ||
656        Major != 10 || Minor >= 100 || Micro >= 100)
657      getDriver().Diag(diag::err_drv_invalid_version_number)
658        << OSXVersion->getAsString(Args);
659  } else {
660    const Arg *Version = iOSVersion ? iOSVersion : iOSSimVersion;
661    assert(Version && "Unknown target platform!");
662    if (!Driver::GetReleaseVersion(Version->getValue(Args), Major, Minor,
663                                   Micro, HadExtra) || HadExtra ||
664        Major >= 10 || Minor >= 100 || Micro >= 100)
665      getDriver().Diag(diag::err_drv_invalid_version_number)
666        << Version->getAsString(Args);
667  }
668
669  bool IsIOSSim = bool(iOSSimVersion);
670
671  // In GCC, the simulator historically was treated as being OS X in some
672  // contexts, like determining the link logic, despite generally being called
673  // with an iOS deployment target. For compatibility, we detect the
674  // simulator as iOS + x86, and treat it differently in a few contexts.
675  if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
676                     getTriple().getArch() == llvm::Triple::x86_64))
677    IsIOSSim = true;
678
679  setTarget(/*IsIPhoneOS=*/ !OSXVersion, Major, Minor, Micro, IsIOSSim);
680}
681
682void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
683                                      ArgStringList &CmdArgs) const {
684  CXXStdlibType Type = GetCXXStdlibType(Args);
685
686  switch (Type) {
687  case ToolChain::CST_Libcxx:
688    CmdArgs.push_back("-lc++");
689    break;
690
691  case ToolChain::CST_Libstdcxx: {
692    // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
693    // it was previously found in the gcc lib dir. However, for all the Darwin
694    // platforms we care about it was -lstdc++.6, so we search for that
695    // explicitly if we can't see an obvious -lstdc++ candidate.
696
697    // Check in the sysroot first.
698    bool Exists;
699    if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
700      llvm::sys::Path P(A->getValue(Args));
701      P.appendComponent("usr");
702      P.appendComponent("lib");
703      P.appendComponent("libstdc++.dylib");
704
705      if (llvm::sys::fs::exists(P.str(), Exists) || !Exists) {
706        P.eraseComponent();
707        P.appendComponent("libstdc++.6.dylib");
708        if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
709          CmdArgs.push_back(Args.MakeArgString(P.str()));
710          return;
711        }
712      }
713    }
714
715    // Otherwise, look in the root.
716    // FIXME: This should be removed someday when we don't have to care about
717    // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
718    if ((llvm::sys::fs::exists("/usr/lib/libstdc++.dylib", Exists) || !Exists)&&
719      (!llvm::sys::fs::exists("/usr/lib/libstdc++.6.dylib", Exists) && Exists)){
720      CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
721      return;
722    }
723
724    // Otherwise, let the linker search.
725    CmdArgs.push_back("-lstdc++");
726    break;
727  }
728  }
729}
730
731void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
732                                   ArgStringList &CmdArgs) const {
733
734  // For Darwin platforms, use the compiler-rt-based support library
735  // instead of the gcc-provided one (which is also incidentally
736  // only present in the gcc lib dir, which makes it hard to find).
737
738  llvm::sys::Path P(getDriver().ResourceDir);
739  P.appendComponent("lib");
740  P.appendComponent("darwin");
741  P.appendComponent("libclang_rt.cc_kext.a");
742
743  // For now, allow missing resource libraries to support developers who may
744  // not have compiler-rt checked out or integrated into their build.
745  bool Exists;
746  if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
747    CmdArgs.push_back(Args.MakeArgString(P.str()));
748}
749
750DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
751                                      const char *BoundArch) const {
752  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
753  const OptTable &Opts = getDriver().getOpts();
754
755  // FIXME: We really want to get out of the tool chain level argument
756  // translation business, as it makes the driver functionality much
757  // more opaque. For now, we follow gcc closely solely for the
758  // purpose of easily achieving feature parity & testability. Once we
759  // have something that works, we should reevaluate each translation
760  // and try to push it down into tool specific logic.
761
762  for (ArgList::const_iterator it = Args.begin(),
763         ie = Args.end(); it != ie; ++it) {
764    Arg *A = *it;
765
766    if (A->getOption().matches(options::OPT_Xarch__)) {
767      // Skip this argument unless the architecture matches either the toolchain
768      // triple arch, or the arch being bound.
769      //
770      // FIXME: Canonicalize name.
771      StringRef XarchArch = A->getValue(Args, 0);
772      if (!(XarchArch == getArchName()  ||
773            (BoundArch && XarchArch == BoundArch)))
774        continue;
775
776      Arg *OriginalArg = A;
777      unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1));
778      unsigned Prev = Index;
779      Arg *XarchArg = Opts.ParseOneArg(Args, Index);
780
781      // If the argument parsing failed or more than one argument was
782      // consumed, the -Xarch_ argument's parameter tried to consume
783      // extra arguments. Emit an error and ignore.
784      //
785      // We also want to disallow any options which would alter the
786      // driver behavior; that isn't going to work in our model. We
787      // use isDriverOption() as an approximation, although things
788      // like -O4 are going to slip through.
789      if (!XarchArg || Index > Prev + 1) {
790        getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
791          << A->getAsString(Args);
792        continue;
793      } else if (XarchArg->getOption().isDriverOption()) {
794        getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
795          << A->getAsString(Args);
796        continue;
797      }
798
799      XarchArg->setBaseArg(A);
800      A = XarchArg;
801
802      DAL->AddSynthesizedArg(A);
803
804      // Linker input arguments require custom handling. The problem is that we
805      // have already constructed the phase actions, so we can not treat them as
806      // "input arguments".
807      if (A->getOption().isLinkerInput()) {
808        // Convert the argument into individual Zlinker_input_args.
809        for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
810          DAL->AddSeparateArg(OriginalArg,
811                              Opts.getOption(options::OPT_Zlinker_input),
812                              A->getValue(Args, i));
813
814        }
815        continue;
816      }
817    }
818
819    // Sob. These is strictly gcc compatible for the time being. Apple
820    // gcc translates options twice, which means that self-expanding
821    // options add duplicates.
822    switch ((options::ID) A->getOption().getID()) {
823    default:
824      DAL->append(A);
825      break;
826
827    case options::OPT_mkernel:
828    case options::OPT_fapple_kext:
829      DAL->append(A);
830      DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
831      break;
832
833    case options::OPT_dependency_file:
834      DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF),
835                          A->getValue(Args));
836      break;
837
838    case options::OPT_gfull:
839      DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
840      DAL->AddFlagArg(A,
841               Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
842      break;
843
844    case options::OPT_gused:
845      DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
846      DAL->AddFlagArg(A,
847             Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
848      break;
849
850    case options::OPT_shared:
851      DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
852      break;
853
854    case options::OPT_fconstant_cfstrings:
855      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
856      break;
857
858    case options::OPT_fno_constant_cfstrings:
859      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
860      break;
861
862    case options::OPT_Wnonportable_cfstrings:
863      DAL->AddFlagArg(A,
864                      Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
865      break;
866
867    case options::OPT_Wno_nonportable_cfstrings:
868      DAL->AddFlagArg(A,
869                   Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
870      break;
871
872    case options::OPT_fpascal_strings:
873      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
874      break;
875
876    case options::OPT_fno_pascal_strings:
877      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
878      break;
879    }
880  }
881
882  if (getTriple().getArch() == llvm::Triple::x86 ||
883      getTriple().getArch() == llvm::Triple::x86_64)
884    if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
885      DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2");
886
887  // Add the arch options based on the particular spelling of -arch, to match
888  // how the driver driver works.
889  if (BoundArch) {
890    StringRef Name = BoundArch;
891    const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ);
892    const Option *MArch = Opts.getOption(options::OPT_march_EQ);
893
894    // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
895    // which defines the list of which architectures we accept.
896    if (Name == "ppc")
897      ;
898    else if (Name == "ppc601")
899      DAL->AddJoinedArg(0, MCpu, "601");
900    else if (Name == "ppc603")
901      DAL->AddJoinedArg(0, MCpu, "603");
902    else if (Name == "ppc604")
903      DAL->AddJoinedArg(0, MCpu, "604");
904    else if (Name == "ppc604e")
905      DAL->AddJoinedArg(0, MCpu, "604e");
906    else if (Name == "ppc750")
907      DAL->AddJoinedArg(0, MCpu, "750");
908    else if (Name == "ppc7400")
909      DAL->AddJoinedArg(0, MCpu, "7400");
910    else if (Name == "ppc7450")
911      DAL->AddJoinedArg(0, MCpu, "7450");
912    else if (Name == "ppc970")
913      DAL->AddJoinedArg(0, MCpu, "970");
914
915    else if (Name == "ppc64")
916      DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
917
918    else if (Name == "i386")
919      ;
920    else if (Name == "i486")
921      DAL->AddJoinedArg(0, MArch, "i486");
922    else if (Name == "i586")
923      DAL->AddJoinedArg(0, MArch, "i586");
924    else if (Name == "i686")
925      DAL->AddJoinedArg(0, MArch, "i686");
926    else if (Name == "pentium")
927      DAL->AddJoinedArg(0, MArch, "pentium");
928    else if (Name == "pentium2")
929      DAL->AddJoinedArg(0, MArch, "pentium2");
930    else if (Name == "pentpro")
931      DAL->AddJoinedArg(0, MArch, "pentiumpro");
932    else if (Name == "pentIIm3")
933      DAL->AddJoinedArg(0, MArch, "pentium2");
934
935    else if (Name == "x86_64")
936      DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
937
938    else if (Name == "arm")
939      DAL->AddJoinedArg(0, MArch, "armv4t");
940    else if (Name == "armv4t")
941      DAL->AddJoinedArg(0, MArch, "armv4t");
942    else if (Name == "armv5")
943      DAL->AddJoinedArg(0, MArch, "armv5tej");
944    else if (Name == "xscale")
945      DAL->AddJoinedArg(0, MArch, "xscale");
946    else if (Name == "armv6")
947      DAL->AddJoinedArg(0, MArch, "armv6k");
948    else if (Name == "armv7")
949      DAL->AddJoinedArg(0, MArch, "armv7a");
950
951    else
952      llvm_unreachable("invalid Darwin arch");
953  }
954
955  // Add an explicit version min argument for the deployment target. We do this
956  // after argument translation because -Xarch_ arguments may add a version min
957  // argument.
958  AddDeploymentTarget(*DAL);
959
960  // Validate the C++ standard library choice.
961  CXXStdlibType Type = GetCXXStdlibType(*DAL);
962  if (Type == ToolChain::CST_Libcxx) {
963    switch (LibCXXForSimulator) {
964    case LibCXXSimulator_None:
965      // Handle non-simulator cases.
966      if (isTargetIPhoneOS()) {
967        if (isIPhoneOSVersionLT(5, 0)) {
968          getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment)
969            << "iOS 5.0";
970        }
971      }
972      break;
973    case LibCXXSimulator_NotAvailable:
974      getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment)
975        << "iOS 5.0";
976      break;
977    case LibCXXSimulator_Available:
978      break;
979    }
980  }
981
982  return DAL;
983}
984
985bool Darwin::IsUnwindTablesDefault() const {
986  // FIXME: Gross; we should probably have some separate target
987  // definition, possibly even reusing the one in clang.
988  return getArchName() == "x86_64";
989}
990
991bool Darwin::UseDwarfDebugFlags() const {
992  if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
993    return S[0] != '\0';
994  return false;
995}
996
997bool Darwin::UseSjLjExceptions() const {
998  // Darwin uses SjLj exceptions on ARM.
999  return (getTriple().getArch() == llvm::Triple::arm ||
1000          getTriple().getArch() == llvm::Triple::thumb);
1001}
1002
1003const char *Darwin::GetDefaultRelocationModel() const {
1004  return "pic";
1005}
1006
1007const char *Darwin::GetForcedPicModel() const {
1008  if (getArchName() == "x86_64")
1009    return "pic";
1010  return 0;
1011}
1012
1013bool Darwin::SupportsProfiling() const {
1014  // Profiling instrumentation is only supported on x86.
1015  return getArchName() == "i386" || getArchName() == "x86_64";
1016}
1017
1018bool Darwin::SupportsObjCGC() const {
1019  // Garbage collection is supported everywhere except on iPhone OS.
1020  return !isTargetIPhoneOS();
1021}
1022
1023std::string
1024Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args,
1025                                                types::ID InputType) const {
1026  return ComputeLLVMTriple(Args, InputType);
1027}
1028
1029/// Generic_GCC - A tool chain using the 'gcc' command to perform
1030/// all subcommands; this relies on gcc translating the majority of
1031/// command line options.
1032
1033/// \brief Parse a GCCVersion object out of a string of text.
1034///
1035/// This is the primary means of forming GCCVersion objects.
1036/*static*/
1037Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) {
1038  const GCCVersion BadVersion = { VersionText.str(), -1, -1, -1, "" };
1039  std::pair<StringRef, StringRef> First = VersionText.split('.');
1040  std::pair<StringRef, StringRef> Second = First.second.split('.');
1041
1042  GCCVersion GoodVersion = { VersionText.str(), -1, -1, -1, "" };
1043  if (First.first.getAsInteger(10, GoodVersion.Major) ||
1044      GoodVersion.Major < 0)
1045    return BadVersion;
1046  if (Second.first.getAsInteger(10, GoodVersion.Minor) ||
1047      GoodVersion.Minor < 0)
1048    return BadVersion;
1049
1050  // First look for a number prefix and parse that if present. Otherwise just
1051  // stash the entire patch string in the suffix, and leave the number
1052  // unspecified. This covers versions strings such as:
1053  //   4.4
1054  //   4.4.0
1055  //   4.4.x
1056  //   4.4.2-rc4
1057  //   4.4.x-patched
1058  // And retains any patch number it finds.
1059  StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
1060  if (!PatchText.empty()) {
1061    if (unsigned EndNumber = PatchText.find_first_not_of("0123456789")) {
1062      // Try to parse the number and any suffix.
1063      if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1064          GoodVersion.Patch < 0)
1065        return BadVersion;
1066      GoodVersion.PatchSuffix = PatchText.substr(EndNumber).str();
1067    }
1068  }
1069
1070  return GoodVersion;
1071}
1072
1073/// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering.
1074bool Generic_GCC::GCCVersion::operator<(const GCCVersion &RHS) const {
1075  if (Major < RHS.Major) return true; if (Major > RHS.Major) return false;
1076  if (Minor < RHS.Minor) return true; if (Minor > RHS.Minor) return false;
1077
1078  // Note that we rank versions with *no* patch specified is better than ones
1079  // hard-coding a patch version. Thus if the RHS has no patch, it always
1080  // wins, and the LHS only wins if it has no patch and the RHS does have
1081  // a patch.
1082  if (RHS.Patch == -1) return true;   if (Patch == -1) return false;
1083  if (Patch < RHS.Patch) return true; if (Patch > RHS.Patch) return false;
1084
1085  // Finally, between completely tied version numbers, the version with the
1086  // suffix loses as we prefer full releases.
1087  if (RHS.PatchSuffix.empty()) return true;
1088  return false;
1089}
1090
1091/// \brief Construct a GCCInstallationDetector from the driver.
1092///
1093/// This performs all of the autodetection and sets up the various paths.
1094/// Once constructed, a GCCInstallation is esentially immutable.
1095Generic_GCC::GCCInstallationDetector::GCCInstallationDetector(const Driver &D)
1096  : IsValid(false),
1097    GccTriple(D.DefaultHostTriple) {
1098  // FIXME: Using CXX_INCLUDE_ROOT is here is a bit of a hack, but
1099  // avoids adding yet another option to configure/cmake.
1100  // It would probably be cleaner to break it in two variables
1101  // CXX_GCC_ROOT with just /foo/bar
1102  // CXX_GCC_VER with 4.5.2
1103  // Then we would have
1104  // CXX_INCLUDE_ROOT = CXX_GCC_ROOT/include/c++/CXX_GCC_VER
1105  // and this function would return
1106  // CXX_GCC_ROOT/lib/gcc/CXX_INCLUDE_ARCH/CXX_GCC_VER
1107  llvm::SmallString<128> CxxIncludeRoot(CXX_INCLUDE_ROOT);
1108  if (CxxIncludeRoot != "") {
1109    // This is of the form /foo/bar/include/c++/4.5.2/
1110    if (CxxIncludeRoot.back() == '/')
1111      llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the /
1112    StringRef Version = llvm::sys::path::filename(CxxIncludeRoot);
1113    llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the version
1114    llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the c++
1115    llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the include
1116    GccInstallPath = CxxIncludeRoot.str();
1117    GccInstallPath.append("/lib/gcc/");
1118    GccInstallPath.append(CXX_INCLUDE_ARCH);
1119    GccInstallPath.append("/");
1120    GccInstallPath.append(Version);
1121    GccParentLibPath = GccInstallPath + "/../../..";
1122    IsValid = true;
1123    return;
1124  }
1125
1126  llvm::Triple::ArchType HostArch = llvm::Triple(GccTriple).getArch();
1127  // The library directories which may contain GCC installations.
1128  SmallVector<StringRef, 4> CandidateLibDirs;
1129  // The compatible GCC triples for this particular architecture.
1130  SmallVector<StringRef, 10> CandidateTriples;
1131  CollectLibDirsAndTriples(HostArch, CandidateLibDirs, CandidateTriples);
1132
1133  // Always include the default host triple as the final fallback if no
1134  // specific triple is detected.
1135  CandidateTriples.push_back(D.DefaultHostTriple);
1136
1137  // Compute the set of prefixes for our search.
1138  SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1139                                       D.PrefixDirs.end());
1140  Prefixes.push_back(D.SysRoot);
1141  Prefixes.push_back(D.SysRoot + "/usr");
1142  Prefixes.push_back(D.InstalledDir + "/..");
1143
1144  // Loop over the various components which exist and select the best GCC
1145  // installation available. GCC installs are ranked by version number.
1146  Version = GCCVersion::Parse("0.0.0");
1147  for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) {
1148    if (!llvm::sys::fs::exists(Prefixes[i]))
1149      continue;
1150    for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) {
1151      const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str();
1152      if (!llvm::sys::fs::exists(LibDir))
1153        continue;
1154      for (unsigned k = 0, ke = CandidateTriples.size(); k < ke; ++k)
1155        ScanLibDirForGCCTriple(HostArch, LibDir, CandidateTriples[k]);
1156    }
1157  }
1158}
1159
1160/*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1161    llvm::Triple::ArchType HostArch, SmallVectorImpl<StringRef> &LibDirs,
1162    SmallVectorImpl<StringRef> &Triples) {
1163  if (HostArch == llvm::Triple::arm || HostArch == llvm::Triple::thumb) {
1164    static const char *const ARMLibDirs[] = { "/lib" };
1165    static const char *const ARMTriples[] = { "arm-linux-gnueabi" };
1166    LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs));
1167    Triples.append(ARMTriples, ARMTriples + llvm::array_lengthof(ARMTriples));
1168  } else if (HostArch == llvm::Triple::x86_64) {
1169    static const char *const X86_64LibDirs[] = { "/lib64", "/lib" };
1170    static const char *const X86_64Triples[] = {
1171      "x86_64-linux-gnu",
1172      "x86_64-unknown-linux-gnu",
1173      "x86_64-pc-linux-gnu",
1174      "x86_64-redhat-linux6E",
1175      "x86_64-redhat-linux",
1176      "x86_64-suse-linux",
1177      "x86_64-manbo-linux-gnu",
1178      "x86_64-linux-gnu",
1179      "x86_64-slackware-linux"
1180    };
1181    LibDirs.append(X86_64LibDirs,
1182                   X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1183    Triples.append(X86_64Triples,
1184                   X86_64Triples + llvm::array_lengthof(X86_64Triples));
1185  } else if (HostArch == llvm::Triple::x86) {
1186    static const char *const X86LibDirs[] = { "/lib32", "/lib" };
1187    static const char *const X86Triples[] = {
1188      "i686-linux-gnu",
1189      "i686-pc-linux-gnu",
1190      "i486-linux-gnu",
1191      "i386-linux-gnu",
1192      "i686-redhat-linux",
1193      "i586-redhat-linux",
1194      "i386-redhat-linux",
1195      "i586-suse-linux",
1196      "i486-slackware-linux"
1197    };
1198    LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1199    Triples.append(X86Triples, X86Triples + llvm::array_lengthof(X86Triples));
1200  } else if (HostArch == llvm::Triple::mips) {
1201    static const char *const MIPSLibDirs[] = { "/lib" };
1202    static const char *const MIPSTriples[] = { "mips-linux-gnu" };
1203    LibDirs.append(MIPSLibDirs,
1204                   MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1205    Triples.append(MIPSTriples,
1206                   MIPSTriples + llvm::array_lengthof(MIPSTriples));
1207  } else if (HostArch == llvm::Triple::mipsel) {
1208    static const char *const MIPSELLibDirs[] = { "/lib" };
1209    static const char *const MIPSELTriples[] = { "mipsel-linux-gnu" };
1210    LibDirs.append(MIPSELLibDirs,
1211                   MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1212    Triples.append(MIPSELTriples,
1213                   MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1214  } else if (HostArch == llvm::Triple::ppc) {
1215    static const char *const PPCLibDirs[] = { "/lib32", "/lib" };
1216    static const char *const PPCTriples[] = {
1217      "powerpc-linux-gnu",
1218      "powerpc-unknown-linux-gnu",
1219      "powerpc-suse-linux"
1220    };
1221    LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1222    Triples.append(PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples));
1223  } else if (HostArch == llvm::Triple::ppc64) {
1224    static const char *const PPC64LibDirs[] = { "/lib64", "/lib" };
1225    static const char *const PPC64Triples[] = {
1226      "powerpc64-unknown-linux-gnu",
1227      "powerpc64-suse-linux",
1228      "ppc64-redhat-linux"
1229    };
1230    LibDirs.append(PPC64LibDirs,
1231                   PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1232    Triples.append(PPC64Triples,
1233                   PPC64Triples + llvm::array_lengthof(PPC64Triples));
1234  }
1235}
1236
1237void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
1238    llvm::Triple::ArchType HostArch, const std::string &LibDir,
1239    StringRef CandidateTriple) {
1240  // There are various different suffixes involving the triple we
1241  // check for. We also record what is necessary to walk from each back
1242  // up to the lib directory.
1243  const std::string Suffixes[] = {
1244    "/gcc/" + CandidateTriple.str(),
1245    "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
1246
1247    // Ubuntu has a strange mis-matched pair of triples that this happens to
1248    // match.
1249    // FIXME: It may be worthwhile to generalize this and look for a second
1250    // triple.
1251    "/i386-linux-gnu/gcc/" + CandidateTriple.str()
1252  };
1253  const std::string InstallSuffixes[] = {
1254    "/../../..",
1255    "/../../../..",
1256    "/../../../.."
1257  };
1258  // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
1259  const unsigned NumSuffixes = (llvm::array_lengthof(Suffixes) -
1260                                (HostArch != llvm::Triple::x86));
1261  for (unsigned i = 0; i < NumSuffixes; ++i) {
1262    StringRef Suffix = Suffixes[i];
1263    llvm::error_code EC;
1264    for (llvm::sys::fs::directory_iterator LI(LibDir + Suffix, EC), LE;
1265         !EC && LI != LE; LI = LI.increment(EC)) {
1266      StringRef VersionText = llvm::sys::path::filename(LI->path());
1267      GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1268      static const GCCVersion MinVersion = { "4.1.1", 4, 1, 1, "" };
1269      if (CandidateVersion < MinVersion)
1270        continue;
1271      if (CandidateVersion <= Version)
1272        continue;
1273
1274      // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1275      // in what would normally be GccInstallPath and put the 64-bit
1276      // libs in a subdirectory named 64. We need the 64-bit libs
1277      // for linking.
1278      bool UseSlash64 = false;
1279      if (HostArch == llvm::Triple::ppc64 &&
1280            llvm::sys::fs::exists(LI->path() + "/64/crtbegin.o"))
1281        UseSlash64 = true;
1282
1283      if (!llvm::sys::fs::exists(LI->path() + "/crtbegin.o"))
1284        continue;
1285
1286      Version = CandidateVersion;
1287      GccTriple = CandidateTriple.str();
1288      // FIXME: We hack together the directory name here instead of
1289      // using LI to ensure stable path separators across Windows and
1290      // Linux.
1291      GccInstallPath = LibDir + Suffixes[i] + "/" + VersionText.str();
1292      GccParentLibPath = GccInstallPath + InstallSuffixes[i];
1293      if (UseSlash64) GccInstallPath = GccInstallPath + "/64";
1294      IsValid = true;
1295    }
1296  }
1297}
1298
1299Generic_GCC::Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple)
1300  : ToolChain(Host, Triple), GCCInstallation(getDriver()) {
1301  getProgramPaths().push_back(getDriver().getInstalledDir());
1302  if (getDriver().getInstalledDir() != getDriver().Dir)
1303    getProgramPaths().push_back(getDriver().Dir);
1304}
1305
1306Generic_GCC::~Generic_GCC() {
1307  // Free tool implementations.
1308  for (llvm::DenseMap<unsigned, Tool*>::iterator
1309         it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
1310    delete it->second;
1311}
1312
1313Tool &Generic_GCC::SelectTool(const Compilation &C,
1314                              const JobAction &JA,
1315                              const ActionList &Inputs) const {
1316  Action::ActionClass Key;
1317  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1318    Key = Action::AnalyzeJobClass;
1319  else
1320    Key = JA.getKind();
1321
1322  Tool *&T = Tools[Key];
1323  if (!T) {
1324    switch (Key) {
1325    case Action::InputClass:
1326    case Action::BindArchClass:
1327      llvm_unreachable("Invalid tool kind.");
1328    case Action::PreprocessJobClass:
1329      T = new tools::gcc::Preprocess(*this); break;
1330    case Action::PrecompileJobClass:
1331      T = new tools::gcc::Precompile(*this); break;
1332    case Action::AnalyzeJobClass:
1333      T = new tools::Clang(*this); break;
1334    case Action::CompileJobClass:
1335      T = new tools::gcc::Compile(*this); break;
1336    case Action::AssembleJobClass:
1337      T = new tools::gcc::Assemble(*this); break;
1338    case Action::LinkJobClass:
1339      T = new tools::gcc::Link(*this); break;
1340
1341      // This is a bit ungeneric, but the only platform using a driver
1342      // driver is Darwin.
1343    case Action::LipoJobClass:
1344      T = new tools::darwin::Lipo(*this); break;
1345    case Action::DsymutilJobClass:
1346      T = new tools::darwin::Dsymutil(*this); break;
1347    case Action::VerifyJobClass:
1348      T = new tools::darwin::VerifyDebug(*this); break;
1349    }
1350  }
1351
1352  return *T;
1353}
1354
1355bool Generic_GCC::IsUnwindTablesDefault() const {
1356  // FIXME: Gross; we should probably have some separate target
1357  // definition, possibly even reusing the one in clang.
1358  return getArchName() == "x86_64";
1359}
1360
1361const char *Generic_GCC::GetDefaultRelocationModel() const {
1362  return "static";
1363}
1364
1365const char *Generic_GCC::GetForcedPicModel() const {
1366  return 0;
1367}
1368/// Hexagon Toolchain
1369
1370Hexagon_TC::Hexagon_TC(const HostInfo &Host, const llvm::Triple& Triple)
1371  : ToolChain(Host, Triple) {
1372  getProgramPaths().push_back(getDriver().getInstalledDir());
1373  if (getDriver().getInstalledDir() != getDriver().Dir.c_str())
1374    getProgramPaths().push_back(getDriver().Dir);
1375}
1376
1377Hexagon_TC::~Hexagon_TC() {
1378  // Free tool implementations.
1379  for (llvm::DenseMap<unsigned, Tool*>::iterator
1380         it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
1381    delete it->second;
1382}
1383
1384Tool &Hexagon_TC::SelectTool(const Compilation &C,
1385                             const JobAction &JA,
1386                             const ActionList &Inputs) const {
1387  Action::ActionClass Key;
1388  //   if (JA.getKind () == Action::CompileJobClass)
1389  //     Key = JA.getKind ();
1390  //     else
1391
1392  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1393    Key = Action::AnalyzeJobClass;
1394  else
1395    Key = JA.getKind();
1396  //   if ((JA.getKind () == Action::CompileJobClass)
1397  //     && (JA.getType () != types::TY_LTO_BC)) {
1398  //     Key = JA.getKind ();
1399  //   }
1400
1401  Tool *&T = Tools[Key];
1402  if (!T) {
1403    switch (Key) {
1404    case Action::InputClass:
1405    case Action::BindArchClass:
1406      assert(0 && "Invalid tool kind.");
1407    case Action::AnalyzeJobClass:
1408      T = new tools::Clang(*this); break;
1409    case Action::AssembleJobClass:
1410      T = new tools::hexagon::Assemble(*this); break;
1411    case Action::LinkJobClass:
1412      T = new tools::hexagon::Link(*this); break;
1413    default:
1414      assert(false && "Unsupported action for Hexagon target.");
1415    }
1416  }
1417
1418  return *T;
1419}
1420
1421bool Hexagon_TC::IsUnwindTablesDefault() const {
1422  // FIXME: Gross; we should probably have some separate target
1423  // definition, possibly even reusing the one in clang.
1424  return getArchName() == "x86_64";
1425}
1426
1427const char *Hexagon_TC::GetDefaultRelocationModel() const {
1428  return "static";
1429}
1430
1431const char *Hexagon_TC::GetForcedPicModel() const {
1432  return 0;
1433} // End Hexagon
1434
1435
1436/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1437/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1438/// Currently does not support anything else but compilation.
1439
1440TCEToolChain::TCEToolChain(const HostInfo &Host, const llvm::Triple& Triple)
1441  : ToolChain(Host, Triple) {
1442  // Path mangling to find libexec
1443  std::string Path(getDriver().Dir);
1444
1445  Path += "/../libexec";
1446  getProgramPaths().push_back(Path);
1447}
1448
1449TCEToolChain::~TCEToolChain() {
1450  for (llvm::DenseMap<unsigned, Tool*>::iterator
1451           it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
1452      delete it->second;
1453}
1454
1455bool TCEToolChain::IsMathErrnoDefault() const {
1456  return true;
1457}
1458
1459bool TCEToolChain::IsUnwindTablesDefault() const {
1460  return false;
1461}
1462
1463const char *TCEToolChain::GetDefaultRelocationModel() const {
1464  return "static";
1465}
1466
1467const char *TCEToolChain::GetForcedPicModel() const {
1468  return 0;
1469}
1470
1471Tool &TCEToolChain::SelectTool(const Compilation &C,
1472                            const JobAction &JA,
1473                               const ActionList &Inputs) const {
1474  Action::ActionClass Key;
1475  Key = Action::AnalyzeJobClass;
1476
1477  Tool *&T = Tools[Key];
1478  if (!T) {
1479    switch (Key) {
1480    case Action::PreprocessJobClass:
1481      T = new tools::gcc::Preprocess(*this); break;
1482    case Action::AnalyzeJobClass:
1483      T = new tools::Clang(*this); break;
1484    default:
1485     llvm_unreachable("Unsupported action for TCE target.");
1486    }
1487  }
1488  return *T;
1489}
1490
1491/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1492
1493OpenBSD::OpenBSD(const HostInfo &Host, const llvm::Triple& Triple)
1494  : Generic_ELF(Host, Triple) {
1495  getFilePaths().push_back(getDriver().Dir + "/../lib");
1496  getFilePaths().push_back("/usr/lib");
1497}
1498
1499Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA,
1500                          const ActionList &Inputs) const {
1501  Action::ActionClass Key;
1502  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1503    Key = Action::AnalyzeJobClass;
1504  else
1505    Key = JA.getKind();
1506
1507  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1508                                             options::OPT_no_integrated_as,
1509                                             IsIntegratedAssemblerDefault());
1510
1511  Tool *&T = Tools[Key];
1512  if (!T) {
1513    switch (Key) {
1514    case Action::AssembleJobClass: {
1515      if (UseIntegratedAs)
1516        T = new tools::ClangAs(*this);
1517      else
1518        T = new tools::openbsd::Assemble(*this);
1519      break;
1520    }
1521    case Action::LinkJobClass:
1522      T = new tools::openbsd::Link(*this); break;
1523    default:
1524      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1525    }
1526  }
1527
1528  return *T;
1529}
1530
1531/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1532
1533FreeBSD::FreeBSD(const HostInfo &Host, const llvm::Triple& Triple)
1534  : Generic_ELF(Host, Triple) {
1535
1536  // Determine if we are compiling 32-bit code on an x86_64 platform.
1537  bool Lib32 = false;
1538  if (Triple.getArch() == llvm::Triple::x86 &&
1539      llvm::Triple(getDriver().DefaultHostTriple).getArch() ==
1540        llvm::Triple::x86_64)
1541    Lib32 = true;
1542
1543  if (Triple.getArch() == llvm::Triple::ppc &&
1544      llvm::Triple(getDriver().DefaultHostTriple).getArch() ==
1545        llvm::Triple::ppc64)
1546    Lib32 = true;
1547
1548  if (Lib32) {
1549    getFilePaths().push_back("/usr/lib32");
1550  } else {
1551    getFilePaths().push_back("/usr/lib");
1552  }
1553}
1554
1555Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA,
1556                          const ActionList &Inputs) const {
1557  Action::ActionClass Key;
1558  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1559    Key = Action::AnalyzeJobClass;
1560  else
1561    Key = JA.getKind();
1562
1563  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1564                                             options::OPT_no_integrated_as,
1565                                             IsIntegratedAssemblerDefault());
1566
1567  Tool *&T = Tools[Key];
1568  if (!T) {
1569    switch (Key) {
1570    case Action::AssembleJobClass:
1571      if (UseIntegratedAs)
1572        T = new tools::ClangAs(*this);
1573      else
1574        T = new tools::freebsd::Assemble(*this);
1575      break;
1576    case Action::LinkJobClass:
1577      T = new tools::freebsd::Link(*this); break;
1578    default:
1579      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1580    }
1581  }
1582
1583  return *T;
1584}
1585
1586/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
1587
1588NetBSD::NetBSD(const HostInfo &Host, const llvm::Triple& Triple,
1589               const llvm::Triple& ToolTriple)
1590  : Generic_ELF(Host, Triple), ToolTriple(ToolTriple) {
1591
1592  // Determine if we are compiling 32-bit code on an x86_64 platform.
1593  bool Lib32 = false;
1594  if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
1595      Triple.getArch() == llvm::Triple::x86)
1596    Lib32 = true;
1597
1598  if (getDriver().UseStdLib) {
1599    if (Lib32)
1600      getFilePaths().push_back("=/usr/lib/i386");
1601    else
1602      getFilePaths().push_back("=/usr/lib");
1603  }
1604}
1605
1606Tool &NetBSD::SelectTool(const Compilation &C, const JobAction &JA,
1607                         const ActionList &Inputs) const {
1608  Action::ActionClass Key;
1609  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1610    Key = Action::AnalyzeJobClass;
1611  else
1612    Key = JA.getKind();
1613
1614  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1615                                             options::OPT_no_integrated_as,
1616                                             IsIntegratedAssemblerDefault());
1617
1618  Tool *&T = Tools[Key];
1619  if (!T) {
1620    switch (Key) {
1621    case Action::AssembleJobClass:
1622      if (UseIntegratedAs)
1623        T = new tools::ClangAs(*this);
1624      else
1625        T = new tools::netbsd::Assemble(*this, ToolTriple);
1626      break;
1627    case Action::LinkJobClass:
1628      T = new tools::netbsd::Link(*this, ToolTriple);
1629      break;
1630    default:
1631      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1632    }
1633  }
1634
1635  return *T;
1636}
1637
1638/// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1639
1640Minix::Minix(const HostInfo &Host, const llvm::Triple& Triple)
1641  : Generic_ELF(Host, Triple) {
1642  getFilePaths().push_back(getDriver().Dir + "/../lib");
1643  getFilePaths().push_back("/usr/lib");
1644}
1645
1646Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA,
1647                        const ActionList &Inputs) const {
1648  Action::ActionClass Key;
1649  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1650    Key = Action::AnalyzeJobClass;
1651  else
1652    Key = JA.getKind();
1653
1654  Tool *&T = Tools[Key];
1655  if (!T) {
1656    switch (Key) {
1657    case Action::AssembleJobClass:
1658      T = new tools::minix::Assemble(*this); break;
1659    case Action::LinkJobClass:
1660      T = new tools::minix::Link(*this); break;
1661    default:
1662      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1663    }
1664  }
1665
1666  return *T;
1667}
1668
1669/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1670
1671AuroraUX::AuroraUX(const HostInfo &Host, const llvm::Triple& Triple)
1672  : Generic_GCC(Host, Triple) {
1673
1674  getProgramPaths().push_back(getDriver().getInstalledDir());
1675  if (getDriver().getInstalledDir() != getDriver().Dir)
1676    getProgramPaths().push_back(getDriver().Dir);
1677
1678  getFilePaths().push_back(getDriver().Dir + "/../lib");
1679  getFilePaths().push_back("/usr/lib");
1680  getFilePaths().push_back("/usr/sfw/lib");
1681  getFilePaths().push_back("/opt/gcc4/lib");
1682  getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
1683
1684}
1685
1686Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA,
1687                           const ActionList &Inputs) const {
1688  Action::ActionClass Key;
1689  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1690    Key = Action::AnalyzeJobClass;
1691  else
1692    Key = JA.getKind();
1693
1694  Tool *&T = Tools[Key];
1695  if (!T) {
1696    switch (Key) {
1697    case Action::AssembleJobClass:
1698      T = new tools::auroraux::Assemble(*this); break;
1699    case Action::LinkJobClass:
1700      T = new tools::auroraux::Link(*this); break;
1701    default:
1702      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1703    }
1704  }
1705
1706  return *T;
1707}
1708
1709
1710/// Linux toolchain (very bare-bones at the moment).
1711
1712enum LinuxDistro {
1713  ArchLinux,
1714  DebianLenny,
1715  DebianSqueeze,
1716  DebianWheezy,
1717  Exherbo,
1718  RHEL4,
1719  RHEL5,
1720  RHEL6,
1721  Fedora13,
1722  Fedora14,
1723  Fedora15,
1724  FedoraRawhide,
1725  OpenSuse11_3,
1726  OpenSuse11_4,
1727  OpenSuse12_1,
1728  UbuntuHardy,
1729  UbuntuIntrepid,
1730  UbuntuJaunty,
1731  UbuntuKarmic,
1732  UbuntuLucid,
1733  UbuntuMaverick,
1734  UbuntuNatty,
1735  UbuntuOneiric,
1736  UnknownDistro
1737};
1738
1739static bool IsRedhat(enum LinuxDistro Distro) {
1740  return Distro == Fedora13 || Distro == Fedora14 ||
1741         Distro == Fedora15 || Distro == FedoraRawhide ||
1742         Distro == RHEL4 || Distro == RHEL5 || Distro == RHEL6;
1743}
1744
1745static bool IsOpenSuse(enum LinuxDistro Distro) {
1746  return Distro == OpenSuse11_3 || Distro == OpenSuse11_4 ||
1747         Distro == OpenSuse12_1;
1748}
1749
1750static bool IsDebian(enum LinuxDistro Distro) {
1751  return Distro == DebianLenny || Distro == DebianSqueeze ||
1752         Distro == DebianWheezy;
1753}
1754
1755static bool IsUbuntu(enum LinuxDistro Distro) {
1756  return Distro == UbuntuHardy  || Distro == UbuntuIntrepid ||
1757         Distro == UbuntuLucid  || Distro == UbuntuMaverick ||
1758         Distro == UbuntuJaunty || Distro == UbuntuKarmic ||
1759         Distro == UbuntuNatty  || Distro == UbuntuOneiric;
1760}
1761
1762static LinuxDistro DetectLinuxDistro(llvm::Triple::ArchType Arch) {
1763  llvm::OwningPtr<llvm::MemoryBuffer> File;
1764  if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
1765    StringRef Data = File.get()->getBuffer();
1766    SmallVector<StringRef, 8> Lines;
1767    Data.split(Lines, "\n");
1768    for (unsigned int i = 0, s = Lines.size(); i < s; ++ i) {
1769      if (Lines[i] == "DISTRIB_CODENAME=hardy")
1770        return UbuntuHardy;
1771      else if (Lines[i] == "DISTRIB_CODENAME=intrepid")
1772        return UbuntuIntrepid;
1773      else if (Lines[i] == "DISTRIB_CODENAME=jaunty")
1774        return UbuntuJaunty;
1775      else if (Lines[i] == "DISTRIB_CODENAME=karmic")
1776        return UbuntuKarmic;
1777      else if (Lines[i] == "DISTRIB_CODENAME=lucid")
1778        return UbuntuLucid;
1779      else if (Lines[i] == "DISTRIB_CODENAME=maverick")
1780        return UbuntuMaverick;
1781      else if (Lines[i] == "DISTRIB_CODENAME=natty")
1782        return UbuntuNatty;
1783      else if (Lines[i] == "DISTRIB_CODENAME=oneiric")
1784        return UbuntuOneiric;
1785    }
1786    return UnknownDistro;
1787  }
1788
1789  if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
1790    StringRef Data = File.get()->getBuffer();
1791    if (Data.startswith("Fedora release 15"))
1792      return Fedora15;
1793    else if (Data.startswith("Fedora release 14"))
1794      return Fedora14;
1795    else if (Data.startswith("Fedora release 13"))
1796      return Fedora13;
1797    else if (Data.startswith("Fedora release") &&
1798             Data.find("Rawhide") != StringRef::npos)
1799      return FedoraRawhide;
1800    else if (Data.startswith("Red Hat Enterprise Linux") &&
1801             Data.find("release 6") != StringRef::npos)
1802      return RHEL6;
1803    else if ((Data.startswith("Red Hat Enterprise Linux") ||
1804	      Data.startswith("CentOS")) &&
1805             Data.find("release 5") != StringRef::npos)
1806      return RHEL5;
1807    else if ((Data.startswith("Red Hat Enterprise Linux") ||
1808	      Data.startswith("CentOS")) &&
1809             Data.find("release 4") != StringRef::npos)
1810      return RHEL4;
1811    return UnknownDistro;
1812  }
1813
1814  if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
1815    StringRef Data = File.get()->getBuffer();
1816    if (Data[0] == '5')
1817      return DebianLenny;
1818    else if (Data.startswith("squeeze/sid"))
1819      return DebianSqueeze;
1820    else if (Data.startswith("wheezy/sid"))
1821      return DebianWheezy;
1822    return UnknownDistro;
1823  }
1824
1825  if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File)) {
1826    StringRef Data = File.get()->getBuffer();
1827    if (Data.startswith("openSUSE 11.3"))
1828      return OpenSuse11_3;
1829    else if (Data.startswith("openSUSE 11.4"))
1830      return OpenSuse11_4;
1831    else if (Data.startswith("openSUSE 12.1"))
1832      return OpenSuse12_1;
1833    return UnknownDistro;
1834  }
1835
1836  bool Exists;
1837  if (!llvm::sys::fs::exists("/etc/exherbo-release", Exists) && Exists)
1838    return Exherbo;
1839
1840  if (!llvm::sys::fs::exists("/etc/arch-release", Exists) && Exists)
1841    return ArchLinux;
1842
1843  return UnknownDistro;
1844}
1845
1846static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) {
1847  if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str());
1848}
1849
1850/// \brief Get our best guess at the multiarch triple for a target.
1851///
1852/// Debian-based systems are starting to use a multiarch setup where they use
1853/// a target-triple directory in the library and header search paths.
1854/// Unfortunately, this triple does not align with the vanilla target triple,
1855/// so we provide a rough mapping here.
1856static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
1857                                      StringRef SysRoot) {
1858  // For most architectures, just use whatever we have rather than trying to be
1859  // clever.
1860  switch (TargetTriple.getArch()) {
1861  default:
1862    return TargetTriple.str();
1863
1864    // We use the existence of '/lib/<triple>' as a directory to detect some
1865    // common linux triples that don't quite match the Clang triple for both
1866    // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
1867    // regardless of what the actual target triple is.
1868  case llvm::Triple::x86:
1869    if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
1870      return "i386-linux-gnu";
1871    return TargetTriple.str();
1872  case llvm::Triple::x86_64:
1873    if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
1874      return "x86_64-linux-gnu";
1875    return TargetTriple.str();
1876  case llvm::Triple::mips:
1877    if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu"))
1878      return "mips-linux-gnu";
1879    return TargetTriple.str();
1880  case llvm::Triple::mipsel:
1881    if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu"))
1882      return "mipsel-linux-gnu";
1883    return TargetTriple.str();
1884  }
1885}
1886
1887Linux::Linux(const HostInfo &Host, const llvm::Triple &Triple)
1888  : Generic_ELF(Host, Triple) {
1889  llvm::Triple::ArchType Arch =
1890    llvm::Triple(getDriver().DefaultHostTriple).getArch();
1891  const std::string &SysRoot = getDriver().SysRoot;
1892
1893  // OpenSuse stores the linker with the compiler, add that to the search
1894  // path.
1895  ToolChain::path_list &PPaths = getProgramPaths();
1896  PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
1897                         GCCInstallation.getTriple() + "/bin").str());
1898
1899  Linker = GetProgramPath("ld");
1900
1901  LinuxDistro Distro = DetectLinuxDistro(Arch);
1902
1903  if (IsOpenSuse(Distro) || IsUbuntu(Distro)) {
1904    ExtraOpts.push_back("-z");
1905    ExtraOpts.push_back("relro");
1906  }
1907
1908  if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
1909    ExtraOpts.push_back("-X");
1910
1911  const bool IsMips = Arch == llvm::Triple::mips ||
1912                      Arch == llvm::Triple::mipsel ||
1913                      Arch == llvm::Triple::mips64 ||
1914                      Arch == llvm::Triple::mips64el;
1915
1916  // Do not use 'gnu' hash style for Mips targets because .gnu.hash
1917  // and the MIPS ABI require .dynsym to be sorted in different ways.
1918  // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
1919  // ABI requires a mapping between the GOT and the symbol table.
1920  if (!IsMips) {
1921    if (IsRedhat(Distro) || IsOpenSuse(Distro) || Distro == UbuntuMaverick ||
1922        Distro == UbuntuNatty || Distro == UbuntuOneiric)
1923      ExtraOpts.push_back("--hash-style=gnu");
1924
1925    if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid ||
1926        Distro == UbuntuJaunty || Distro == UbuntuKarmic)
1927      ExtraOpts.push_back("--hash-style=both");
1928  }
1929
1930  if (IsRedhat(Distro))
1931    ExtraOpts.push_back("--no-add-needed");
1932
1933  if (Distro == DebianSqueeze || Distro == DebianWheezy ||
1934      IsOpenSuse(Distro) ||
1935      (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
1936      Distro == UbuntuLucid ||
1937      Distro == UbuntuMaverick || Distro == UbuntuKarmic ||
1938      Distro == UbuntuNatty || Distro == UbuntuOneiric)
1939    ExtraOpts.push_back("--build-id");
1940
1941  if (IsOpenSuse(Distro))
1942    ExtraOpts.push_back("--enable-new-dtags");
1943
1944  // The selection of paths to try here is designed to match the patterns which
1945  // the GCC driver itself uses, as this is part of the GCC-compatible driver.
1946  // This was determined by running GCC in a fake filesystem, creating all
1947  // possible permutations of these directories, and seeing which ones it added
1948  // to the link paths.
1949  path_list &Paths = getFilePaths();
1950  const bool Is32Bits = (getArch() == llvm::Triple::x86 ||
1951                         getArch() == llvm::Triple::mips ||
1952                         getArch() == llvm::Triple::mipsel ||
1953                         getArch() == llvm::Triple::ppc);
1954
1955  StringRef Suffix32;
1956  StringRef Suffix64;
1957  if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64) {
1958    Suffix32 = "/32";
1959    Suffix64 = "";
1960  } else {
1961    Suffix32 = "";
1962    Suffix64 = "/64";
1963  }
1964  const std::string Suffix = Is32Bits ? Suffix32 : Suffix64;
1965  const std::string Multilib = Is32Bits ? "lib32" : "lib64";
1966  const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
1967
1968  // Add the multilib suffixed paths where they are available.
1969  if (GCCInstallation.isValid()) {
1970    const std::string &LibPath = GCCInstallation.getParentLibPath();
1971    const std::string &GccTriple = GCCInstallation.getTriple();
1972    addPathIfExists(GCCInstallation.getInstallPath() + Suffix, Paths);
1973    addPathIfExists(LibPath + "/../" + GccTriple + "/lib/../" + Multilib,
1974                    Paths);
1975    addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
1976    addPathIfExists(LibPath + "/../" + Multilib, Paths);
1977  }
1978  addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
1979  addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
1980  addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
1981  addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
1982
1983  // Try walking via the GCC triple path in case of multiarch GCC
1984  // installations with strange symlinks.
1985  if (GCCInstallation.isValid())
1986    addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple() +
1987                    "/../../" + Multilib, Paths);
1988
1989  // Add the non-multilib suffixed paths (if potentially different).
1990  if (GCCInstallation.isValid()) {
1991    const std::string &LibPath = GCCInstallation.getParentLibPath();
1992    const std::string &GccTriple = GCCInstallation.getTriple();
1993    if (!Suffix.empty())
1994      addPathIfExists(GCCInstallation.getInstallPath(), Paths);
1995    addPathIfExists(LibPath + "/../" + GccTriple + "/lib", Paths);
1996    addPathIfExists(LibPath, Paths);
1997  }
1998  addPathIfExists(SysRoot + "/lib", Paths);
1999  addPathIfExists(SysRoot + "/usr/lib", Paths);
2000}
2001
2002bool Linux::HasNativeLLVMSupport() const {
2003  return true;
2004}
2005
2006Tool &Linux::SelectTool(const Compilation &C, const JobAction &JA,
2007                        const ActionList &Inputs) const {
2008  Action::ActionClass Key;
2009  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
2010    Key = Action::AnalyzeJobClass;
2011  else
2012    Key = JA.getKind();
2013
2014  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
2015                                             options::OPT_no_integrated_as,
2016                                             IsIntegratedAssemblerDefault());
2017
2018  Tool *&T = Tools[Key];
2019  if (!T) {
2020    switch (Key) {
2021    case Action::AssembleJobClass:
2022      if (UseIntegratedAs)
2023        T = new tools::ClangAs(*this);
2024      else
2025        T = new tools::linuxtools::Assemble(*this);
2026      break;
2027    case Action::LinkJobClass:
2028      T = new tools::linuxtools::Link(*this); break;
2029    default:
2030      T = &Generic_GCC::SelectTool(C, JA, Inputs);
2031    }
2032  }
2033
2034  return *T;
2035}
2036
2037void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2038                                      ArgStringList &CC1Args) const {
2039  const Driver &D = getDriver();
2040
2041  if (DriverArgs.hasArg(options::OPT_nostdinc))
2042    return;
2043
2044  if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
2045    addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include");
2046
2047  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2048    llvm::sys::Path P(D.ResourceDir);
2049    P.appendComponent("include");
2050    addSystemInclude(DriverArgs, CC1Args, P.str());
2051  }
2052
2053  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2054    return;
2055
2056  // Check for configure-time C include directories.
2057  StringRef CIncludeDirs(C_INCLUDE_DIRS);
2058  if (CIncludeDirs != "") {
2059    SmallVector<StringRef, 5> dirs;
2060    CIncludeDirs.split(dirs, ":");
2061    for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
2062         I != E; ++I) {
2063      StringRef Prefix = llvm::sys::path::is_absolute(*I) ? D.SysRoot : "";
2064      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
2065    }
2066    return;
2067  }
2068
2069  // Lacking those, try to detect the correct set of system includes for the
2070  // target triple.
2071
2072  // Implement generic Debian multiarch support.
2073  const StringRef X86_64MultiarchIncludeDirs[] = {
2074    "/usr/include/x86_64-linux-gnu",
2075
2076    // FIXME: These are older forms of multiarch. It's not clear that they're
2077    // in use in any released version of Debian, so we should consider
2078    // removing them.
2079    "/usr/include/i686-linux-gnu/64",
2080    "/usr/include/i486-linux-gnu/64"
2081  };
2082  const StringRef X86MultiarchIncludeDirs[] = {
2083    "/usr/include/i386-linux-gnu",
2084
2085    // FIXME: These are older forms of multiarch. It's not clear that they're
2086    // in use in any released version of Debian, so we should consider
2087    // removing them.
2088    "/usr/include/x86_64-linux-gnu/32",
2089    "/usr/include/i686-linux-gnu",
2090    "/usr/include/i486-linux-gnu"
2091  };
2092  const StringRef ARMMultiarchIncludeDirs[] = {
2093    "/usr/include/arm-linux-gnueabi"
2094  };
2095  const StringRef MIPSMultiarchIncludeDirs[] = {
2096    "/usr/include/mips-linux-gnu"
2097  };
2098  const StringRef MIPSELMultiarchIncludeDirs[] = {
2099    "/usr/include/mipsel-linux-gnu"
2100  };
2101  ArrayRef<StringRef> MultiarchIncludeDirs;
2102  if (getTriple().getArch() == llvm::Triple::x86_64) {
2103    MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
2104  } else if (getTriple().getArch() == llvm::Triple::x86) {
2105    MultiarchIncludeDirs = X86MultiarchIncludeDirs;
2106  } else if (getTriple().getArch() == llvm::Triple::arm) {
2107    MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
2108  } else if (getTriple().getArch() == llvm::Triple::mips) {
2109    MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
2110  } else if (getTriple().getArch() == llvm::Triple::mipsel) {
2111    MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
2112  }
2113  for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(),
2114                                     E = MultiarchIncludeDirs.end();
2115       I != E; ++I) {
2116    if (llvm::sys::fs::exists(D.SysRoot + *I)) {
2117      addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + *I);
2118      break;
2119    }
2120  }
2121
2122  if (getTriple().getOS() == llvm::Triple::RTEMS)
2123    return;
2124
2125  // Add an include of '/include' directly. This isn't provided by default by
2126  // system GCCs, but is often used with cross-compiling GCCs, and harmless to
2127  // add even when Clang is acting as-if it were a system compiler.
2128  addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/include");
2129
2130  addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include");
2131}
2132
2133/// \brief Helper to add the thre variant paths for a libstdc++ installation.
2134/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
2135                                                const ArgList &DriverArgs,
2136                                                ArgStringList &CC1Args) {
2137  if (!llvm::sys::fs::exists(Base))
2138    return false;
2139  addSystemInclude(DriverArgs, CC1Args, Base);
2140  addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir);
2141  addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
2142  return true;
2143}
2144
2145void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2146                                         ArgStringList &CC1Args) const {
2147  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2148      DriverArgs.hasArg(options::OPT_nostdincxx))
2149    return;
2150
2151  // Check if libc++ has been enabled and provide its include paths if so.
2152  if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
2153    // libc++ is always installed at a fixed path on Linux currently.
2154    addSystemInclude(DriverArgs, CC1Args,
2155                     getDriver().SysRoot + "/usr/include/c++/v1");
2156    return;
2157  }
2158
2159  const llvm::Triple &TargetTriple = getTriple();
2160
2161  StringRef CxxIncludeRoot(CXX_INCLUDE_ROOT);
2162  if (!CxxIncludeRoot.empty()) {
2163    StringRef CxxIncludeArch(CXX_INCLUDE_ARCH);
2164    if (CxxIncludeArch.empty())
2165      CxxIncludeArch = TargetTriple.str();
2166
2167    addLibStdCXXIncludePaths(
2168      CxxIncludeRoot,
2169      CxxIncludeArch + (isTarget64Bit() ? CXX_INCLUDE_64BIT_DIR
2170                                        : CXX_INCLUDE_32BIT_DIR),
2171      DriverArgs, CC1Args);
2172    return;
2173  }
2174
2175  // Check if the target architecture specific dirs need a suffix. Note that we
2176  // only support the suffix-based bi-arch-like header scheme for host/target
2177  // mismatches of just bit width.
2178  llvm::Triple::ArchType HostArch =
2179    llvm::Triple(getDriver().DefaultHostTriple).getArch();
2180  llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2181  StringRef Suffix;
2182  if ((HostArch == llvm::Triple::x86 && TargetArch == llvm::Triple::x86_64) ||
2183      (HostArch == llvm::Triple::ppc && TargetArch == llvm::Triple::ppc64))
2184    Suffix = "/64";
2185  if ((HostArch == llvm::Triple::x86_64 && TargetArch == llvm::Triple::x86) ||
2186      (HostArch == llvm::Triple::ppc64 && TargetArch == llvm::Triple::ppc))
2187    Suffix = "/32";
2188
2189  // By default, look for the C++ headers in an include directory adjacent to
2190  // the lib directory of the GCC installation. Note that this is expect to be
2191  // equivalent to '/usr/include/c++/X.Y' in almost all cases.
2192  StringRef LibDir = GCCInstallation.getParentLibPath();
2193  StringRef InstallDir = GCCInstallation.getInstallPath();
2194  StringRef Version = GCCInstallation.getVersion();
2195  if (!addLibStdCXXIncludePaths(LibDir + "/../include/c++/" + Version,
2196                                GCCInstallation.getTriple() + Suffix,
2197                                DriverArgs, CC1Args)) {
2198    // Gentoo is weird and places its headers inside the GCC install, so if the
2199    // first attempt to find the headers fails, try this pattern.
2200    addLibStdCXXIncludePaths(InstallDir + "/include/g++-v4",
2201                             GCCInstallation.getTriple() + Suffix,
2202                             DriverArgs, CC1Args);
2203  }
2204}
2205
2206/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2207
2208DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple)
2209  : Generic_ELF(Host, Triple) {
2210
2211  // Path mangling to find libexec
2212  getProgramPaths().push_back(getDriver().getInstalledDir());
2213  if (getDriver().getInstalledDir() != getDriver().Dir)
2214    getProgramPaths().push_back(getDriver().Dir);
2215
2216  getFilePaths().push_back(getDriver().Dir + "/../lib");
2217  getFilePaths().push_back("/usr/lib");
2218  getFilePaths().push_back("/usr/lib/gcc41");
2219}
2220
2221Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA,
2222                            const ActionList &Inputs) const {
2223  Action::ActionClass Key;
2224  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
2225    Key = Action::AnalyzeJobClass;
2226  else
2227    Key = JA.getKind();
2228
2229  Tool *&T = Tools[Key];
2230  if (!T) {
2231    switch (Key) {
2232    case Action::AssembleJobClass:
2233      T = new tools::dragonfly::Assemble(*this); break;
2234    case Action::LinkJobClass:
2235      T = new tools::dragonfly::Link(*this); break;
2236    default:
2237      T = &Generic_GCC::SelectTool(C, JA, Inputs);
2238    }
2239  }
2240
2241  return *T;
2242}
2243