ToolChains.cpp revision 210299 
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  // Unfortunately, we still might depend on a few of the libraries that are
330  // only available in the gcc library directory (in particular
331  // libstdc++.dylib). For now, hardcode the path to the known install location.
332  llvm::sys::Path P(getDriver().Dir);
333  P.eraseComponent(); // .../usr/bin -> ../usr
334  P.appendComponent("lib");
335  P.appendComponent("gcc");
336  switch (getTriple().getArch()) {
337  default:
338    assert(0 && "Invalid Darwin arch!");
339  case llvm::Triple::x86:
340  case llvm::Triple::x86_64:
341    P.appendComponent("i686-apple-darwin10");
342    break;
343  case llvm::Triple::arm:
344  case llvm::Triple::thumb:
345    P.appendComponent("arm-apple-darwin10");
346    break;
347  case llvm::Triple::ppc:
348  case llvm::Triple::ppc64:
349    P.appendComponent("powerpc-apple-darwin10");
350    break;
351  }
352  P.appendComponent("4.2.1");
353  if (P.exists())
354    CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
355}
356
357void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
358                                        ArgStringList &CmdArgs) const {
359  // Darwin doesn't support real static executables, don't link any runtime
360  // libraries with -static.
361  if (Args.hasArg(options::OPT_static))
362    return;
363
364  // Reject -static-libgcc for now, we can deal with this when and if someone
365  // cares. This is useful in situations where someone wants to statically link
366  // something like libstdc++, and needs its runtime support routines.
367  if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
368    getDriver().Diag(clang::diag::err_drv_unsupported_opt)
369      << A->getAsString(Args);
370    return;
371  }
372
373  // Otherwise link libSystem, then the dynamic runtime library, and finally any
374  // target specific static runtime library.
375  CmdArgs.push_back("-lSystem");
376
377  // Select the dynamic runtime library and the target specific static library.
378  const char *DarwinStaticLib = 0;
379  if (isTargetIPhoneOS()) {
380    CmdArgs.push_back("-lgcc_s.1");
381
382    // We may need some static functions for armv6/thumb which are required to
383    // be in the same linkage unit as their caller.
384    if (getDarwinArchName(Args) == "armv6")
385      DarwinStaticLib = "libclang_rt.armv6.a";
386  } else {
387    // The dynamic runtime library was merged with libSystem for 10.6 and
388    // beyond; only 10.4 and 10.5 need an additional runtime library.
389    if (isMacosxVersionLT(10, 5))
390      CmdArgs.push_back("-lgcc_s.10.4");
391    else if (isMacosxVersionLT(10, 6))
392      CmdArgs.push_back("-lgcc_s.10.5");
393
394    // For OS X, we only need a static runtime library when targetting 10.4, to
395    // provide versions of the static functions which were omitted from
396    // 10.4.dylib.
397    if (isMacosxVersionLT(10, 5))
398      DarwinStaticLib = "libclang_rt.10.4.a";
399  }
400
401  /// Add the target specific static library, if needed.
402  if (DarwinStaticLib) {
403    llvm::sys::Path P(getDriver().ResourceDir);
404    P.appendComponent("lib");
405    P.appendComponent("darwin");
406    P.appendComponent(DarwinStaticLib);
407
408    // For now, allow missing resource libraries to support developers who may
409    // not have compiler-rt checked out or integrated into their build.
410    if (!P.exists())
411      getDriver().Diag(clang::diag::warn_drv_missing_resource_library)
412        << P.str();
413    else
414      CmdArgs.push_back(Args.MakeArgString(P.str()));
415  }
416}
417
418DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
419                                      const char *BoundArch) const {
420  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
421  const OptTable &Opts = getDriver().getOpts();
422
423  // FIXME: We really want to get out of the tool chain level argument
424  // translation business, as it makes the driver functionality much
425  // more opaque. For now, we follow gcc closely solely for the
426  // purpose of easily achieving feature parity & testability. Once we
427  // have something that works, we should reevaluate each translation
428  // and try to push it down into tool specific logic.
429
430  Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
431  Arg *iPhoneVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
432  if (OSXVersion && iPhoneVersion) {
433    getDriver().Diag(clang::diag::err_drv_argument_not_allowed_with)
434          << OSXVersion->getAsString(Args)
435          << iPhoneVersion->getAsString(Args);
436    iPhoneVersion = 0;
437  } else if (!OSXVersion && !iPhoneVersion) {
438    // If neither OS X nor iPhoneOS targets were specified, check for
439    // environment defines.
440    const char *OSXTarget = ::getenv("MACOSX_DEPLOYMENT_TARGET");
441    const char *iPhoneOSTarget = ::getenv("IPHONEOS_DEPLOYMENT_TARGET");
442
443    // Ignore empty strings.
444    if (OSXTarget && OSXTarget[0] == '\0')
445      OSXTarget = 0;
446    if (iPhoneOSTarget && iPhoneOSTarget[0] == '\0')
447      iPhoneOSTarget = 0;
448
449    // Diagnose conflicting deployment targets, and choose default platform
450    // based on the tool chain.
451    //
452    // FIXME: Don't hardcode default here.
453    if (OSXTarget && iPhoneOSTarget) {
454      // FIXME: We should see if we can get away with warning or erroring on
455      // this. Perhaps put under -pedantic?
456      if (getTriple().getArch() == llvm::Triple::arm ||
457          getTriple().getArch() == llvm::Triple::thumb)
458        OSXTarget = 0;
459      else
460        iPhoneOSTarget = 0;
461    }
462
463    if (OSXTarget) {
464      const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
465      OSXVersion = DAL->MakeJoinedArg(0, O, OSXTarget);
466      DAL->append(OSXVersion);
467    } else if (iPhoneOSTarget) {
468      const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
469      iPhoneVersion = DAL->MakeJoinedArg(0, O, iPhoneOSTarget);
470      DAL->append(iPhoneVersion);
471    } else {
472      // Otherwise, assume we are targeting OS X.
473      const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
474      OSXVersion = DAL->MakeJoinedArg(0, O, MacosxVersionMin);
475      DAL->append(OSXVersion);
476    }
477  }
478
479  // Set the tool chain target information.
480  unsigned Major, Minor, Micro;
481  bool HadExtra;
482  if (OSXVersion) {
483    assert(!iPhoneVersion && "Unknown target platform!");
484    if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor,
485                                   Micro, HadExtra) || HadExtra ||
486        Major != 10 || Minor >= 10 || Micro >= 10)
487      getDriver().Diag(clang::diag::err_drv_invalid_version_number)
488        << OSXVersion->getAsString(Args);
489  } else {
490    assert(iPhoneVersion && "Unknown target platform!");
491    if (!Driver::GetReleaseVersion(iPhoneVersion->getValue(Args), Major, Minor,
492                                   Micro, HadExtra) || HadExtra ||
493        Major >= 10 || Minor >= 100 || Micro >= 100)
494      getDriver().Diag(clang::diag::err_drv_invalid_version_number)
495        << iPhoneVersion->getAsString(Args);
496  }
497  setTarget(iPhoneVersion, Major, Minor, Micro);
498
499  for (ArgList::const_iterator it = Args.begin(),
500         ie = Args.end(); it != ie; ++it) {
501    Arg *A = *it;
502
503    if (A->getOption().matches(options::OPT_Xarch__)) {
504      // FIXME: Canonicalize name.
505      if (getArchName() != A->getValue(Args, 0))
506        continue;
507
508      unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1));
509      unsigned Prev = Index;
510      Arg *XarchArg = Opts.ParseOneArg(Args, Index);
511
512      // If the argument parsing failed or more than one argument was
513      // consumed, the -Xarch_ argument's parameter tried to consume
514      // extra arguments. Emit an error and ignore.
515      //
516      // We also want to disallow any options which would alter the
517      // driver behavior; that isn't going to work in our model. We
518      // use isDriverOption() as an approximation, although things
519      // like -O4 are going to slip through.
520      if (!XarchArg || Index > Prev + 1 ||
521          XarchArg->getOption().isDriverOption()) {
522       getDriver().Diag(clang::diag::err_drv_invalid_Xarch_argument)
523          << A->getAsString(Args);
524        continue;
525      }
526
527      XarchArg->setBaseArg(A);
528      A = XarchArg;
529
530      DAL->AddSynthesizedArg(A);
531    }
532
533    // Sob. These is strictly gcc compatible for the time being. Apple
534    // gcc translates options twice, which means that self-expanding
535    // options add duplicates.
536    switch ((options::ID) A->getOption().getID()) {
537    default:
538      DAL->append(A);
539      break;
540
541    case options::OPT_mkernel:
542    case options::OPT_fapple_kext:
543      DAL->append(A);
544      DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
545      DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
546      break;
547
548    case options::OPT_dependency_file:
549      DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF),
550                          A->getValue(Args));
551      break;
552
553    case options::OPT_gfull:
554      DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
555      DAL->AddFlagArg(A,
556               Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
557      break;
558
559    case options::OPT_gused:
560      DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
561      DAL->AddFlagArg(A,
562             Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
563      break;
564
565    case options::OPT_fterminated_vtables:
566    case options::OPT_findirect_virtual_calls:
567      DAL->AddFlagArg(A, Opts.getOption(options::OPT_fapple_kext));
568      DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
569      break;
570
571    case options::OPT_shared:
572      DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
573      break;
574
575    case options::OPT_fconstant_cfstrings:
576      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
577      break;
578
579    case options::OPT_fno_constant_cfstrings:
580      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
581      break;
582
583    case options::OPT_Wnonportable_cfstrings:
584      DAL->AddFlagArg(A,
585                      Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
586      break;
587
588    case options::OPT_Wno_nonportable_cfstrings:
589      DAL->AddFlagArg(A,
590                   Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
591      break;
592
593    case options::OPT_fpascal_strings:
594      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
595      break;
596
597    case options::OPT_fno_pascal_strings:
598      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
599      break;
600    }
601  }
602
603  if (getTriple().getArch() == llvm::Triple::x86 ||
604      getTriple().getArch() == llvm::Triple::x86_64)
605    if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
606      DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2");
607
608  // Add the arch options based on the particular spelling of -arch, to match
609  // how the driver driver works.
610  if (BoundArch) {
611    llvm::StringRef Name = BoundArch;
612    const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ);
613    const Option *MArch = Opts.getOption(options::OPT_march_EQ);
614
615    // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
616    // which defines the list of which architectures we accept.
617    if (Name == "ppc")
618      ;
619    else if (Name == "ppc601")
620      DAL->AddJoinedArg(0, MCpu, "601");
621    else if (Name == "ppc603")
622      DAL->AddJoinedArg(0, MCpu, "603");
623    else if (Name == "ppc604")
624      DAL->AddJoinedArg(0, MCpu, "604");
625    else if (Name == "ppc604e")
626      DAL->AddJoinedArg(0, MCpu, "604e");
627    else if (Name == "ppc750")
628      DAL->AddJoinedArg(0, MCpu, "750");
629    else if (Name == "ppc7400")
630      DAL->AddJoinedArg(0, MCpu, "7400");
631    else if (Name == "ppc7450")
632      DAL->AddJoinedArg(0, MCpu, "7450");
633    else if (Name == "ppc970")
634      DAL->AddJoinedArg(0, MCpu, "970");
635
636    else if (Name == "ppc64")
637      DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
638
639    else if (Name == "i386")
640      ;
641    else if (Name == "i486")
642      DAL->AddJoinedArg(0, MArch, "i486");
643    else if (Name == "i586")
644      DAL->AddJoinedArg(0, MArch, "i586");
645    else if (Name == "i686")
646      DAL->AddJoinedArg(0, MArch, "i686");
647    else if (Name == "pentium")
648      DAL->AddJoinedArg(0, MArch, "pentium");
649    else if (Name == "pentium2")
650      DAL->AddJoinedArg(0, MArch, "pentium2");
651    else if (Name == "pentpro")
652      DAL->AddJoinedArg(0, MArch, "pentiumpro");
653    else if (Name == "pentIIm3")
654      DAL->AddJoinedArg(0, MArch, "pentium2");
655
656    else if (Name == "x86_64")
657      DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
658
659    else if (Name == "arm")
660      DAL->AddJoinedArg(0, MArch, "armv4t");
661    else if (Name == "armv4t")
662      DAL->AddJoinedArg(0, MArch, "armv4t");
663    else if (Name == "armv5")
664      DAL->AddJoinedArg(0, MArch, "armv5tej");
665    else if (Name == "xscale")
666      DAL->AddJoinedArg(0, MArch, "xscale");
667    else if (Name == "armv6")
668      DAL->AddJoinedArg(0, MArch, "armv6k");
669    else if (Name == "armv7")
670      DAL->AddJoinedArg(0, MArch, "armv7a");
671
672    else
673      llvm_unreachable("invalid Darwin arch");
674  }
675
676  return DAL;
677}
678
679bool Darwin::IsUnwindTablesDefault() const {
680  // FIXME: Gross; we should probably have some separate target
681  // definition, possibly even reusing the one in clang.
682  return getArchName() == "x86_64";
683}
684
685bool Darwin::UseDwarfDebugFlags() const {
686  if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
687    return S[0] != '\0';
688  return false;
689}
690
691bool Darwin::UseSjLjExceptions() const {
692  // Darwin uses SjLj exceptions on ARM.
693  return (getTriple().getArch() == llvm::Triple::arm ||
694          getTriple().getArch() == llvm::Triple::thumb);
695}
696
697const char *Darwin::GetDefaultRelocationModel() const {
698  return "pic";
699}
700
701const char *Darwin::GetForcedPicModel() const {
702  if (getArchName() == "x86_64")
703    return "pic";
704  return 0;
705}
706
707bool Darwin::SupportsObjCGC() const {
708  // Garbage collection is supported everywhere except on iPhone OS.
709  return !isTargetIPhoneOS();
710}
711
712/// Generic_GCC - A tool chain using the 'gcc' command to perform
713/// all subcommands; this relies on gcc translating the majority of
714/// command line options.
715
716Generic_GCC::Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple)
717  : ToolChain(Host, Triple) {
718  getProgramPaths().push_back(getDriver().Dir);
719}
720
721Generic_GCC::~Generic_GCC() {
722  // Free tool implementations.
723  for (llvm::DenseMap<unsigned, Tool*>::iterator
724         it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
725    delete it->second;
726}
727
728Tool &Generic_GCC::SelectTool(const Compilation &C,
729                              const JobAction &JA) const {
730  Action::ActionClass Key;
731  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
732    Key = Action::AnalyzeJobClass;
733  else
734    Key = JA.getKind();
735
736  Tool *&T = Tools[Key];
737  if (!T) {
738    switch (Key) {
739    case Action::InputClass:
740    case Action::BindArchClass:
741      assert(0 && "Invalid tool kind.");
742    case Action::PreprocessJobClass:
743      T = new tools::gcc::Preprocess(*this); break;
744    case Action::PrecompileJobClass:
745      T = new tools::gcc::Precompile(*this); break;
746    case Action::AnalyzeJobClass:
747      T = new tools::Clang(*this); break;
748    case Action::CompileJobClass:
749      T = new tools::gcc::Compile(*this); break;
750    case Action::AssembleJobClass:
751      T = new tools::gcc::Assemble(*this); break;
752    case Action::LinkJobClass:
753      T = new tools::gcc::Link(*this); break;
754
755      // This is a bit ungeneric, but the only platform using a driver
756      // driver is Darwin.
757    case Action::LipoJobClass:
758      T = new tools::darwin::Lipo(*this); break;
759    case Action::DsymutilJobClass:
760      T = new tools::darwin::Dsymutil(*this); break;
761    }
762  }
763
764  return *T;
765}
766
767bool Generic_GCC::IsUnwindTablesDefault() const {
768  // FIXME: Gross; we should probably have some separate target
769  // definition, possibly even reusing the one in clang.
770  return getArchName() == "x86_64";
771}
772
773const char *Generic_GCC::GetDefaultRelocationModel() const {
774  return "static";
775}
776
777const char *Generic_GCC::GetForcedPicModel() const {
778  return 0;
779}
780
781/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
782/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
783/// Currently does not support anything else but compilation.
784
785TCEToolChain::TCEToolChain(const HostInfo &Host, const llvm::Triple& Triple)
786  : ToolChain(Host, Triple) {
787  // Path mangling to find libexec
788  std::string Path(getDriver().Dir);
789
790  Path += "/../libexec";
791  getProgramPaths().push_back(Path);
792}
793
794TCEToolChain::~TCEToolChain() {
795  for (llvm::DenseMap<unsigned, Tool*>::iterator
796           it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
797      delete it->second;
798}
799
800bool TCEToolChain::IsMathErrnoDefault() const {
801  return true;
802}
803
804bool TCEToolChain::IsUnwindTablesDefault() const {
805  return false;
806}
807
808const char *TCEToolChain::GetDefaultRelocationModel() const {
809  return "static";
810}
811
812const char *TCEToolChain::GetForcedPicModel() const {
813  return 0;
814}
815
816Tool &TCEToolChain::SelectTool(const Compilation &C,
817                            const JobAction &JA) const {
818  Action::ActionClass Key;
819  Key = Action::AnalyzeJobClass;
820
821  Tool *&T = Tools[Key];
822  if (!T) {
823    switch (Key) {
824    case Action::PreprocessJobClass:
825      T = new tools::gcc::Preprocess(*this); break;
826    case Action::AnalyzeJobClass:
827      T = new tools::Clang(*this); break;
828    default:
829     assert(false && "Unsupported action for TCE target.");
830    }
831  }
832  return *T;
833}
834
835/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
836
837OpenBSD::OpenBSD(const HostInfo &Host, const llvm::Triple& Triple)
838  : Generic_GCC(Host, Triple) {
839  getFilePaths().push_back(getDriver().Dir + "/../lib");
840  getFilePaths().push_back("/usr/lib");
841}
842
843Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA) const {
844  Action::ActionClass Key;
845  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
846    Key = Action::AnalyzeJobClass;
847  else
848    Key = JA.getKind();
849
850  Tool *&T = Tools[Key];
851  if (!T) {
852    switch (Key) {
853    case Action::AssembleJobClass:
854      T = new tools::openbsd::Assemble(*this); break;
855    case Action::LinkJobClass:
856      T = new tools::openbsd::Link(*this); break;
857    default:
858      T = &Generic_GCC::SelectTool(C, JA);
859    }
860  }
861
862  return *T;
863}
864
865/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
866
867FreeBSD::FreeBSD(const HostInfo &Host, const llvm::Triple& Triple, bool Lib32)
868  : Generic_GCC(Host, Triple) {
869  getProgramPaths().push_back(getDriver().Dir + "/../libexec");
870  getProgramPaths().push_back("/usr/libexec");
871  if (Lib32) {
872    getFilePaths().push_back(getDriver().Dir + "/../lib32");
873    getFilePaths().push_back("/usr/lib32");
874  } else {
875    getFilePaths().push_back(getDriver().Dir + "/../lib");
876    getFilePaths().push_back("/usr/lib");
877  }
878}
879
880Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA) const {
881  Action::ActionClass Key;
882  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
883    Key = Action::AnalyzeJobClass;
884  else
885    Key = JA.getKind();
886
887  Tool *&T = Tools[Key];
888  if (!T) {
889    switch (Key) {
890    case Action::AssembleJobClass:
891      T = new tools::freebsd::Assemble(*this); break;
892    case Action::LinkJobClass:
893      T = new tools::freebsd::Link(*this); break;
894    default:
895      T = &Generic_GCC::SelectTool(C, JA);
896    }
897  }
898
899  return *T;
900}
901
902/// Minix - Minix tool chain which can call as(1) and ld(1) directly.
903
904Minix::Minix(const HostInfo &Host, const llvm::Triple& Triple)
905  : Generic_GCC(Host, Triple) {
906  getFilePaths().push_back(getDriver().Dir + "/../lib");
907  getFilePaths().push_back("/usr/lib");
908  getFilePaths().push_back("/usr/gnu/lib");
909  getFilePaths().push_back("/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
910}
911
912Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA) const {
913  Action::ActionClass Key;
914  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
915    Key = Action::AnalyzeJobClass;
916  else
917    Key = JA.getKind();
918
919  Tool *&T = Tools[Key];
920  if (!T) {
921    switch (Key) {
922    case Action::AssembleJobClass:
923      T = new tools::minix::Assemble(*this); break;
924    case Action::LinkJobClass:
925      T = new tools::minix::Link(*this); break;
926    default:
927      T = &Generic_GCC::SelectTool(C, JA);
928    }
929  }
930
931  return *T;
932}
933
934/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
935
936AuroraUX::AuroraUX(const HostInfo &Host, const llvm::Triple& Triple)
937  : Generic_GCC(Host, Triple) {
938
939  getProgramPaths().push_back(getDriver().Dir);
940
941  getFilePaths().push_back(getDriver().Dir + "/../lib");
942  getFilePaths().push_back("/usr/lib");
943  getFilePaths().push_back("/usr/sfw/lib");
944  getFilePaths().push_back("/opt/gcc4/lib");
945  getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
946
947}
948
949Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA) const {
950  Action::ActionClass Key;
951  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
952    Key = Action::AnalyzeJobClass;
953  else
954    Key = JA.getKind();
955
956  Tool *&T = Tools[Key];
957  if (!T) {
958    switch (Key) {
959    case Action::AssembleJobClass:
960      T = new tools::auroraux::Assemble(*this); break;
961    case Action::LinkJobClass:
962      T = new tools::auroraux::Link(*this); break;
963    default:
964      T = &Generic_GCC::SelectTool(C, JA);
965    }
966  }
967
968  return *T;
969}
970
971
972/// Linux toolchain (very bare-bones at the moment).
973
974Linux::Linux(const HostInfo &Host, const llvm::Triple& Triple)
975  : Generic_GCC(Host, Triple) {
976  getFilePaths().push_back(getDriver().Dir + "/../lib/clang/1.0/");
977  getFilePaths().push_back("/lib/");
978  getFilePaths().push_back("/usr/lib/");
979
980  // Depending on the Linux distribution, any combination of lib{,32,64} is
981  // possible. E.g. Debian uses lib and lib32 for mixed i386/x86-64 systems,
982  // openSUSE uses lib and lib64 for the same purpose.
983  getFilePaths().push_back("/lib32/");
984  getFilePaths().push_back("/usr/lib32/");
985  getFilePaths().push_back("/lib64/");
986  getFilePaths().push_back("/usr/lib64/");
987
988  // FIXME: Figure out some way to get gcc's libdir
989  // (e.g. /usr/lib/gcc/i486-linux-gnu/4.3/ for Ubuntu 32-bit); we need
990  // crtbegin.o/crtend.o/etc., and want static versions of various
991  // libraries. If we had our own crtbegin.o/crtend.o/etc, we could probably
992  // get away with using shared versions in /usr/lib, though.
993  // We could fall back to the approach we used for includes (a massive
994  // list), but that's messy at best.
995}
996
997/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
998
999DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple)
1000  : Generic_GCC(Host, Triple) {
1001
1002  // Path mangling to find libexec
1003  getProgramPaths().push_back(getDriver().Dir);
1004
1005  getFilePaths().push_back(getDriver().Dir + "/../lib");
1006  getFilePaths().push_back("/usr/lib");
1007  getFilePaths().push_back("/usr/lib/gcc41");
1008}
1009
1010Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA) const {
1011  Action::ActionClass Key;
1012  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1013    Key = Action::AnalyzeJobClass;
1014  else
1015    Key = JA.getKind();
1016
1017  Tool *&T = Tools[Key];
1018  if (!T) {
1019    switch (Key) {
1020    case Action::AssembleJobClass:
1021      T = new tools::dragonfly::Assemble(*this); break;
1022    case Action::LinkJobClass:
1023      T = new tools::dragonfly::Link(*this); break;
1024    default:
1025      T = &Generic_GCC::SelectTool(C, JA);
1026    }
1027  }
1028
1029  return *T;
1030}
1031