ToolChains.cpp revision 9d0863b22faef1678eb191bbab7268809be60a96 
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/Compilation.h"
15#include "clang/Driver/Driver.h"
16#include "clang/Driver/DriverDiagnostic.h"
17#include "clang/Driver/HostInfo.h"
18#include "clang/Driver/OptTable.h"
19#include "clang/Driver/Option.h"
20#include "clang/Driver/Options.h"
21
22#include "llvm/ADT/StringExtras.h"
23#include "llvm/Support/ErrorHandling.h"
24#include "llvm/Support/raw_ostream.h"
25#include "llvm/System/Path.h"
26
27#include <cstdlib> // ::getenv
28
29using namespace clang::driver;
30using namespace clang::driver::toolchains;
31
32/// Darwin - Darwin tool chain for i386 and x86_64.
33
34Darwin::Darwin(const HostInfo &Host, const llvm::Triple& Triple,
35               const unsigned (&_DarwinVersion)[3])
36  : ToolChain(Host, Triple), TargetInitialized(false)
37{
38  llvm::raw_string_ostream(MacosxVersionMin)
39    << "10." << std::max(0, (int)_DarwinVersion[0] - 4) << '.'
40    << _DarwinVersion[1];
41}
42
43// FIXME: Can we tablegen this?
44static const char *GetArmArchForMArch(llvm::StringRef Value) {
45  if (Value == "armv6k")
46    return "armv6";
47
48  if (Value == "armv5tej")
49    return "armv5";
50
51  if (Value == "xscale")
52    return "xscale";
53
54  if (Value == "armv4t")
55    return "armv4t";
56
57  if (Value == "armv7" || Value == "armv7-a" || Value == "armv7-r" ||
58      Value == "armv7-m" || Value == "armv7a" || Value == "armv7r" ||
59      Value == "armv7m")
60    return "armv7";
61
62  return 0;
63}
64
65// FIXME: Can we tablegen this?
66static const char *GetArmArchForMCpu(llvm::StringRef Value) {
67  if (Value == "arm10tdmi" || Value == "arm1020t" || Value == "arm9e" ||
68      Value == "arm946e-s" || Value == "arm966e-s" ||
69      Value == "arm968e-s" || Value == "arm10e" ||
70      Value == "arm1020e" || Value == "arm1022e" || Value == "arm926ej-s" ||
71      Value == "arm1026ej-s")
72    return "armv5";
73
74  if (Value == "xscale")
75    return "xscale";
76
77  if (Value == "arm1136j-s" || Value == "arm1136jf-s" ||
78      Value == "arm1176jz-s" || Value == "arm1176jzf-s")
79    return "armv6";
80
81  if (Value == "cortex-a8" || Value == "cortex-r4" || Value == "cortex-m3")
82    return "armv7";
83
84  return 0;
85}
86
87llvm::StringRef Darwin::getDarwinArchName(const ArgList &Args) const {
88  switch (getTriple().getArch()) {
89  default:
90    return getArchName();
91
92  case llvm::Triple::arm: {
93    if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
94      if (const char *Arch = GetArmArchForMArch(A->getValue(Args)))
95        return Arch;
96
97    if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
98      if (const char *Arch = GetArmArchForMCpu(A->getValue(Args)))
99        return Arch;
100
101    return "arm";
102  }
103  }
104}
105
106DarwinGCC::DarwinGCC(const HostInfo &Host, const llvm::Triple& Triple,
107                     const unsigned (&DarwinVersion)[3],
108                     const unsigned (&_GCCVersion)[3])
109  : Darwin(Host, Triple, DarwinVersion)
110{
111  GCCVersion[0] = _GCCVersion[0];
112  GCCVersion[1] = _GCCVersion[1];
113  GCCVersion[2] = _GCCVersion[2];
114
115  // Set up the tool chain paths to match gcc.
116  ToolChainDir = "i686-apple-darwin";
117  ToolChainDir += llvm::utostr(DarwinVersion[0]);
118  ToolChainDir += "/";
119  ToolChainDir += llvm::utostr(GCCVersion[0]);
120  ToolChainDir += '.';
121  ToolChainDir += llvm::utostr(GCCVersion[1]);
122  ToolChainDir += '.';
123  ToolChainDir += llvm::utostr(GCCVersion[2]);
124
125  // Try the next major version if that tool chain dir is invalid.
126  std::string Tmp = "/usr/lib/gcc/" + ToolChainDir;
127  if (!llvm::sys::Path(Tmp).exists()) {
128    std::string Next = "i686-apple-darwin";
129    Next += llvm::utostr(DarwinVersion[0] + 1);
130    Next += "/";
131    Next += llvm::utostr(GCCVersion[0]);
132    Next += '.';
133    Next += llvm::utostr(GCCVersion[1]);
134    Next += '.';
135    Next += llvm::utostr(GCCVersion[2]);
136
137    // Use that if it exists, otherwise hope the user isn't linking.
138    //
139    // FIXME: Drop dependency on gcc's tool chain.
140    Tmp = "/usr/lib/gcc/" + Next;
141    if (llvm::sys::Path(Tmp).exists())
142      ToolChainDir = Next;
143  }
144
145  std::string Path;
146  if (getArchName() == "x86_64") {
147    Path = getDriver().Dir;
148    Path += "/../lib/gcc/";
149    Path += ToolChainDir;
150    Path += "/x86_64";
151    getFilePaths().push_back(Path);
152
153    Path = "/usr/lib/gcc/";
154    Path += ToolChainDir;
155    Path += "/x86_64";
156    getFilePaths().push_back(Path);
157  }
158
159  Path = getDriver().Dir;
160  Path += "/../lib/gcc/";
161  Path += ToolChainDir;
162  getFilePaths().push_back(Path);
163
164  Path = "/usr/lib/gcc/";
165  Path += ToolChainDir;
166  getFilePaths().push_back(Path);
167
168  Path = getDriver().Dir;
169  Path += "/../libexec/gcc/";
170  Path += ToolChainDir;
171  getProgramPaths().push_back(Path);
172
173  Path = "/usr/libexec/gcc/";
174  Path += ToolChainDir;
175  getProgramPaths().push_back(Path);
176
177  getProgramPaths().push_back(getDriver().Dir);
178}
179
180Darwin::~Darwin() {
181  // Free tool implementations.
182  for (llvm::DenseMap<unsigned, Tool*>::iterator
183         it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
184    delete it->second;
185}
186
187Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA) const {
188  Action::ActionClass Key;
189  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
190    Key = Action::AnalyzeJobClass;
191  else
192    Key = JA.getKind();
193
194  // FIXME: This doesn't belong here, but ideally we will support static soon
195  // anyway.
196  bool HasStatic = (C.getArgs().hasArg(options::OPT_mkernel) ||
197                    C.getArgs().hasArg(options::OPT_static) ||
198                    C.getArgs().hasArg(options::OPT_fapple_kext));
199  bool IsIADefault = IsIntegratedAssemblerDefault() && !HasStatic;
200  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
201                                             options::OPT_no_integrated_as,
202                                             IsIADefault);
203
204  Tool *&T = Tools[Key];
205  if (!T) {
206    switch (Key) {
207    case Action::InputClass:
208    case Action::BindArchClass:
209      assert(0 && "Invalid tool kind.");
210    case Action::PreprocessJobClass:
211      T = new tools::darwin::Preprocess(*this); break;
212    case Action::AnalyzeJobClass:
213      T = new tools::Clang(*this); break;
214    case Action::PrecompileJobClass:
215    case Action::CompileJobClass:
216      T = new tools::darwin::Compile(*this); break;
217    case Action::AssembleJobClass: {
218      if (UseIntegratedAs)
219        T = new tools::ClangAs(*this);
220      else
221        T = new tools::darwin::Assemble(*this);
222      break;
223    }
224    case Action::LinkJobClass:
225      T = new tools::darwin::Link(*this); break;
226    case Action::LipoJobClass:
227      T = new tools::darwin::Lipo(*this); break;
228    case Action::DsymutilJobClass:
229      T = new tools::darwin::Dsymutil(*this); break;
230    }
231  }
232
233  return *T;
234}
235
236void DarwinGCC::AddLinkSearchPathArgs(const ArgList &Args,
237                                      ArgStringList &CmdArgs) const {
238  std::string Tmp;
239
240  // FIXME: Derive these correctly.
241  if (getArchName() == "x86_64") {
242    CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
243                                         "/x86_64"));
244    // Intentionally duplicated for (temporary) gcc bug compatibility.
245    CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
246                                         "/x86_64"));
247  }
248
249  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/" + ToolChainDir));
250
251  Tmp = getDriver().Dir + "/../lib/gcc/" + ToolChainDir;
252  if (llvm::sys::Path(Tmp).exists())
253    CmdArgs.push_back(Args.MakeArgString("-L" + Tmp));
254  Tmp = getDriver().Dir + "/../lib/gcc";
255  if (llvm::sys::Path(Tmp).exists())
256    CmdArgs.push_back(Args.MakeArgString("-L" + Tmp));
257  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir));
258  // Intentionally duplicated for (temporary) gcc bug compatibility.
259  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir));
260  Tmp = getDriver().Dir + "/../lib/" + ToolChainDir;
261  if (llvm::sys::Path(Tmp).exists())
262    CmdArgs.push_back(Args.MakeArgString("-L" + Tmp));
263  Tmp = getDriver().Dir + "/../lib";
264  if (llvm::sys::Path(Tmp).exists())
265    CmdArgs.push_back(Args.MakeArgString("-L" + Tmp));
266  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
267                                       "/../../../" + ToolChainDir));
268  CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir +
269                                       "/../../.."));
270}
271
272void DarwinGCC::AddLinkRuntimeLibArgs(const ArgList &Args,
273                                      ArgStringList &CmdArgs) const {
274  // Note that this routine is only used for targetting OS X.
275
276  // Derived from libgcc and lib specs but refactored.
277  if (Args.hasArg(options::OPT_static)) {
278    CmdArgs.push_back("-lgcc_static");
279  } else {
280    if (Args.hasArg(options::OPT_static_libgcc)) {
281      CmdArgs.push_back("-lgcc_eh");
282    } else if (Args.hasArg(options::OPT_miphoneos_version_min_EQ)) {
283      // Derived from darwin_iphoneos_libgcc spec.
284      if (isTargetIPhoneOS()) {
285        CmdArgs.push_back("-lgcc_s.1");
286      } else {
287        CmdArgs.push_back("-lgcc_s.10.5");
288      }
289    } else if (Args.hasArg(options::OPT_shared_libgcc) ||
290               Args.hasFlag(options::OPT_fexceptions,
291                            options::OPT_fno_exceptions) ||
292               Args.hasArg(options::OPT_fgnu_runtime)) {
293      // FIXME: This is probably broken on 10.3?
294      if (isMacosxVersionLT(10, 5))
295        CmdArgs.push_back("-lgcc_s.10.4");
296      else if (isMacosxVersionLT(10, 6))
297        CmdArgs.push_back("-lgcc_s.10.5");
298    } else {
299      if (isMacosxVersionLT(10, 3, 9))
300        ; // Do nothing.
301      else if (isMacosxVersionLT(10, 5))
302        CmdArgs.push_back("-lgcc_s.10.4");
303      else if (isMacosxVersionLT(10, 6))
304        CmdArgs.push_back("-lgcc_s.10.5");
305    }
306
307    if (isTargetIPhoneOS() || isMacosxVersionLT(10, 6)) {
308      CmdArgs.push_back("-lgcc");
309      CmdArgs.push_back("-lSystem");
310    } else {
311      CmdArgs.push_back("-lSystem");
312      CmdArgs.push_back("-lgcc");
313    }
314  }
315}
316
317DarwinClang::DarwinClang(const HostInfo &Host, const llvm::Triple& Triple,
318                         const unsigned (&DarwinVersion)[3])
319  : Darwin(Host, Triple, DarwinVersion)
320{
321  // We expect 'as', 'ld', etc. to be adjacent to our install dir.
322  getProgramPaths().push_back(getDriver().Dir);
323}
324
325void DarwinClang::AddLinkSearchPathArgs(const ArgList &Args,
326                                       ArgStringList &CmdArgs) const {
327  // The Clang toolchain uses explicit paths for internal libraries.
328}
329
330void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
331                                        ArgStringList &CmdArgs) const {
332  // Darwin doesn't support real static executables, don't link any runtime
333  // libraries with -static.
334  if (Args.hasArg(options::OPT_static))
335    return;
336
337  // Reject -static-libgcc for now, we can deal with this when and if someone
338  // cares. This is useful in situations where someone wants to statically link
339  // something like libstdc++, and needs its runtime support routines.
340  if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
341    getDriver().Diag(clang::diag::err_drv_unsupported_opt)
342      << A->getAsString(Args);
343    return;
344  }
345
346  // Otherwise link libSystem, then the dynamic runtime library, and finally any
347  // target specific static runtime library.
348  CmdArgs.push_back("-lSystem");
349
350  // Select the dynamic runtime library and the target specific static library.
351  const char *DarwinStaticLib = 0;
352  if (isTargetIPhoneOS()) {
353    CmdArgs.push_back("-lgcc_s.1");
354
355    // We may need some static functions for armv6/thumb which are required to
356    // be in the same linkage unit as their caller.
357    if (getDarwinArchName(Args) == "armv6")
358      DarwinStaticLib = "libclang_rt.armv6.a";
359  } else {
360    // The dynamic runtime library was merged with libSystem for 10.6 and
361    // beyond; only 10.4 and 10.5 need an additional runtime library.
362    if (isMacosxVersionLT(10, 5))
363      CmdArgs.push_back("-lgcc_s.10.4");
364    else if (isMacosxVersionLT(10, 6))
365      CmdArgs.push_back("-lgcc_s.10.5");
366
367    // For OS X, we only need a static runtime library when targetting 10.4, to
368    // provide versions of the static functions which were omitted from
369    // 10.4.dylib.
370    if (isMacosxVersionLT(10, 5))
371      DarwinStaticLib = "libclang_rt.10.4.a";
372  }
373
374  /// Add the target specific static library, if needed.
375  if (DarwinStaticLib) {
376    llvm::sys::Path P(getDriver().ResourceDir);
377    P.appendComponent("lib");
378    P.appendComponent("darwin");
379    P.appendComponent(DarwinStaticLib);
380
381    // For now, allow missing resource libraries to support developers who may
382    // not have compiler-rt checked out or integrated into their build.
383    if (!P.exists())
384      getDriver().Diag(clang::diag::warn_drv_missing_resource_library)
385        << P.str();
386    else
387      CmdArgs.push_back(Args.MakeArgString(P.str()));
388  }
389}
390
391DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
392                                      const char *BoundArch) const {
393  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
394  const OptTable &Opts = getDriver().getOpts();
395
396  // FIXME: We really want to get out of the tool chain level argument
397  // translation business, as it makes the driver functionality much
398  // more opaque. For now, we follow gcc closely solely for the
399  // purpose of easily achieving feature parity & testability. Once we
400  // have something that works, we should reevaluate each translation
401  // and try to push it down into tool specific logic.
402
403  Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
404  Arg *iPhoneVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
405  if (OSXVersion && iPhoneVersion) {
406    getDriver().Diag(clang::diag::err_drv_argument_not_allowed_with)
407          << OSXVersion->getAsString(Args)
408          << iPhoneVersion->getAsString(Args);
409    iPhoneVersion = 0;
410  } else if (!OSXVersion && !iPhoneVersion) {
411    // If neither OS X nor iPhoneOS targets were specified, check for
412    // environment defines.
413    const char *OSXTarget = ::getenv("MACOSX_DEPLOYMENT_TARGET");
414    const char *iPhoneOSTarget = ::getenv("IPHONEOS_DEPLOYMENT_TARGET");
415
416    // Ignore empty strings.
417    if (OSXTarget && OSXTarget[0] == '\0')
418      OSXTarget = 0;
419    if (iPhoneOSTarget && iPhoneOSTarget[0] == '\0')
420      iPhoneOSTarget = 0;
421
422    // Diagnose conflicting deployment targets, and choose default platform
423    // based on the tool chain.
424    //
425    // FIXME: Don't hardcode default here.
426    if (OSXTarget && iPhoneOSTarget) {
427      // FIXME: We should see if we can get away with warning or erroring on
428      // this. Perhaps put under -pedantic?
429      if (getTriple().getArch() == llvm::Triple::arm ||
430          getTriple().getArch() == llvm::Triple::thumb)
431        OSXTarget = 0;
432      else
433        iPhoneOSTarget = 0;
434    }
435
436    if (OSXTarget) {
437      const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
438      OSXVersion = DAL->MakeJoinedArg(0, O, OSXTarget);
439      DAL->append(OSXVersion);
440    } else if (iPhoneOSTarget) {
441      const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
442      iPhoneVersion = DAL->MakeJoinedArg(0, O, iPhoneOSTarget);
443      DAL->append(iPhoneVersion);
444    } else {
445      // Otherwise, choose a default platform based on the tool chain.
446      //
447      // FIXME: Don't hardcode default here.
448      if (getTriple().getArch() == llvm::Triple::arm ||
449          getTriple().getArch() == llvm::Triple::thumb) {
450        const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
451        iPhoneVersion = DAL->MakeJoinedArg(0, O, "3.0");
452        DAL->append(iPhoneVersion);
453      } else {
454        const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
455        OSXVersion = DAL->MakeJoinedArg(0, O, MacosxVersionMin);
456        DAL->append(OSXVersion);
457      }
458    }
459  }
460
461  // Set the tool chain target information.
462  unsigned Major, Minor, Micro;
463  bool HadExtra;
464  if (OSXVersion) {
465    assert(!iPhoneVersion && "Unknown target platform!");
466    if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor,
467                                   Micro, HadExtra) || HadExtra ||
468        Major != 10 || Minor >= 10 || Micro >= 10)
469      getDriver().Diag(clang::diag::err_drv_invalid_version_number)
470        << OSXVersion->getAsString(Args);
471  } else {
472    assert(iPhoneVersion && "Unknown target platform!");
473    if (!Driver::GetReleaseVersion(iPhoneVersion->getValue(Args), Major, Minor,
474                                   Micro, HadExtra) || HadExtra ||
475        Major >= 10 || Minor >= 100 || Micro >= 100)
476      getDriver().Diag(clang::diag::err_drv_invalid_version_number)
477        << iPhoneVersion->getAsString(Args);
478  }
479  setTarget(iPhoneVersion, Major, Minor, Micro);
480
481  for (ArgList::const_iterator it = Args.begin(),
482         ie = Args.end(); it != ie; ++it) {
483    Arg *A = *it;
484
485    if (A->getOption().matches(options::OPT_Xarch__)) {
486      // FIXME: Canonicalize name.
487      if (getArchName() != A->getValue(Args, 0))
488        continue;
489
490      // FIXME: The arg is leaked here, and we should have a nicer
491      // interface for this.
492      unsigned Prev, Index = Prev = A->getIndex() + 1;
493      Arg *XarchArg = Opts.ParseOneArg(Args, Index);
494
495      // If the argument parsing failed or more than one argument was
496      // consumed, the -Xarch_ argument's parameter tried to consume
497      // extra arguments. Emit an error and ignore.
498      //
499      // We also want to disallow any options which would alter the
500      // driver behavior; that isn't going to work in our model. We
501      // use isDriverOption() as an approximation, although things
502      // like -O4 are going to slip through.
503      if (!XarchArg || Index > Prev + 1 ||
504          XarchArg->getOption().isDriverOption()) {
505       getDriver().Diag(clang::diag::err_drv_invalid_Xarch_argument)
506          << A->getAsString(Args);
507        continue;
508      }
509
510      XarchArg->setBaseArg(A);
511      A = XarchArg;
512    }
513
514    // Sob. These is strictly gcc compatible for the time being. Apple
515    // gcc translates options twice, which means that self-expanding
516    // options add duplicates.
517    switch ((options::ID) A->getOption().getID()) {
518    default:
519      DAL->append(A);
520      break;
521
522    case options::OPT_mkernel:
523    case options::OPT_fapple_kext:
524      DAL->append(A);
525      DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
526      DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
527      break;
528
529    case options::OPT_dependency_file:
530      DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF),
531                          A->getValue(Args));
532      break;
533
534    case options::OPT_gfull:
535      DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
536      DAL->AddFlagArg(A,
537               Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
538      break;
539
540    case options::OPT_gused:
541      DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
542      DAL->AddFlagArg(A,
543             Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
544      break;
545
546    case options::OPT_fterminated_vtables:
547    case options::OPT_findirect_virtual_calls:
548      DAL->AddFlagArg(A, Opts.getOption(options::OPT_fapple_kext));
549      DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
550      break;
551
552    case options::OPT_shared:
553      DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
554      break;
555
556    case options::OPT_fconstant_cfstrings:
557      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
558      break;
559
560    case options::OPT_fno_constant_cfstrings:
561      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
562      break;
563
564    case options::OPT_Wnonportable_cfstrings:
565      DAL->AddFlagArg(A,
566                      Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
567      break;
568
569    case options::OPT_Wno_nonportable_cfstrings:
570      DAL->AddFlagArg(A,
571                   Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
572      break;
573
574    case options::OPT_fpascal_strings:
575      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
576      break;
577
578    case options::OPT_fno_pascal_strings:
579      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
580      break;
581    }
582  }
583
584  if (getTriple().getArch() == llvm::Triple::x86 ||
585      getTriple().getArch() == llvm::Triple::x86_64)
586    if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
587      DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2");
588
589  // Add the arch options based on the particular spelling of -arch, to match
590  // how the driver driver works.
591  if (BoundArch) {
592    llvm::StringRef Name = BoundArch;
593    const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ);
594    const Option *MArch = Opts.getOption(options::OPT_march_EQ);
595
596    // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
597    // which defines the list of which architectures we accept.
598    if (Name == "ppc")
599      ;
600    else if (Name == "ppc601")
601      DAL->AddJoinedArg(0, MCpu, "601");
602    else if (Name == "ppc603")
603      DAL->AddJoinedArg(0, MCpu, "603");
604    else if (Name == "ppc604")
605      DAL->AddJoinedArg(0, MCpu, "604");
606    else if (Name == "ppc604e")
607      DAL->AddJoinedArg(0, MCpu, "604e");
608    else if (Name == "ppc750")
609      DAL->AddJoinedArg(0, MCpu, "750");
610    else if (Name == "ppc7400")
611      DAL->AddJoinedArg(0, MCpu, "7400");
612    else if (Name == "ppc7450")
613      DAL->AddJoinedArg(0, MCpu, "7450");
614    else if (Name == "ppc970")
615      DAL->AddJoinedArg(0, MCpu, "970");
616
617    else if (Name == "ppc64")
618      DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
619
620    else if (Name == "i386")
621      ;
622    else if (Name == "i486")
623      DAL->AddJoinedArg(0, MArch, "i486");
624    else if (Name == "i586")
625      DAL->AddJoinedArg(0, MArch, "i586");
626    else if (Name == "i686")
627      DAL->AddJoinedArg(0, MArch, "i686");
628    else if (Name == "pentium")
629      DAL->AddJoinedArg(0, MArch, "pentium");
630    else if (Name == "pentium2")
631      DAL->AddJoinedArg(0, MArch, "pentium2");
632    else if (Name == "pentpro")
633      DAL->AddJoinedArg(0, MArch, "pentiumpro");
634    else if (Name == "pentIIm3")
635      DAL->AddJoinedArg(0, MArch, "pentium2");
636
637    else if (Name == "x86_64")
638      DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
639
640    else if (Name == "arm")
641      DAL->AddJoinedArg(0, MArch, "armv4t");
642    else if (Name == "armv4t")
643      DAL->AddJoinedArg(0, MArch, "armv4t");
644    else if (Name == "armv5")
645      DAL->AddJoinedArg(0, MArch, "armv5tej");
646    else if (Name == "xscale")
647      DAL->AddJoinedArg(0, MArch, "xscale");
648    else if (Name == "armv6")
649      DAL->AddJoinedArg(0, MArch, "armv6k");
650    else if (Name == "armv7")
651      DAL->AddJoinedArg(0, MArch, "armv7a");
652
653    else
654      llvm_unreachable("invalid Darwin arch");
655  }
656
657  return DAL;
658}
659
660bool Darwin::IsUnwindTablesDefault() const {
661  // FIXME: Gross; we should probably have some separate target
662  // definition, possibly even reusing the one in clang.
663  return getArchName() == "x86_64";
664}
665
666bool Darwin::UseDwarfDebugFlags() const {
667  if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
668    return S[0] != '\0';
669  return false;
670}
671
672bool Darwin::UseSjLjExceptions() const {
673  // Darwin uses SjLj exceptions on ARM.
674  return (getTriple().getArch() == llvm::Triple::arm ||
675          getTriple().getArch() == llvm::Triple::thumb);
676}
677
678const char *Darwin::GetDefaultRelocationModel() const {
679  return "pic";
680}
681
682const char *Darwin::GetForcedPicModel() const {
683  if (getArchName() == "x86_64")
684    return "pic";
685  return 0;
686}
687
688bool Darwin::SupportsObjCGC() const {
689  // Garbage collection is supported everywhere except on iPhone OS.
690  return !isTargetIPhoneOS();
691}
692
693/// Generic_GCC - A tool chain using the 'gcc' command to perform
694/// all subcommands; this relies on gcc translating the majority of
695/// command line options.
696
697Generic_GCC::Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple)
698  : ToolChain(Host, Triple) {
699  getProgramPaths().push_back(getDriver().Dir);
700}
701
702Generic_GCC::~Generic_GCC() {
703  // Free tool implementations.
704  for (llvm::DenseMap<unsigned, Tool*>::iterator
705         it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
706    delete it->second;
707}
708
709Tool &Generic_GCC::SelectTool(const Compilation &C,
710                              const JobAction &JA) const {
711  Action::ActionClass Key;
712  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
713    Key = Action::AnalyzeJobClass;
714  else
715    Key = JA.getKind();
716
717  Tool *&T = Tools[Key];
718  if (!T) {
719    switch (Key) {
720    case Action::InputClass:
721    case Action::BindArchClass:
722      assert(0 && "Invalid tool kind.");
723    case Action::PreprocessJobClass:
724      T = new tools::gcc::Preprocess(*this); break;
725    case Action::PrecompileJobClass:
726      T = new tools::gcc::Precompile(*this); break;
727    case Action::AnalyzeJobClass:
728      T = new tools::Clang(*this); break;
729    case Action::CompileJobClass:
730      T = new tools::gcc::Compile(*this); break;
731    case Action::AssembleJobClass:
732      T = new tools::gcc::Assemble(*this); break;
733    case Action::LinkJobClass:
734      T = new tools::gcc::Link(*this); break;
735
736      // This is a bit ungeneric, but the only platform using a driver
737      // driver is Darwin.
738    case Action::LipoJobClass:
739      T = new tools::darwin::Lipo(*this); break;
740    case Action::DsymutilJobClass:
741      T = new tools::darwin::Dsymutil(*this); break;
742    }
743  }
744
745  return *T;
746}
747
748bool Generic_GCC::IsUnwindTablesDefault() const {
749  // FIXME: Gross; we should probably have some separate target
750  // definition, possibly even reusing the one in clang.
751  return getArchName() == "x86_64";
752}
753
754const char *Generic_GCC::GetDefaultRelocationModel() const {
755  return "static";
756}
757
758const char *Generic_GCC::GetForcedPicModel() const {
759  return 0;
760}
761
762/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
763/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
764/// Currently does not support anything else but compilation.
765
766TCEToolChain::TCEToolChain(const HostInfo &Host, const llvm::Triple& Triple)
767  : ToolChain(Host, Triple) {
768  // Path mangling to find libexec
769  std::string Path(getDriver().Dir);
770
771  Path += "/../libexec";
772  getProgramPaths().push_back(Path);
773}
774
775TCEToolChain::~TCEToolChain() {
776  for (llvm::DenseMap<unsigned, Tool*>::iterator
777           it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
778      delete it->second;
779}
780
781bool TCEToolChain::IsMathErrnoDefault() const {
782  return true;
783}
784
785bool TCEToolChain::IsUnwindTablesDefault() const {
786  return false;
787}
788
789const char *TCEToolChain::GetDefaultRelocationModel() const {
790  return "static";
791}
792
793const char *TCEToolChain::GetForcedPicModel() const {
794  return 0;
795}
796
797Tool &TCEToolChain::SelectTool(const Compilation &C,
798                            const JobAction &JA) const {
799  Action::ActionClass Key;
800  Key = Action::AnalyzeJobClass;
801
802  Tool *&T = Tools[Key];
803  if (!T) {
804    switch (Key) {
805    case Action::PreprocessJobClass:
806      T = new tools::gcc::Preprocess(*this); break;
807    case Action::AnalyzeJobClass:
808      T = new tools::Clang(*this); break;
809    default:
810     assert(false && "Unsupported action for TCE target.");
811    }
812  }
813  return *T;
814}
815
816/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
817
818OpenBSD::OpenBSD(const HostInfo &Host, const llvm::Triple& Triple)
819  : Generic_GCC(Host, Triple) {
820  getFilePaths().push_back(getDriver().Dir + "/../lib");
821  getFilePaths().push_back("/usr/lib");
822}
823
824Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA) const {
825  Action::ActionClass Key;
826  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
827    Key = Action::AnalyzeJobClass;
828  else
829    Key = JA.getKind();
830
831  Tool *&T = Tools[Key];
832  if (!T) {
833    switch (Key) {
834    case Action::AssembleJobClass:
835      T = new tools::openbsd::Assemble(*this); break;
836    case Action::LinkJobClass:
837      T = new tools::openbsd::Link(*this); break;
838    default:
839      T = &Generic_GCC::SelectTool(C, JA);
840    }
841  }
842
843  return *T;
844}
845
846/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
847
848FreeBSD::FreeBSD(const HostInfo &Host, const llvm::Triple& Triple, bool Lib32)
849  : Generic_GCC(Host, Triple) {
850  if (Lib32) {
851    getFilePaths().push_back(getDriver().Dir + "/../lib32");
852    getFilePaths().push_back("/usr/lib32");
853  } else {
854    getFilePaths().push_back(getDriver().Dir + "/../lib");
855    getFilePaths().push_back("/usr/lib");
856  }
857}
858
859Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA) const {
860  Action::ActionClass Key;
861  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
862    Key = Action::AnalyzeJobClass;
863  else
864    Key = JA.getKind();
865
866  Tool *&T = Tools[Key];
867  if (!T) {
868    switch (Key) {
869    case Action::AssembleJobClass:
870      T = new tools::freebsd::Assemble(*this); break;
871    case Action::LinkJobClass:
872      T = new tools::freebsd::Link(*this); break;
873    default:
874      T = &Generic_GCC::SelectTool(C, JA);
875    }
876  }
877
878  return *T;
879}
880
881/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
882
883AuroraUX::AuroraUX(const HostInfo &Host, const llvm::Triple& Triple)
884  : Generic_GCC(Host, Triple) {
885
886  getProgramPaths().push_back(getDriver().Dir);
887
888  getFilePaths().push_back(getDriver().Dir + "/../lib");
889  getFilePaths().push_back("/usr/lib");
890  getFilePaths().push_back("/usr/sfw/lib");
891  getFilePaths().push_back("/opt/gcc4/lib");
892  getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
893
894}
895
896Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA) const {
897  Action::ActionClass Key;
898  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
899    Key = Action::AnalyzeJobClass;
900  else
901    Key = JA.getKind();
902
903  Tool *&T = Tools[Key];
904  if (!T) {
905    switch (Key) {
906    case Action::AssembleJobClass:
907      T = new tools::auroraux::Assemble(*this); break;
908    case Action::LinkJobClass:
909      T = new tools::auroraux::Link(*this); break;
910    default:
911      T = &Generic_GCC::SelectTool(C, JA);
912    }
913  }
914
915  return *T;
916}
917
918
919/// Linux toolchain (very bare-bones at the moment).
920
921Linux::Linux(const HostInfo &Host, const llvm::Triple& Triple)
922  : Generic_GCC(Host, Triple) {
923  getFilePaths().push_back(getDriver().Dir + "/../lib/clang/1.0/");
924  getFilePaths().push_back("/lib/");
925  getFilePaths().push_back("/usr/lib/");
926
927  // Depending on the Linux distribution, any combination of lib{,32,64} is
928  // possible. E.g. Debian uses lib and lib32 for mixed i386/x86-64 systems,
929  // openSUSE uses lib and lib64 for the same purpose.
930  getFilePaths().push_back("/lib32/");
931  getFilePaths().push_back("/usr/lib32/");
932  getFilePaths().push_back("/lib64/");
933  getFilePaths().push_back("/usr/lib64/");
934
935  // FIXME: Figure out some way to get gcc's libdir
936  // (e.g. /usr/lib/gcc/i486-linux-gnu/4.3/ for Ubuntu 32-bit); we need
937  // crtbegin.o/crtend.o/etc., and want static versions of various
938  // libraries. If we had our own crtbegin.o/crtend.o/etc, we could probably
939  // get away with using shared versions in /usr/lib, though.
940  // We could fall back to the approach we used for includes (a massive
941  // list), but that's messy at best.
942}
943
944/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
945
946DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple)
947  : Generic_GCC(Host, Triple) {
948
949  // Path mangling to find libexec
950  getProgramPaths().push_back(getDriver().Dir);
951
952  getFilePaths().push_back(getDriver().Dir + "/../lib");
953  getFilePaths().push_back("/usr/lib");
954  getFilePaths().push_back("/usr/lib/gcc41");
955}
956
957Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA) const {
958  Action::ActionClass Key;
959  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
960    Key = Action::AnalyzeJobClass;
961  else
962    Key = JA.getKind();
963
964  Tool *&T = Tools[Key];
965  if (!T) {
966    switch (Key) {
967    case Action::AssembleJobClass:
968      T = new tools::dragonfly::Assemble(*this); break;
969    case Action::LinkJobClass:
970      T = new tools::dragonfly::Link(*this); break;
971    default:
972      T = &Generic_GCC::SelectTool(C, JA);
973    }
974  }
975
976  return *T;
977}
978