ToolChains.cpp revision 198398 
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#include "clang/Driver/Arg.h"
13#include "clang/Driver/ArgList.h"
14#include "clang/Driver/Driver.h"
15#include "clang/Driver/DriverDiagnostic.h"
16#include "clang/Driver/HostInfo.h"
17#include "clang/Driver/Option.h"
18
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/Support/ErrorHandling.h"
21#include "llvm/Support/raw_ostream.h"
22#include "llvm/System/Path.h"
23
24#include <cstdlib> // ::getenv
25
26using namespace clang::driver;
27using namespace clang::driver::toolchains;
28
29/// Darwin - Darwin tool chain for i386 and x86_64.
30
31Darwin::Darwin(const HostInfo &Host, const llvm::Triple& Triple,
32               const unsigned (&_DarwinVersion)[3], bool _IsIPhoneOS)
33  : ToolChain(Host, Triple),
34    IsIPhoneOS(_IsIPhoneOS)
35{
36  DarwinVersion[0] = _DarwinVersion[0];
37  DarwinVersion[1] = _DarwinVersion[1];
38  DarwinVersion[2] = _DarwinVersion[2];
39
40  llvm::raw_string_ostream(MacosxVersionMin)
41    << "10." << std::max(0, (int)DarwinVersion[0] - 4) << '.'
42    << DarwinVersion[1];
43
44  // FIXME: Lift default up.
45  IPhoneOSVersionMin = "3.0";
46}
47
48DarwinGCC::DarwinGCC(const HostInfo &Host, const llvm::Triple& Triple,
49                     const unsigned (&DarwinVersion)[3],
50                     const unsigned (&_GCCVersion)[3], bool IsIPhoneOS)
51  : Darwin(Host, Triple, DarwinVersion, IsIPhoneOS)
52{
53  GCCVersion[0] = _GCCVersion[0];
54  GCCVersion[1] = _GCCVersion[1];
55  GCCVersion[2] = _GCCVersion[2];
56
57  // Set up the tool chain paths to match gcc.
58  ToolChainDir = "i686-apple-darwin";
59  ToolChainDir += llvm::utostr(DarwinVersion[0]);
60  ToolChainDir += "/";
61  ToolChainDir += llvm::utostr(GCCVersion[0]);
62  ToolChainDir += '.';
63  ToolChainDir += llvm::utostr(GCCVersion[1]);
64  ToolChainDir += '.';
65  ToolChainDir += llvm::utostr(GCCVersion[2]);
66
67  // Try the next major version if that tool chain dir is invalid.
68  std::string Tmp = "/usr/lib/gcc/" + ToolChainDir;
69  if (!llvm::sys::Path(Tmp).exists()) {
70    std::string Next = "i686-apple-darwin";
71    Next += llvm::utostr(DarwinVersion[0] + 1);
72    Next += "/";
73    Next += llvm::utostr(GCCVersion[0]);
74    Next += '.';
75    Next += llvm::utostr(GCCVersion[1]);
76    Next += '.';
77    Next += llvm::utostr(GCCVersion[2]);
78
79    // Use that if it exists, otherwise hope the user isn't linking.
80    //
81    // FIXME: Drop dependency on gcc's tool chain.
82    Tmp = "/usr/lib/gcc/" + Next;
83    if (llvm::sys::Path(Tmp).exists())
84      ToolChainDir = Next;
85  }
86
87  std::string Path;
88  if (getArchName() == "x86_64") {
89    Path = getHost().getDriver().Dir;
90    Path += "/../lib/gcc/";
91    Path += ToolChainDir;
92    Path += "/x86_64";
93    getFilePaths().push_back(Path);
94
95    Path = "/usr/lib/gcc/";
96    Path += ToolChainDir;
97    Path += "/x86_64";
98    getFilePaths().push_back(Path);
99  }
100
101  Path = getHost().getDriver().Dir;
102  Path += "/../lib/gcc/";
103  Path += ToolChainDir;
104  getFilePaths().push_back(Path);
105
106  Path = "/usr/lib/gcc/";
107  Path += ToolChainDir;
108  getFilePaths().push_back(Path);
109
110  Path = getHost().getDriver().Dir;
111  Path += "/../libexec/gcc/";
112  Path += ToolChainDir;
113  getProgramPaths().push_back(Path);
114
115  Path = "/usr/libexec/gcc/";
116  Path += ToolChainDir;
117  getProgramPaths().push_back(Path);
118
119  Path = getHost().getDriver().Dir;
120  Path += "/../libexec";
121  getProgramPaths().push_back(Path);
122
123  getProgramPaths().push_back(getHost().getDriver().Dir);
124}
125
126Darwin::~Darwin() {
127  // Free tool implementations.
128  for (llvm::DenseMap<unsigned, Tool*>::iterator
129         it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
130    delete it->second;
131}
132
133Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA) const {
134  Action::ActionClass Key;
135  if (getHost().getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
136    Key = Action::AnalyzeJobClass;
137  else
138    Key = JA.getKind();
139
140  Tool *&T = Tools[Key];
141  if (!T) {
142    switch (Key) {
143    case Action::InputClass:
144    case Action::BindArchClass:
145      assert(0 && "Invalid tool kind.");
146    case Action::PreprocessJobClass:
147      T = new tools::darwin::Preprocess(*this); break;
148    case Action::AnalyzeJobClass:
149      T = new tools::Clang(*this); break;
150    case Action::PrecompileJobClass:
151    case Action::CompileJobClass:
152      T = new tools::darwin::Compile(*this); break;
153    case Action::AssembleJobClass:
154      T = new tools::darwin::Assemble(*this); break;
155    case Action::LinkJobClass:
156      T = new tools::darwin::Link(*this); break;
157    case Action::LipoJobClass:
158      T = new tools::darwin::Lipo(*this); break;
159    }
160  }
161
162  return *T;
163}
164
165void DarwinGCC::AddLinkSearchPathArgs(const ArgList &Args,
166                                      ArgStringList &CmdArgs) const {
167  // FIXME: Derive these correctly.
168  if (getArchName() == "x86_64") {
169    CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
170                                         "/x86_64"));
171    // Intentionally duplicated for (temporary) gcc bug compatibility.
172    CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
173                                         "/x86_64"));
174  }
175  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/" + ToolChainDir));
176  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir));
177  // Intentionally duplicated for (temporary) gcc bug compatibility.
178  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir));
179  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
180                                       "/../../../" + ToolChainDir));
181  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
182                                       "/../../.."));
183}
184
185void DarwinGCC::AddLinkRuntimeLibArgs(const ArgList &Args,
186                                      ArgStringList &CmdArgs) const {
187  unsigned MacosxVersionMin[3];
188  getMacosxVersionMin(Args, MacosxVersionMin);
189
190  // Derived from libgcc and lib specs but refactored.
191  if (Args.hasArg(options::OPT_static)) {
192    CmdArgs.push_back("-lgcc_static");
193  } else {
194    if (Args.hasArg(options::OPT_static_libgcc)) {
195      CmdArgs.push_back("-lgcc_eh");
196    } else if (Args.hasArg(options::OPT_miphoneos_version_min_EQ)) {
197      // Derived from darwin_iphoneos_libgcc spec.
198      if (isIPhoneOS()) {
199        CmdArgs.push_back("-lgcc_s.1");
200      } else {
201        CmdArgs.push_back("-lgcc_s.10.5");
202      }
203    } else if (Args.hasArg(options::OPT_shared_libgcc) ||
204               // FIXME: -fexceptions -fno-exceptions means no exceptions
205               Args.hasArg(options::OPT_fexceptions) ||
206               Args.hasArg(options::OPT_fgnu_runtime)) {
207      // FIXME: This is probably broken on 10.3?
208      if (isMacosxVersionLT(MacosxVersionMin, 10, 5))
209        CmdArgs.push_back("-lgcc_s.10.4");
210      else if (isMacosxVersionLT(MacosxVersionMin, 10, 6))
211        CmdArgs.push_back("-lgcc_s.10.5");
212    } else {
213      if (isMacosxVersionLT(MacosxVersionMin, 10, 3, 9))
214        ; // Do nothing.
215      else if (isMacosxVersionLT(MacosxVersionMin, 10, 5))
216        CmdArgs.push_back("-lgcc_s.10.4");
217      else if (isMacosxVersionLT(MacosxVersionMin, 10, 6))
218        CmdArgs.push_back("-lgcc_s.10.5");
219    }
220
221    if (isIPhoneOS() || isMacosxVersionLT(MacosxVersionMin, 10, 6)) {
222      CmdArgs.push_back("-lgcc");
223      CmdArgs.push_back("-lSystem");
224    } else {
225      CmdArgs.push_back("-lSystem");
226      CmdArgs.push_back("-lgcc");
227    }
228  }
229}
230
231DarwinClang::DarwinClang(const HostInfo &Host, const llvm::Triple& Triple,
232                         const unsigned (&DarwinVersion)[3],
233                         bool IsIPhoneOS)
234  : Darwin(Host, Triple, DarwinVersion, IsIPhoneOS)
235{
236  // Add the relative libexec dir (for clang-cc).
237  //
238  // FIXME: We should sink clang-cc into libexec/clang/<version>/.
239  std::string Path = getHost().getDriver().Dir;
240  Path += "/../libexec";
241  getProgramPaths().push_back(Path);
242
243  // We expect 'as', 'ld', etc. to be adjacent to our install dir.
244  getProgramPaths().push_back(getHost().getDriver().Dir);
245}
246
247void DarwinClang::AddLinkSearchPathArgs(const ArgList &Args,
248                                       ArgStringList &CmdArgs) const {
249  // The Clang toolchain uses explicit paths for internal libraries.
250}
251
252void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
253                                        ArgStringList &CmdArgs) const {
254  // Check for static linking.
255  if (Args.hasArg(options::OPT_static)) {
256    // FIXME: We need to have compiler-rt available (perhaps as
257    // libclang_static.a) to link against.
258    return;
259  }
260
261  // Reject -static-libgcc for now, we can deal with this when and if someone
262  // cares. This is useful in situations where someone wants to statically link
263  // something like libstdc++, and needs its runtime support routines.
264  if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
265    getHost().getDriver().Diag(clang::diag::err_drv_unsupported_opt)
266      << A->getAsString(Args);
267    return;
268  }
269
270  // Otherwise link libSystem, which should have the support routines.
271  //
272  // FIXME: This is only true for 10.6 and beyond. Legacy support isn't
273  // critical, but it should work... we should just link in the static
274  // compiler-rt library.
275  CmdArgs.push_back("-lSystem");
276}
277
278void Darwin::getMacosxVersionMin(const ArgList &Args,
279                                 unsigned (&Res)[3]) const {
280  if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ)) {
281    bool HadExtra;
282    if (!Driver::GetReleaseVersion(A->getValue(Args), Res[0], Res[1], Res[2],
283                                   HadExtra) ||
284        HadExtra) {
285      const Driver &D = getHost().getDriver();
286      D.Diag(clang::diag::err_drv_invalid_version_number)
287        << A->getAsString(Args);
288    }
289  } else
290    return getMacosxVersion(Res);
291}
292
293DerivedArgList *Darwin::TranslateArgs(InputArgList &Args,
294                                      const char *BoundArch) const {
295  DerivedArgList *DAL = new DerivedArgList(Args, false);
296  const OptTable &Opts = getHost().getDriver().getOpts();
297
298  // FIXME: We really want to get out of the tool chain level argument
299  // translation business, as it makes the driver functionality much
300  // more opaque. For now, we follow gcc closely solely for the
301  // purpose of easily achieving feature parity & testability. Once we
302  // have something that works, we should reevaluate each translation
303  // and try to push it down into tool specific logic.
304
305  Arg *OSXVersion =
306    Args.getLastArg(options::OPT_mmacosx_version_min_EQ, false);
307  Arg *iPhoneVersion =
308    Args.getLastArg(options::OPT_miphoneos_version_min_EQ, false);
309  if (OSXVersion && iPhoneVersion) {
310    getHost().getDriver().Diag(clang::diag::err_drv_argument_not_allowed_with)
311          << OSXVersion->getAsString(Args)
312          << iPhoneVersion->getAsString(Args);
313  } else if (!OSXVersion && !iPhoneVersion) {
314    // Chose the default version based on the arch.
315    //
316    // FIXME: Are there iPhone overrides for this?
317
318    if (!isIPhoneOS()) {
319      // Look for MACOSX_DEPLOYMENT_TARGET, otherwise use the version
320      // from the host.
321      const char *Version = ::getenv("MACOSX_DEPLOYMENT_TARGET");
322      if (!Version)
323        Version = MacosxVersionMin.c_str();
324      const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
325      DAL->append(DAL->MakeJoinedArg(0, O, Version));
326    } else {
327      const char *Version = IPhoneOSVersionMin.c_str();
328      const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
329      DAL->append(DAL->MakeJoinedArg(0, O, Version));
330    }
331  }
332
333  for (ArgList::iterator it = Args.begin(), ie = Args.end(); it != ie; ++it) {
334    Arg *A = *it;
335
336    if (A->getOption().matches(options::OPT_Xarch__)) {
337      // FIXME: Canonicalize name.
338      if (getArchName() != A->getValue(Args, 0))
339        continue;
340
341      // FIXME: The arg is leaked here, and we should have a nicer
342      // interface for this.
343      unsigned Prev, Index = Prev = A->getIndex() + 1;
344      Arg *XarchArg = Opts.ParseOneArg(Args, Index);
345
346      // If the argument parsing failed or more than one argument was
347      // consumed, the -Xarch_ argument's parameter tried to consume
348      // extra arguments. Emit an error and ignore.
349      //
350      // We also want to disallow any options which would alter the
351      // driver behavior; that isn't going to work in our model. We
352      // use isDriverOption() as an approximation, although things
353      // like -O4 are going to slip through.
354      if (!XarchArg || Index > Prev + 1 ||
355          XarchArg->getOption().isDriverOption()) {
356       getHost().getDriver().Diag(clang::diag::err_drv_invalid_Xarch_argument)
357          << A->getAsString(Args);
358        continue;
359      }
360
361      XarchArg->setBaseArg(A);
362      A = XarchArg;
363    }
364
365    // Sob. These is strictly gcc compatible for the time being. Apple
366    // gcc translates options twice, which means that self-expanding
367    // options add duplicates.
368    options::ID id = A->getOption().getId();
369    switch (id) {
370    default:
371      DAL->append(A);
372      break;
373
374    case options::OPT_mkernel:
375    case options::OPT_fapple_kext:
376      DAL->append(A);
377      DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_static)));
378      DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_static)));
379      break;
380
381    case options::OPT_dependency_file:
382      DAL->append(DAL->MakeSeparateArg(A, Opts.getOption(options::OPT_MF),
383                                       A->getValue(Args)));
384      break;
385
386    case options::OPT_gfull:
387      DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_g_Flag)));
388      DAL->append(DAL->MakeFlagArg(A,
389             Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols)));
390      break;
391
392    case options::OPT_gused:
393      DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_g_Flag)));
394      DAL->append(DAL->MakeFlagArg(A,
395             Opts.getOption(options::OPT_feliminate_unused_debug_symbols)));
396      break;
397
398    case options::OPT_fterminated_vtables:
399    case options::OPT_findirect_virtual_calls:
400      DAL->append(DAL->MakeFlagArg(A,
401                                   Opts.getOption(options::OPT_fapple_kext)));
402      DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_static)));
403      break;
404
405    case options::OPT_shared:
406      DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_dynamiclib)));
407      break;
408
409    case options::OPT_fconstant_cfstrings:
410      DAL->append(DAL->MakeFlagArg(A,
411                             Opts.getOption(options::OPT_mconstant_cfstrings)));
412      break;
413
414    case options::OPT_fno_constant_cfstrings:
415      DAL->append(DAL->MakeFlagArg(A,
416                          Opts.getOption(options::OPT_mno_constant_cfstrings)));
417      break;
418
419    case options::OPT_Wnonportable_cfstrings:
420      DAL->append(DAL->MakeFlagArg(A,
421                     Opts.getOption(options::OPT_mwarn_nonportable_cfstrings)));
422      break;
423
424    case options::OPT_Wno_nonportable_cfstrings:
425      DAL->append(DAL->MakeFlagArg(A,
426                  Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings)));
427      break;
428
429    case options::OPT_fpascal_strings:
430      DAL->append(DAL->MakeFlagArg(A,
431                                 Opts.getOption(options::OPT_mpascal_strings)));
432      break;
433
434    case options::OPT_fno_pascal_strings:
435      DAL->append(DAL->MakeFlagArg(A,
436                              Opts.getOption(options::OPT_mno_pascal_strings)));
437      break;
438    }
439  }
440
441  if (getTriple().getArch() == llvm::Triple::x86 ||
442      getTriple().getArch() == llvm::Triple::x86_64)
443    if (!Args.hasArg(options::OPT_mtune_EQ, false))
444      DAL->append(DAL->MakeJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ),
445                                     "core2"));
446
447  // Add the arch options based on the particular spelling of -arch, to match
448  // how the driver driver works.
449  if (BoundArch) {
450    llvm::StringRef Name = BoundArch;
451    const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ);
452    const Option *MArch = Opts.getOption(options::OPT_march_EQ);
453
454    // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
455    // which defines the list of which architectures we accept.
456    if (Name == "ppc")
457      ;
458    else if (Name == "ppc601")
459      DAL->append(DAL->MakeJoinedArg(0, MCpu, "601"));
460    else if (Name == "ppc603")
461      DAL->append(DAL->MakeJoinedArg(0, MCpu, "603"));
462    else if (Name == "ppc604")
463      DAL->append(DAL->MakeJoinedArg(0, MCpu, "604"));
464    else if (Name == "ppc604e")
465      DAL->append(DAL->MakeJoinedArg(0, MCpu, "604e"));
466    else if (Name == "ppc750")
467      DAL->append(DAL->MakeJoinedArg(0, MCpu, "750"));
468    else if (Name == "ppc7400")
469      DAL->append(DAL->MakeJoinedArg(0, MCpu, "7400"));
470    else if (Name == "ppc7450")
471      DAL->append(DAL->MakeJoinedArg(0, MCpu, "7450"));
472    else if (Name == "ppc970")
473      DAL->append(DAL->MakeJoinedArg(0, MCpu, "970"));
474
475    else if (Name == "ppc64")
476      DAL->append(DAL->MakeFlagArg(0, Opts.getOption(options::OPT_m64)));
477
478    else if (Name == "i386")
479      ;
480    else if (Name == "i486")
481      DAL->append(DAL->MakeJoinedArg(0, MArch, "i486"));
482    else if (Name == "i586")
483      DAL->append(DAL->MakeJoinedArg(0, MArch, "i586"));
484    else if (Name == "i686")
485      DAL->append(DAL->MakeJoinedArg(0, MArch, "i686"));
486    else if (Name == "pentium")
487      DAL->append(DAL->MakeJoinedArg(0, MArch, "pentium"));
488    else if (Name == "pentium2")
489      DAL->append(DAL->MakeJoinedArg(0, MArch, "pentium2"));
490    else if (Name == "pentpro")
491      DAL->append(DAL->MakeJoinedArg(0, MArch, "pentiumpro"));
492    else if (Name == "pentIIm3")
493      DAL->append(DAL->MakeJoinedArg(0, MArch, "pentium2"));
494
495    else if (Name == "x86_64")
496      DAL->append(DAL->MakeFlagArg(0, Opts.getOption(options::OPT_m64)));
497
498    else if (Name == "arm")
499      DAL->append(DAL->MakeJoinedArg(0, MArch, "armv4t"));
500    else if (Name == "armv4t")
501      DAL->append(DAL->MakeJoinedArg(0, MArch, "armv4t"));
502    else if (Name == "armv5")
503      DAL->append(DAL->MakeJoinedArg(0, MArch, "armv5tej"));
504    else if (Name == "xscale")
505      DAL->append(DAL->MakeJoinedArg(0, MArch, "xscale"));
506    else if (Name == "armv6")
507      DAL->append(DAL->MakeJoinedArg(0, MArch, "armv6k"));
508    else if (Name == "armv7")
509      DAL->append(DAL->MakeJoinedArg(0, MArch, "armv7a"));
510
511    else
512      llvm::llvm_unreachable("invalid Darwin arch");
513  }
514
515  return DAL;
516}
517
518bool Darwin::IsMathErrnoDefault() const {
519  return false;
520}
521
522bool Darwin::IsUnwindTablesDefault() const {
523  // FIXME: Gross; we should probably have some separate target
524  // definition, possibly even reusing the one in clang.
525  return getArchName() == "x86_64";
526}
527
528const char *Darwin::GetDefaultRelocationModel() const {
529  return "pic";
530}
531
532const char *Darwin::GetForcedPicModel() const {
533  if (getArchName() == "x86_64")
534    return "pic";
535  return 0;
536}
537
538/// Generic_GCC - A tool chain using the 'gcc' command to perform
539/// all subcommands; this relies on gcc translating the majority of
540/// command line options.
541
542Generic_GCC::Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple)
543  : ToolChain(Host, Triple) {
544  std::string Path(getHost().getDriver().Dir);
545  Path += "/../libexec";
546  getProgramPaths().push_back(Path);
547
548  getProgramPaths().push_back(getHost().getDriver().Dir);
549}
550
551Generic_GCC::~Generic_GCC() {
552  // Free tool implementations.
553  for (llvm::DenseMap<unsigned, Tool*>::iterator
554         it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
555    delete it->second;
556}
557
558Tool &Generic_GCC::SelectTool(const Compilation &C,
559                              const JobAction &JA) const {
560  Action::ActionClass Key;
561  if (getHost().getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
562    Key = Action::AnalyzeJobClass;
563  else
564    Key = JA.getKind();
565
566  Tool *&T = Tools[Key];
567  if (!T) {
568    switch (Key) {
569    case Action::InputClass:
570    case Action::BindArchClass:
571      assert(0 && "Invalid tool kind.");
572    case Action::PreprocessJobClass:
573      T = new tools::gcc::Preprocess(*this); break;
574    case Action::PrecompileJobClass:
575      T = new tools::gcc::Precompile(*this); break;
576    case Action::AnalyzeJobClass:
577      T = new tools::Clang(*this); break;
578    case Action::CompileJobClass:
579      T = new tools::gcc::Compile(*this); break;
580    case Action::AssembleJobClass:
581      T = new tools::gcc::Assemble(*this); break;
582    case Action::LinkJobClass:
583      T = new tools::gcc::Link(*this); break;
584
585      // This is a bit ungeneric, but the only platform using a driver
586      // driver is Darwin.
587    case Action::LipoJobClass:
588      T = new tools::darwin::Lipo(*this); break;
589    }
590  }
591
592  return *T;
593}
594
595bool Generic_GCC::IsMathErrnoDefault() const {
596  return true;
597}
598
599bool Generic_GCC::IsUnwindTablesDefault() const {
600  // FIXME: Gross; we should probably have some separate target
601  // definition, possibly even reusing the one in clang.
602  return getArchName() == "x86_64";
603}
604
605const char *Generic_GCC::GetDefaultRelocationModel() const {
606  return "static";
607}
608
609const char *Generic_GCC::GetForcedPicModel() const {
610  return 0;
611}
612
613DerivedArgList *Generic_GCC::TranslateArgs(InputArgList &Args,
614                                           const char *BoundArch) const {
615  return new DerivedArgList(Args, true);
616}
617
618/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
619
620OpenBSD::OpenBSD(const HostInfo &Host, const llvm::Triple& Triple)
621  : Generic_GCC(Host, Triple) {
622  getFilePaths().push_back(getHost().getDriver().Dir + "/../lib");
623  getFilePaths().push_back("/usr/lib");
624}
625
626Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA) const {
627  Action::ActionClass Key;
628  if (getHost().getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
629    Key = Action::AnalyzeJobClass;
630  else
631    Key = JA.getKind();
632
633  Tool *&T = Tools[Key];
634  if (!T) {
635    switch (Key) {
636    case Action::AssembleJobClass:
637      T = new tools::openbsd::Assemble(*this); break;
638    case Action::LinkJobClass:
639      T = new tools::openbsd::Link(*this); break;
640    default:
641      T = &Generic_GCC::SelectTool(C, JA);
642    }
643  }
644
645  return *T;
646}
647
648/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
649
650FreeBSD::FreeBSD(const HostInfo &Host, const llvm::Triple& Triple, bool Lib32)
651  : Generic_GCC(Host, Triple) {
652  if (Lib32) {
653    getFilePaths().push_back(getHost().getDriver().Dir + "/../lib32");
654    getFilePaths().push_back("/usr/lib32");
655  } else {
656    getFilePaths().push_back(getHost().getDriver().Dir + "/../lib");
657    getFilePaths().push_back("/usr/lib");
658  }
659}
660
661Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA) const {
662  Action::ActionClass Key;
663  if (getHost().getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
664    Key = Action::AnalyzeJobClass;
665  else
666    Key = JA.getKind();
667
668  Tool *&T = Tools[Key];
669  if (!T) {
670    switch (Key) {
671    case Action::AssembleJobClass:
672      T = new tools::freebsd::Assemble(*this); break;
673    case Action::LinkJobClass:
674      T = new tools::freebsd::Link(*this); break;
675    default:
676      T = &Generic_GCC::SelectTool(C, JA);
677    }
678  }
679
680  return *T;
681}
682
683/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
684
685AuroraUX::AuroraUX(const HostInfo &Host, const llvm::Triple& Triple)
686  : Generic_GCC(Host, Triple) {
687
688  // Path mangling to find libexec
689  std::string Path(getHost().getDriver().Dir);
690
691  Path += "/../libexec";
692  getProgramPaths().push_back(Path);
693  getProgramPaths().push_back(getHost().getDriver().Dir);
694
695  getFilePaths().push_back(getHost().getDriver().Dir + "/../lib");
696  getFilePaths().push_back("/usr/lib");
697  getFilePaths().push_back("/usr/sfw/lib");
698  getFilePaths().push_back("/opt/gcc4/lib");
699  getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
700
701}
702
703Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA) const {
704  Action::ActionClass Key;
705  if (getHost().getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
706    Key = Action::AnalyzeJobClass;
707  else
708    Key = JA.getKind();
709
710  Tool *&T = Tools[Key];
711  if (!T) {
712    switch (Key) {
713    case Action::AssembleJobClass:
714      T = new tools::auroraux::Assemble(*this); break;
715    case Action::LinkJobClass:
716      T = new tools::auroraux::Link(*this); break;
717    default:
718      T = &Generic_GCC::SelectTool(C, JA);
719    }
720  }
721
722  return *T;
723}
724
725
726/// Linux toolchain (very bare-bones at the moment).
727
728Linux::Linux(const HostInfo &Host, const llvm::Triple& Triple)
729  : Generic_GCC(Host, Triple) {
730  getFilePaths().push_back(getHost().getDriver().Dir + "/../lib/clang/1.0/");
731  getFilePaths().push_back("/lib/");
732  getFilePaths().push_back("/usr/lib/");
733
734  // Depending on the Linux distribution, any combination of lib{,32,64} is
735  // possible. E.g. Debian uses lib and lib32 for mixed i386/x86-64 systems,
736  // openSUSE uses lib and lib64 for the same purpose.
737  getFilePaths().push_back("/lib32/");
738  getFilePaths().push_back("/usr/lib32/");
739  getFilePaths().push_back("/lib64/");
740  getFilePaths().push_back("/usr/lib64/");
741
742  // FIXME: Figure out some way to get gcc's libdir
743  // (e.g. /usr/lib/gcc/i486-linux-gnu/4.3/ for Ubuntu 32-bit); we need
744  // crtbegin.o/crtend.o/etc., and want static versions of various
745  // libraries. If we had our own crtbegin.o/crtend.o/etc, we could probably
746  // get away with using shared versions in /usr/lib, though.
747  // We could fall back to the approach we used for includes (a massive
748  // list), but that's messy at best.
749}
750
751/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
752
753DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple)
754  : Generic_GCC(Host, Triple) {
755
756  // Path mangling to find libexec
757  std::string Path(getHost().getDriver().Dir);
758
759  Path += "/../libexec";
760  getProgramPaths().push_back(Path);
761  getProgramPaths().push_back(getHost().getDriver().Dir);
762
763  getFilePaths().push_back(getHost().getDriver().Dir + "/../lib");
764  getFilePaths().push_back("/usr/lib");
765  getFilePaths().push_back("/usr/lib/gcc41");
766}
767
768Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA) const {
769  Action::ActionClass Key;
770  if (getHost().getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
771    Key = Action::AnalyzeJobClass;
772  else
773    Key = JA.getKind();
774
775  Tool *&T = Tools[Key];
776  if (!T) {
777    switch (Key) {
778    case Action::AssembleJobClass:
779      T = new tools::dragonfly::Assemble(*this); break;
780    case Action::LinkJobClass:
781      T = new tools::dragonfly::Link(*this); break;
782    default:
783      T = &Generic_GCC::SelectTool(C, JA);
784    }
785  }
786
787  return *T;
788}
789