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