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