ToolChains.cpp revision cb2e00ff6570144efaf69a03f5d20b9e6fce4f7d 
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/StringSwitch.h"
31#include "llvm/ADT/STLExtras.h"
32#include "llvm/Support/ErrorHandling.h"
33#include "llvm/Support/FileSystem.h"
34#include "llvm/Support/MemoryBuffer.h"
35#include "llvm/Support/raw_ostream.h"
36#include "llvm/Support/Path.h"
37#include "llvm/Support/system_error.h"
38
39#include <cstdlib> // ::getenv
40
41#include "llvm/Config/config.h" // for CXX_INCLUDE_ROOT
42
43// Include the necessary headers to interface with the Windows registry and
44// environment.
45#ifdef _MSC_VER
46  #define WIN32_LEAN_AND_MEAN
47  #define NOGDI
48  #define NOMINMAX
49  #include <Windows.h>
50#endif
51
52using namespace clang::driver;
53using namespace clang::driver::toolchains;
54using namespace clang;
55
56/// \brief Utility function to add a system include directory to CC1 arguments.
57static void addSystemInclude(const ArgList &DriverArgs, ArgStringList &CC1Args,
58                             const Twine &Path) {
59  CC1Args.push_back("-internal-isystem");
60  CC1Args.push_back(DriverArgs.MakeArgString(Path));
61}
62
63/// \brief Utility function to add a system include directory with extern "C"
64/// semantics to CC1 arguments.
65///
66/// Note that this should be used rarely, and only for directories that
67/// historically and for legacy reasons are treated as having implicit extern
68/// "C" semantics. These semantics are *ignored* by and large today, but its
69/// important to preserve the preprocessor changes resulting from the
70/// classification.
71static void addExternCSystemInclude(const ArgList &DriverArgs,
72                                    ArgStringList &CC1Args, const Twine &Path) {
73  CC1Args.push_back("-internal-externc-isystem");
74  CC1Args.push_back(DriverArgs.MakeArgString(Path));
75}
76
77/// \brief Utility function to add a list of system include directories to CC1.
78static void addSystemIncludes(const ArgList &DriverArgs,
79                              ArgStringList &CC1Args,
80                              ArrayRef<StringRef> Paths) {
81  for (ArrayRef<StringRef>::iterator I = Paths.begin(), E = Paths.end();
82       I != E; ++I) {
83    CC1Args.push_back("-internal-isystem");
84    CC1Args.push_back(DriverArgs.MakeArgString(*I));
85  }
86}
87
88/// Darwin - Darwin tool chain for i386 and x86_64.
89
90Darwin::Darwin(const HostInfo &Host, const llvm::Triple& Triple)
91  : ToolChain(Host, Triple), TargetInitialized(false),
92    ARCRuntimeForSimulator(ARCSimulator_None),
93    LibCXXForSimulator(LibCXXSimulator_None)
94{
95  // Compute the initial Darwin version based on the host.
96  bool HadExtra;
97  std::string OSName = Triple.getOSName();
98  if (!Driver::GetReleaseVersion(&OSName.c_str()[6],
99                                 DarwinVersion[0], DarwinVersion[1],
100                                 DarwinVersion[2], HadExtra))
101    getDriver().Diag(diag::err_drv_invalid_darwin_version) << OSName;
102
103  llvm::raw_string_ostream(MacosxVersionMin)
104    << "10." << std::max(0, (int)DarwinVersion[0] - 4) << '.'
105    << DarwinVersion[1];
106}
107
108types::ID Darwin::LookupTypeForExtension(const char *Ext) const {
109  types::ID Ty = types::lookupTypeForExtension(Ext);
110
111  // Darwin always preprocesses assembly files (unless -x is used explicitly).
112  if (Ty == types::TY_PP_Asm)
113    return types::TY_Asm;
114
115  return Ty;
116}
117
118bool Darwin::HasNativeLLVMSupport() const {
119  return true;
120}
121
122bool Darwin::hasARCRuntime() const {
123  // FIXME: Remove this once there is a proper way to detect an ARC runtime
124  // for the simulator.
125  switch (ARCRuntimeForSimulator) {
126  case ARCSimulator_None:
127    break;
128  case ARCSimulator_HasARCRuntime:
129    return true;
130  case ARCSimulator_NoARCRuntime:
131    return false;
132  }
133
134  if (isTargetIPhoneOS())
135    return !isIPhoneOSVersionLT(5);
136  else
137    return !isMacosxVersionLT(10, 7);
138}
139
140/// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
141void Darwin::configureObjCRuntime(ObjCRuntime &runtime) const {
142  if (runtime.getKind() != ObjCRuntime::NeXT)
143    return ToolChain::configureObjCRuntime(runtime);
144
145  runtime.HasARC = runtime.HasWeak = hasARCRuntime();
146
147  // So far, objc_terminate is only available in iOS 5.
148  // FIXME: do the simulator logic properly.
149  if (!ARCRuntimeForSimulator && isTargetIPhoneOS())
150    runtime.HasTerminate = !isIPhoneOSVersionLT(5);
151  else
152    runtime.HasTerminate = false;
153}
154
155/// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
156bool Darwin::hasBlocksRuntime() const {
157  if (isTargetIPhoneOS())
158    return !isIPhoneOSVersionLT(3, 2);
159  else
160    return !isMacosxVersionLT(10, 6);
161}
162
163static const char *GetArmArchForMArch(StringRef Value) {
164  return llvm::StringSwitch<const char*>(Value)
165    .Case("armv6k", "armv6")
166    .Case("armv5tej", "armv5")
167    .Case("xscale", "xscale")
168    .Case("armv4t", "armv4t")
169    .Case("armv7", "armv7")
170    .Cases("armv7a", "armv7-a", "armv7")
171    .Cases("armv7r", "armv7-r", "armv7")
172    .Cases("armv7m", "armv7-m", "armv7")
173    .Default(0);
174}
175
176static const char *GetArmArchForMCpu(StringRef Value) {
177  return llvm::StringSwitch<const char *>(Value)
178    .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "arm926ej-s","armv5")
179    .Cases("arm10e", "arm10tdmi", "armv5")
180    .Cases("arm1020t", "arm1020e", "arm1022e", "arm1026ej-s", "armv5")
181    .Case("xscale", "xscale")
182    .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s",
183           "arm1176jzf-s", "cortex-m0", "armv6")
184    .Cases("cortex-a8", "cortex-r4", "cortex-m3", "cortex-a9", "armv7")
185    .Default(0);
186}
187
188StringRef Darwin::getDarwinArchName(const ArgList &Args) const {
189  switch (getTriple().getArch()) {
190  default:
191    return getArchName();
192
193  case llvm::Triple::thumb:
194  case llvm::Triple::arm: {
195    if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
196      if (const char *Arch = GetArmArchForMArch(A->getValue(Args)))
197        return Arch;
198
199    if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
200      if (const char *Arch = GetArmArchForMCpu(A->getValue(Args)))
201        return Arch;
202
203    return "arm";
204  }
205  }
206}
207
208Darwin::~Darwin() {
209  // Free tool implementations.
210  for (llvm::DenseMap<unsigned, Tool*>::iterator
211         it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
212    delete it->second;
213}
214
215std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
216                                                types::ID InputType) const {
217  llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
218
219  // If the target isn't initialized (e.g., an unknown Darwin platform, return
220  // the default triple).
221  if (!isTargetInitialized())
222    return Triple.getTriple();
223
224  unsigned Version[3];
225  getTargetVersion(Version);
226
227  llvm::SmallString<16> Str;
228  llvm::raw_svector_ostream(Str)
229    << (isTargetIPhoneOS() ? "ios" : "macosx")
230    << Version[0] << "." << Version[1] << "." << Version[2];
231  Triple.setOSName(Str.str());
232
233  return Triple.getTriple();
234}
235
236Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA,
237                         const ActionList &Inputs) const {
238  Action::ActionClass Key;
239
240  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) {
241    // Fallback to llvm-gcc for i386 kext compiles, we don't support that ABI.
242    if (Inputs.size() == 1 &&
243        types::isCXX(Inputs[0]->getType()) &&
244        getTriple().isOSDarwin() &&
245        getTriple().getArch() == llvm::Triple::x86 &&
246        (C.getArgs().getLastArg(options::OPT_fapple_kext) ||
247         C.getArgs().getLastArg(options::OPT_mkernel)))
248      Key = JA.getKind();
249    else
250      Key = Action::AnalyzeJobClass;
251  } else
252    Key = JA.getKind();
253
254  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
255                                             options::OPT_no_integrated_as,
256                                             IsIntegratedAssemblerDefault());
257
258  Tool *&T = Tools[Key];
259  if (!T) {
260    switch (Key) {
261    case Action::InputClass:
262    case Action::BindArchClass:
263      llvm_unreachable("Invalid tool kind.");
264    case Action::PreprocessJobClass:
265      T = new tools::darwin::Preprocess(*this); break;
266    case Action::AnalyzeJobClass:
267      T = new tools::Clang(*this); break;
268    case Action::PrecompileJobClass:
269    case Action::CompileJobClass:
270      T = new tools::darwin::Compile(*this); break;
271    case Action::AssembleJobClass: {
272      if (UseIntegratedAs)
273        T = new tools::ClangAs(*this);
274      else
275        T = new tools::darwin::Assemble(*this);
276      break;
277    }
278    case Action::LinkJobClass:
279      T = new tools::darwin::Link(*this); break;
280    case Action::LipoJobClass:
281      T = new tools::darwin::Lipo(*this); break;
282    case Action::DsymutilJobClass:
283      T = new tools::darwin::Dsymutil(*this); break;
284    case Action::VerifyJobClass:
285      T = new tools::darwin::VerifyDebug(*this); break;
286    }
287  }
288
289  return *T;
290}
291
292
293DarwinClang::DarwinClang(const HostInfo &Host, const llvm::Triple& Triple)
294  : Darwin(Host, Triple)
295{
296  getProgramPaths().push_back(getDriver().getInstalledDir());
297  if (getDriver().getInstalledDir() != getDriver().Dir)
298    getProgramPaths().push_back(getDriver().Dir);
299
300  // We expect 'as', 'ld', etc. to be adjacent to our install dir.
301  getProgramPaths().push_back(getDriver().getInstalledDir());
302  if (getDriver().getInstalledDir() != getDriver().Dir)
303    getProgramPaths().push_back(getDriver().Dir);
304
305  // For fallback, we need to know how to find the GCC cc1 executables, so we
306  // also add the GCC libexec paths. This is legacy code that can be removed
307  // once fallback is no longer useful.
308  AddGCCLibexecPath(DarwinVersion[0]);
309  AddGCCLibexecPath(DarwinVersion[0] - 2);
310  AddGCCLibexecPath(DarwinVersion[0] - 1);
311  AddGCCLibexecPath(DarwinVersion[0] + 1);
312  AddGCCLibexecPath(DarwinVersion[0] + 2);
313}
314
315void DarwinClang::AddGCCLibexecPath(unsigned darwinVersion) {
316  std::string ToolChainDir = "i686-apple-darwin";
317  ToolChainDir += llvm::utostr(darwinVersion);
318  ToolChainDir += "/4.2.1";
319
320  std::string Path = getDriver().Dir;
321  Path += "/../llvm-gcc-4.2/libexec/gcc/";
322  Path += ToolChainDir;
323  getProgramPaths().push_back(Path);
324
325  Path = "/usr/llvm-gcc-4.2/libexec/gcc/";
326  Path += ToolChainDir;
327  getProgramPaths().push_back(Path);
328}
329
330void DarwinClang::AddLinkSearchPathArgs(const ArgList &Args,
331                                       ArgStringList &CmdArgs) const {
332  // The Clang toolchain uses explicit paths for internal libraries.
333
334  // Unfortunately, we still might depend on a few of the libraries that are
335  // only available in the gcc library directory (in particular
336  // libstdc++.dylib). For now, hardcode the path to the known install location.
337  llvm::sys::Path P(getDriver().Dir);
338  P.eraseComponent(); // .../usr/bin -> ../usr
339  P.appendComponent("lib");
340  P.appendComponent("gcc");
341  switch (getTriple().getArch()) {
342  default:
343    llvm_unreachable("Invalid Darwin arch!");
344  case llvm::Triple::x86:
345  case llvm::Triple::x86_64:
346    P.appendComponent("i686-apple-darwin10");
347    break;
348  case llvm::Triple::arm:
349  case llvm::Triple::thumb:
350    P.appendComponent("arm-apple-darwin10");
351    break;
352  case llvm::Triple::ppc:
353  case llvm::Triple::ppc64:
354    P.appendComponent("powerpc-apple-darwin10");
355    break;
356  }
357  P.appendComponent("4.2.1");
358
359  // Determine the arch specific GCC subdirectory.
360  const char *ArchSpecificDir = 0;
361  switch (getTriple().getArch()) {
362  default:
363    break;
364  case llvm::Triple::arm:
365  case llvm::Triple::thumb: {
366    std::string Triple = ComputeLLVMTriple(Args);
367    StringRef TripleStr = Triple;
368    if (TripleStr.startswith("armv5") || TripleStr.startswith("thumbv5"))
369      ArchSpecificDir = "v5";
370    else if (TripleStr.startswith("armv6") || TripleStr.startswith("thumbv6"))
371      ArchSpecificDir = "v6";
372    else if (TripleStr.startswith("armv7") || TripleStr.startswith("thumbv7"))
373      ArchSpecificDir = "v7";
374    break;
375  }
376  case llvm::Triple::ppc64:
377    ArchSpecificDir = "ppc64";
378    break;
379  case llvm::Triple::x86_64:
380    ArchSpecificDir = "x86_64";
381    break;
382  }
383
384  if (ArchSpecificDir) {
385    P.appendComponent(ArchSpecificDir);
386    bool Exists;
387    if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
388      CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
389    P.eraseComponent();
390  }
391
392  bool Exists;
393  if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
394    CmdArgs.push_back(Args.MakeArgString("-L" + P.str()));
395}
396
397void DarwinClang::AddLinkARCArgs(const ArgList &Args,
398                                 ArgStringList &CmdArgs) const {
399
400  CmdArgs.push_back("-force_load");
401  llvm::sys::Path P(getDriver().ClangExecutable);
402  P.eraseComponent(); // 'clang'
403  P.eraseComponent(); // 'bin'
404  P.appendComponent("lib");
405  P.appendComponent("arc");
406  P.appendComponent("libarclite_");
407  std::string s = P.str();
408  // Mash in the platform.
409  if (isTargetIOSSimulator())
410    s += "iphonesimulator";
411  else if (isTargetIPhoneOS())
412    s += "iphoneos";
413  // FIXME: Remove this once we depend fully on -mios-simulator-version-min.
414  else if (ARCRuntimeForSimulator != ARCSimulator_None)
415    s += "iphonesimulator";
416  else
417    s += "macosx";
418  s += ".a";
419
420  CmdArgs.push_back(Args.MakeArgString(s));
421}
422
423void DarwinClang::AddLinkRuntimeLib(const ArgList &Args,
424                                    ArgStringList &CmdArgs,
425                                    const char *DarwinStaticLib) const {
426  llvm::sys::Path P(getDriver().ResourceDir);
427  P.appendComponent("lib");
428  P.appendComponent("darwin");
429  P.appendComponent(DarwinStaticLib);
430
431  // For now, allow missing resource libraries to support developers who may
432  // not have compiler-rt checked out or integrated into their build.
433  bool Exists;
434  if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
435    CmdArgs.push_back(Args.MakeArgString(P.str()));
436}
437
438void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
439                                        ArgStringList &CmdArgs) const {
440  // Darwin doesn't support real static executables, don't link any runtime
441  // libraries with -static.
442  if (Args.hasArg(options::OPT_static))
443    return;
444
445  // Reject -static-libgcc for now, we can deal with this when and if someone
446  // cares. This is useful in situations where someone wants to statically link
447  // something like libstdc++, and needs its runtime support routines.
448  if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
449    getDriver().Diag(diag::err_drv_unsupported_opt)
450      << A->getAsString(Args);
451    return;
452  }
453
454  // Otherwise link libSystem, then the dynamic runtime library, and finally any
455  // target specific static runtime library.
456  CmdArgs.push_back("-lSystem");
457
458  // Select the dynamic runtime library and the target specific static library.
459  if (isTargetIPhoneOS()) {
460    // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
461    // it never went into the SDK.
462    // Linking against libgcc_s.1 isn't needed for iOS 5.0+
463    if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator())
464      CmdArgs.push_back("-lgcc_s.1");
465
466    // We currently always need a static runtime library for iOS.
467    AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
468  } else {
469    // The dynamic runtime library was merged with libSystem for 10.6 and
470    // beyond; only 10.4 and 10.5 need an additional runtime library.
471    if (isMacosxVersionLT(10, 5))
472      CmdArgs.push_back("-lgcc_s.10.4");
473    else if (isMacosxVersionLT(10, 6))
474      CmdArgs.push_back("-lgcc_s.10.5");
475
476    // For OS X, we thought we would only need a static runtime library when
477    // targeting 10.4, to provide versions of the static functions which were
478    // omitted from 10.4.dylib.
479    //
480    // Unfortunately, that turned out to not be true, because Darwin system
481    // headers can still use eprintf on i386, and it is not exported from
482    // libSystem. Therefore, we still must provide a runtime library just for
483    // the tiny tiny handful of projects that *might* use that symbol.
484    if (isMacosxVersionLT(10, 5)) {
485      AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
486    } else {
487      if (getTriple().getArch() == llvm::Triple::x86)
488        AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.eprintf.a");
489      AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
490    }
491  }
492}
493
494static inline StringRef SimulatorVersionDefineName() {
495  return "__IPHONE_OS_VERSION_MIN_REQUIRED";
496}
497
498/// \brief Parse the simulator version define:
499/// __IPHONE_OS_VERSION_MIN_REQUIRED=([0-9])([0-9][0-9])([0-9][0-9])
500// and return the grouped values as integers, e.g:
501//   __IPHONE_OS_VERSION_MIN_REQUIRED=40201
502// will return Major=4, Minor=2, Micro=1.
503static bool GetVersionFromSimulatorDefine(StringRef define,
504                                          unsigned &Major, unsigned &Minor,
505                                          unsigned &Micro) {
506  assert(define.startswith(SimulatorVersionDefineName()));
507  StringRef name, version;
508  llvm::tie(name, version) = define.split('=');
509  if (version.empty())
510    return false;
511  std::string verstr = version.str();
512  char *end;
513  unsigned num = (unsigned) strtol(verstr.c_str(), &end, 10);
514  if (*end != '\0')
515    return false;
516  Major = num / 10000;
517  num = num % 10000;
518  Minor = num / 100;
519  Micro = num % 100;
520  return true;
521}
522
523void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
524  const OptTable &Opts = getDriver().getOpts();
525
526  Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
527  Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
528  Arg *iOSSimVersion = Args.getLastArg(
529    options::OPT_mios_simulator_version_min_EQ);
530
531  // FIXME: HACK! When compiling for the simulator we don't get a
532  // '-miphoneos-version-min' to help us know whether there is an ARC runtime
533  // or not; try to parse a __IPHONE_OS_VERSION_MIN_REQUIRED
534  // define passed in command-line.
535  if (!iOSVersion && !iOSSimVersion) {
536    for (arg_iterator it = Args.filtered_begin(options::OPT_D),
537           ie = Args.filtered_end(); it != ie; ++it) {
538      StringRef define = (*it)->getValue(Args);
539      if (define.startswith(SimulatorVersionDefineName())) {
540        unsigned Major = 0, Minor = 0, Micro = 0;
541        if (GetVersionFromSimulatorDefine(define, Major, Minor, Micro) &&
542            Major < 10 && Minor < 100 && Micro < 100) {
543          ARCRuntimeForSimulator = Major < 5 ? ARCSimulator_NoARCRuntime
544                                             : ARCSimulator_HasARCRuntime;
545          LibCXXForSimulator = Major < 5 ? LibCXXSimulator_NotAvailable
546                                         : LibCXXSimulator_Available;
547        }
548        break;
549      }
550    }
551  }
552
553  if (OSXVersion && (iOSVersion || iOSSimVersion)) {
554    getDriver().Diag(diag::err_drv_argument_not_allowed_with)
555          << OSXVersion->getAsString(Args)
556          << (iOSVersion ? iOSVersion : iOSSimVersion)->getAsString(Args);
557    iOSVersion = iOSSimVersion = 0;
558  } else if (iOSVersion && iOSSimVersion) {
559    getDriver().Diag(diag::err_drv_argument_not_allowed_with)
560          << iOSVersion->getAsString(Args)
561          << iOSSimVersion->getAsString(Args);
562    iOSSimVersion = 0;
563  } else if (!OSXVersion && !iOSVersion && !iOSSimVersion) {
564    // If no deployment target was specified on the command line, check for
565    // environment defines.
566    StringRef OSXTarget;
567    StringRef iOSTarget;
568    StringRef iOSSimTarget;
569    if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
570      OSXTarget = env;
571    if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
572      iOSTarget = env;
573    if (char *env = ::getenv("IOS_SIMULATOR_DEPLOYMENT_TARGET"))
574      iOSSimTarget = env;
575
576    // If no '-miphoneos-version-min' specified on the command line and
577    // IPHONEOS_DEPLOYMENT_TARGET is not defined, see if we can set the default
578    // based on isysroot.
579    if (iOSTarget.empty()) {
580      if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
581        StringRef first, second;
582        StringRef isysroot = A->getValue(Args);
583        llvm::tie(first, second) = isysroot.split(StringRef("SDKs/iPhoneOS"));
584        if (second != "")
585          iOSTarget = second.substr(0,3);
586      }
587    }
588
589    // If no OSX or iOS target has been specified and we're compiling for armv7,
590    // go ahead as assume we're targeting iOS.
591    if (OSXTarget.empty() && iOSTarget.empty())
592      if (getDarwinArchName(Args) == "armv7")
593        iOSTarget = "0.0";
594
595    // Handle conflicting deployment targets
596    //
597    // FIXME: Don't hardcode default here.
598
599    // Do not allow conflicts with the iOS simulator target.
600    if (!iOSSimTarget.empty() && (!OSXTarget.empty() || !iOSTarget.empty())) {
601      getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
602        << "IOS_SIMULATOR_DEPLOYMENT_TARGET"
603        << (!OSXTarget.empty() ? "MACOSX_DEPLOYMENT_TARGET" :
604            "IPHONEOS_DEPLOYMENT_TARGET");
605    }
606
607    // Allow conflicts among OSX and iOS for historical reasons, but choose the
608    // default platform.
609    if (!OSXTarget.empty() && !iOSTarget.empty()) {
610      if (getTriple().getArch() == llvm::Triple::arm ||
611          getTriple().getArch() == llvm::Triple::thumb)
612        OSXTarget = "";
613      else
614        iOSTarget = "";
615    }
616
617    if (!OSXTarget.empty()) {
618      const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
619      OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget);
620      Args.append(OSXVersion);
621    } else if (!iOSTarget.empty()) {
622      const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
623      iOSVersion = Args.MakeJoinedArg(0, O, iOSTarget);
624      Args.append(iOSVersion);
625    } else if (!iOSSimTarget.empty()) {
626      const Option *O = Opts.getOption(
627        options::OPT_mios_simulator_version_min_EQ);
628      iOSSimVersion = Args.MakeJoinedArg(0, O, iOSSimTarget);
629      Args.append(iOSSimVersion);
630    } else {
631      // Otherwise, assume we are targeting OS X.
632      const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
633      OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin);
634      Args.append(OSXVersion);
635    }
636  }
637
638  // Reject invalid architecture combinations.
639  if (iOSSimVersion && (getTriple().getArch() != llvm::Triple::x86 &&
640                        getTriple().getArch() != llvm::Triple::x86_64)) {
641    getDriver().Diag(diag::err_drv_invalid_arch_for_deployment_target)
642      << getTriple().getArchName() << iOSSimVersion->getAsString(Args);
643  }
644
645  // Set the tool chain target information.
646  unsigned Major, Minor, Micro;
647  bool HadExtra;
648  if (OSXVersion) {
649    assert((!iOSVersion && !iOSSimVersion) && "Unknown target platform!");
650    if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor,
651                                   Micro, HadExtra) || HadExtra ||
652        Major != 10 || Minor >= 100 || Micro >= 100)
653      getDriver().Diag(diag::err_drv_invalid_version_number)
654        << OSXVersion->getAsString(Args);
655  } else {
656    const Arg *Version = iOSVersion ? iOSVersion : iOSSimVersion;
657    assert(Version && "Unknown target platform!");
658    if (!Driver::GetReleaseVersion(Version->getValue(Args), Major, Minor,
659                                   Micro, HadExtra) || HadExtra ||
660        Major >= 10 || Minor >= 100 || Micro >= 100)
661      getDriver().Diag(diag::err_drv_invalid_version_number)
662        << Version->getAsString(Args);
663  }
664
665  bool IsIOSSim = bool(iOSSimVersion);
666
667  // In GCC, the simulator historically was treated as being OS X in some
668  // contexts, like determining the link logic, despite generally being called
669  // with an iOS deployment target. For compatibility, we detect the
670  // simulator as iOS + x86, and treat it differently in a few contexts.
671  if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
672                     getTriple().getArch() == llvm::Triple::x86_64))
673    IsIOSSim = true;
674
675  setTarget(/*IsIPhoneOS=*/ !OSXVersion, Major, Minor, Micro, IsIOSSim);
676}
677
678void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
679                                      ArgStringList &CmdArgs) const {
680  CXXStdlibType Type = GetCXXStdlibType(Args);
681
682  switch (Type) {
683  case ToolChain::CST_Libcxx:
684    CmdArgs.push_back("-lc++");
685    break;
686
687  case ToolChain::CST_Libstdcxx: {
688    // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
689    // it was previously found in the gcc lib dir. However, for all the Darwin
690    // platforms we care about it was -lstdc++.6, so we search for that
691    // explicitly if we can't see an obvious -lstdc++ candidate.
692
693    // Check in the sysroot first.
694    bool Exists;
695    if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
696      llvm::sys::Path P(A->getValue(Args));
697      P.appendComponent("usr");
698      P.appendComponent("lib");
699      P.appendComponent("libstdc++.dylib");
700
701      if (llvm::sys::fs::exists(P.str(), Exists) || !Exists) {
702        P.eraseComponent();
703        P.appendComponent("libstdc++.6.dylib");
704        if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
705          CmdArgs.push_back(Args.MakeArgString(P.str()));
706          return;
707        }
708      }
709    }
710
711    // Otherwise, look in the root.
712    if ((llvm::sys::fs::exists("/usr/lib/libstdc++.dylib", Exists) || !Exists)&&
713      (!llvm::sys::fs::exists("/usr/lib/libstdc++.6.dylib", Exists) && Exists)){
714      CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
715      return;
716    }
717
718    // Otherwise, let the linker search.
719    CmdArgs.push_back("-lstdc++");
720    break;
721  }
722  }
723}
724
725void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
726                                   ArgStringList &CmdArgs) const {
727
728  // For Darwin platforms, use the compiler-rt-based support library
729  // instead of the gcc-provided one (which is also incidentally
730  // only present in the gcc lib dir, which makes it hard to find).
731
732  llvm::sys::Path P(getDriver().ResourceDir);
733  P.appendComponent("lib");
734  P.appendComponent("darwin");
735  P.appendComponent("libclang_rt.cc_kext.a");
736
737  // For now, allow missing resource libraries to support developers who may
738  // not have compiler-rt checked out or integrated into their build.
739  bool Exists;
740  if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
741    CmdArgs.push_back(Args.MakeArgString(P.str()));
742}
743
744DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
745                                      const char *BoundArch) const {
746  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
747  const OptTable &Opts = getDriver().getOpts();
748
749  // FIXME: We really want to get out of the tool chain level argument
750  // translation business, as it makes the driver functionality much
751  // more opaque. For now, we follow gcc closely solely for the
752  // purpose of easily achieving feature parity & testability. Once we
753  // have something that works, we should reevaluate each translation
754  // and try to push it down into tool specific logic.
755
756  for (ArgList::const_iterator it = Args.begin(),
757         ie = Args.end(); it != ie; ++it) {
758    Arg *A = *it;
759
760    if (A->getOption().matches(options::OPT_Xarch__)) {
761      // Skip this argument unless the architecture matches either the toolchain
762      // triple arch, or the arch being bound.
763      //
764      // FIXME: Canonicalize name.
765      StringRef XarchArch = A->getValue(Args, 0);
766      if (!(XarchArch == getArchName()  ||
767            (BoundArch && XarchArch == BoundArch)))
768        continue;
769
770      Arg *OriginalArg = A;
771      unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1));
772      unsigned Prev = Index;
773      Arg *XarchArg = Opts.ParseOneArg(Args, Index);
774
775      // If the argument parsing failed or more than one argument was
776      // consumed, the -Xarch_ argument's parameter tried to consume
777      // extra arguments. Emit an error and ignore.
778      //
779      // We also want to disallow any options which would alter the
780      // driver behavior; that isn't going to work in our model. We
781      // use isDriverOption() as an approximation, although things
782      // like -O4 are going to slip through.
783      if (!XarchArg || Index > Prev + 1) {
784        getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
785          << A->getAsString(Args);
786        continue;
787      } else if (XarchArg->getOption().isDriverOption()) {
788        getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
789          << A->getAsString(Args);
790        continue;
791      }
792
793      XarchArg->setBaseArg(A);
794      A = XarchArg;
795
796      DAL->AddSynthesizedArg(A);
797
798      // Linker input arguments require custom handling. The problem is that we
799      // have already constructed the phase actions, so we can not treat them as
800      // "input arguments".
801      if (A->getOption().isLinkerInput()) {
802        // Convert the argument into individual Zlinker_input_args.
803        for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
804          DAL->AddSeparateArg(OriginalArg,
805                              Opts.getOption(options::OPT_Zlinker_input),
806                              A->getValue(Args, i));
807
808        }
809        continue;
810      }
811    }
812
813    // Sob. These is strictly gcc compatible for the time being. Apple
814    // gcc translates options twice, which means that self-expanding
815    // options add duplicates.
816    switch ((options::ID) A->getOption().getID()) {
817    default:
818      DAL->append(A);
819      break;
820
821    case options::OPT_mkernel:
822    case options::OPT_fapple_kext:
823      DAL->append(A);
824      DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
825      break;
826
827    case options::OPT_dependency_file:
828      DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF),
829                          A->getValue(Args));
830      break;
831
832    case options::OPT_gfull:
833      DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
834      DAL->AddFlagArg(A,
835               Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
836      break;
837
838    case options::OPT_gused:
839      DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
840      DAL->AddFlagArg(A,
841             Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
842      break;
843
844    case options::OPT_shared:
845      DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
846      break;
847
848    case options::OPT_fconstant_cfstrings:
849      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
850      break;
851
852    case options::OPT_fno_constant_cfstrings:
853      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
854      break;
855
856    case options::OPT_Wnonportable_cfstrings:
857      DAL->AddFlagArg(A,
858                      Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
859      break;
860
861    case options::OPT_Wno_nonportable_cfstrings:
862      DAL->AddFlagArg(A,
863                   Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
864      break;
865
866    case options::OPT_fpascal_strings:
867      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
868      break;
869
870    case options::OPT_fno_pascal_strings:
871      DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
872      break;
873    }
874  }
875
876  if (getTriple().getArch() == llvm::Triple::x86 ||
877      getTriple().getArch() == llvm::Triple::x86_64)
878    if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
879      DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2");
880
881  // Add the arch options based on the particular spelling of -arch, to match
882  // how the driver driver works.
883  if (BoundArch) {
884    StringRef Name = BoundArch;
885    const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ);
886    const Option *MArch = Opts.getOption(options::OPT_march_EQ);
887
888    // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
889    // which defines the list of which architectures we accept.
890    if (Name == "ppc")
891      ;
892    else if (Name == "ppc601")
893      DAL->AddJoinedArg(0, MCpu, "601");
894    else if (Name == "ppc603")
895      DAL->AddJoinedArg(0, MCpu, "603");
896    else if (Name == "ppc604")
897      DAL->AddJoinedArg(0, MCpu, "604");
898    else if (Name == "ppc604e")
899      DAL->AddJoinedArg(0, MCpu, "604e");
900    else if (Name == "ppc750")
901      DAL->AddJoinedArg(0, MCpu, "750");
902    else if (Name == "ppc7400")
903      DAL->AddJoinedArg(0, MCpu, "7400");
904    else if (Name == "ppc7450")
905      DAL->AddJoinedArg(0, MCpu, "7450");
906    else if (Name == "ppc970")
907      DAL->AddJoinedArg(0, MCpu, "970");
908
909    else if (Name == "ppc64")
910      DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
911
912    else if (Name == "i386")
913      ;
914    else if (Name == "i486")
915      DAL->AddJoinedArg(0, MArch, "i486");
916    else if (Name == "i586")
917      DAL->AddJoinedArg(0, MArch, "i586");
918    else if (Name == "i686")
919      DAL->AddJoinedArg(0, MArch, "i686");
920    else if (Name == "pentium")
921      DAL->AddJoinedArg(0, MArch, "pentium");
922    else if (Name == "pentium2")
923      DAL->AddJoinedArg(0, MArch, "pentium2");
924    else if (Name == "pentpro")
925      DAL->AddJoinedArg(0, MArch, "pentiumpro");
926    else if (Name == "pentIIm3")
927      DAL->AddJoinedArg(0, MArch, "pentium2");
928
929    else if (Name == "x86_64")
930      DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
931
932    else if (Name == "arm")
933      DAL->AddJoinedArg(0, MArch, "armv4t");
934    else if (Name == "armv4t")
935      DAL->AddJoinedArg(0, MArch, "armv4t");
936    else if (Name == "armv5")
937      DAL->AddJoinedArg(0, MArch, "armv5tej");
938    else if (Name == "xscale")
939      DAL->AddJoinedArg(0, MArch, "xscale");
940    else if (Name == "armv6")
941      DAL->AddJoinedArg(0, MArch, "armv6k");
942    else if (Name == "armv7")
943      DAL->AddJoinedArg(0, MArch, "armv7a");
944
945    else
946      llvm_unreachable("invalid Darwin arch");
947  }
948
949  // Add an explicit version min argument for the deployment target. We do this
950  // after argument translation because -Xarch_ arguments may add a version min
951  // argument.
952  AddDeploymentTarget(*DAL);
953
954  // Validate the C++ standard library choice.
955  CXXStdlibType Type = GetCXXStdlibType(*DAL);
956  if (Type == ToolChain::CST_Libcxx) {
957    switch (LibCXXForSimulator) {
958    case LibCXXSimulator_None:
959      // Handle non-simulator cases.
960      if (isTargetIPhoneOS()) {
961        if (isIPhoneOSVersionLT(5, 0)) {
962          getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment)
963            << "iOS 5.0";
964        }
965      }
966      break;
967    case LibCXXSimulator_NotAvailable:
968      getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment)
969        << "iOS 5.0";
970      break;
971    case LibCXXSimulator_Available:
972      break;
973    }
974  }
975
976  return DAL;
977}
978
979bool Darwin::IsUnwindTablesDefault() const {
980  // FIXME: Gross; we should probably have some separate target
981  // definition, possibly even reusing the one in clang.
982  return getArchName() == "x86_64";
983}
984
985bool Darwin::UseDwarfDebugFlags() const {
986  if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
987    return S[0] != '\0';
988  return false;
989}
990
991bool Darwin::UseSjLjExceptions() const {
992  // Darwin uses SjLj exceptions on ARM.
993  return (getTriple().getArch() == llvm::Triple::arm ||
994          getTriple().getArch() == llvm::Triple::thumb);
995}
996
997const char *Darwin::GetDefaultRelocationModel() const {
998  return "pic";
999}
1000
1001const char *Darwin::GetForcedPicModel() const {
1002  if (getArchName() == "x86_64")
1003    return "pic";
1004  return 0;
1005}
1006
1007bool Darwin::SupportsProfiling() const {
1008  // Profiling instrumentation is only supported on x86.
1009  return getArchName() == "i386" || getArchName() == "x86_64";
1010}
1011
1012bool Darwin::SupportsObjCGC() const {
1013  // Garbage collection is supported everywhere except on iPhone OS.
1014  return !isTargetIPhoneOS();
1015}
1016
1017std::string
1018Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args,
1019                                                types::ID InputType) const {
1020  return ComputeLLVMTriple(Args, InputType);
1021}
1022
1023/// Generic_GCC - A tool chain using the 'gcc' command to perform
1024/// all subcommands; this relies on gcc translating the majority of
1025/// command line options.
1026
1027Generic_GCC::Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple)
1028  : ToolChain(Host, Triple) {
1029  getProgramPaths().push_back(getDriver().getInstalledDir());
1030  if (getDriver().getInstalledDir() != getDriver().Dir)
1031    getProgramPaths().push_back(getDriver().Dir);
1032}
1033
1034Generic_GCC::~Generic_GCC() {
1035  // Free tool implementations.
1036  for (llvm::DenseMap<unsigned, Tool*>::iterator
1037         it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
1038    delete it->second;
1039}
1040
1041Tool &Generic_GCC::SelectTool(const Compilation &C,
1042                              const JobAction &JA,
1043                              const ActionList &Inputs) const {
1044  Action::ActionClass Key;
1045  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1046    Key = Action::AnalyzeJobClass;
1047  else
1048    Key = JA.getKind();
1049
1050  Tool *&T = Tools[Key];
1051  if (!T) {
1052    switch (Key) {
1053    case Action::InputClass:
1054    case Action::BindArchClass:
1055      llvm_unreachable("Invalid tool kind.");
1056    case Action::PreprocessJobClass:
1057      T = new tools::gcc::Preprocess(*this); break;
1058    case Action::PrecompileJobClass:
1059      T = new tools::gcc::Precompile(*this); break;
1060    case Action::AnalyzeJobClass:
1061      T = new tools::Clang(*this); break;
1062    case Action::CompileJobClass:
1063      T = new tools::gcc::Compile(*this); break;
1064    case Action::AssembleJobClass:
1065      T = new tools::gcc::Assemble(*this); break;
1066    case Action::LinkJobClass:
1067      T = new tools::gcc::Link(*this); break;
1068
1069      // This is a bit ungeneric, but the only platform using a driver
1070      // driver is Darwin.
1071    case Action::LipoJobClass:
1072      T = new tools::darwin::Lipo(*this); break;
1073    case Action::DsymutilJobClass:
1074      T = new tools::darwin::Dsymutil(*this); break;
1075    case Action::VerifyJobClass:
1076      T = new tools::darwin::VerifyDebug(*this); break;
1077    }
1078  }
1079
1080  return *T;
1081}
1082
1083bool Generic_GCC::IsUnwindTablesDefault() const {
1084  // FIXME: Gross; we should probably have some separate target
1085  // definition, possibly even reusing the one in clang.
1086  return getArchName() == "x86_64";
1087}
1088
1089const char *Generic_GCC::GetDefaultRelocationModel() const {
1090  return "static";
1091}
1092
1093const char *Generic_GCC::GetForcedPicModel() const {
1094  return 0;
1095}
1096
1097/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1098/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1099/// Currently does not support anything else but compilation.
1100
1101TCEToolChain::TCEToolChain(const HostInfo &Host, const llvm::Triple& Triple)
1102  : ToolChain(Host, Triple) {
1103  // Path mangling to find libexec
1104  std::string Path(getDriver().Dir);
1105
1106  Path += "/../libexec";
1107  getProgramPaths().push_back(Path);
1108}
1109
1110TCEToolChain::~TCEToolChain() {
1111  for (llvm::DenseMap<unsigned, Tool*>::iterator
1112           it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
1113      delete it->second;
1114}
1115
1116bool TCEToolChain::IsMathErrnoDefault() const {
1117  return true;
1118}
1119
1120bool TCEToolChain::IsUnwindTablesDefault() const {
1121  return false;
1122}
1123
1124const char *TCEToolChain::GetDefaultRelocationModel() const {
1125  return "static";
1126}
1127
1128const char *TCEToolChain::GetForcedPicModel() const {
1129  return 0;
1130}
1131
1132Tool &TCEToolChain::SelectTool(const Compilation &C,
1133                            const JobAction &JA,
1134                               const ActionList &Inputs) const {
1135  Action::ActionClass Key;
1136  Key = Action::AnalyzeJobClass;
1137
1138  Tool *&T = Tools[Key];
1139  if (!T) {
1140    switch (Key) {
1141    case Action::PreprocessJobClass:
1142      T = new tools::gcc::Preprocess(*this); break;
1143    case Action::AnalyzeJobClass:
1144      T = new tools::Clang(*this); break;
1145    default:
1146     llvm_unreachable("Unsupported action for TCE target.");
1147    }
1148  }
1149  return *T;
1150}
1151
1152/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1153
1154OpenBSD::OpenBSD(const HostInfo &Host, const llvm::Triple& Triple)
1155  : Generic_ELF(Host, Triple) {
1156  getFilePaths().push_back(getDriver().Dir + "/../lib");
1157  getFilePaths().push_back("/usr/lib");
1158}
1159
1160Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA,
1161                          const ActionList &Inputs) const {
1162  Action::ActionClass Key;
1163  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1164    Key = Action::AnalyzeJobClass;
1165  else
1166    Key = JA.getKind();
1167
1168  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1169                                             options::OPT_no_integrated_as,
1170                                             IsIntegratedAssemblerDefault());
1171
1172  Tool *&T = Tools[Key];
1173  if (!T) {
1174    switch (Key) {
1175    case Action::AssembleJobClass: {
1176      if (UseIntegratedAs)
1177        T = new tools::ClangAs(*this);
1178      else
1179        T = new tools::openbsd::Assemble(*this);
1180      break;
1181    }
1182    case Action::LinkJobClass:
1183      T = new tools::openbsd::Link(*this); break;
1184    default:
1185      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1186    }
1187  }
1188
1189  return *T;
1190}
1191
1192/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1193
1194FreeBSD::FreeBSD(const HostInfo &Host, const llvm::Triple& Triple)
1195  : Generic_ELF(Host, Triple) {
1196
1197  // Determine if we are compiling 32-bit code on an x86_64 platform.
1198  bool Lib32 = false;
1199  if (Triple.getArch() == llvm::Triple::x86 &&
1200      llvm::Triple(getDriver().DefaultHostTriple).getArch() ==
1201        llvm::Triple::x86_64)
1202    Lib32 = true;
1203
1204  if (Triple.getArch() == llvm::Triple::ppc &&
1205      llvm::Triple(getDriver().DefaultHostTriple).getArch() ==
1206        llvm::Triple::ppc64)
1207    Lib32 = true;
1208
1209  if (Lib32) {
1210    getFilePaths().push_back("/usr/lib32");
1211  } else {
1212    getFilePaths().push_back("/usr/lib");
1213  }
1214}
1215
1216Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA,
1217                          const ActionList &Inputs) const {
1218  Action::ActionClass Key;
1219  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1220    Key = Action::AnalyzeJobClass;
1221  else
1222    Key = JA.getKind();
1223
1224  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1225                                             options::OPT_no_integrated_as,
1226                                             IsIntegratedAssemblerDefault());
1227
1228  Tool *&T = Tools[Key];
1229  if (!T) {
1230    switch (Key) {
1231    case Action::AssembleJobClass:
1232      if (UseIntegratedAs)
1233        T = new tools::ClangAs(*this);
1234      else
1235        T = new tools::freebsd::Assemble(*this);
1236      break;
1237    case Action::LinkJobClass:
1238      T = new tools::freebsd::Link(*this); break;
1239    default:
1240      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1241    }
1242  }
1243
1244  return *T;
1245}
1246
1247/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
1248
1249NetBSD::NetBSD(const HostInfo &Host, const llvm::Triple& Triple,
1250               const llvm::Triple& ToolTriple)
1251  : Generic_ELF(Host, Triple), ToolTriple(ToolTriple) {
1252
1253  // Determine if we are compiling 32-bit code on an x86_64 platform.
1254  bool Lib32 = false;
1255  if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
1256      Triple.getArch() == llvm::Triple::x86)
1257    Lib32 = true;
1258
1259  if (getDriver().UseStdLib) {
1260    if (Lib32)
1261      getFilePaths().push_back("=/usr/lib/i386");
1262    else
1263      getFilePaths().push_back("=/usr/lib");
1264  }
1265}
1266
1267Tool &NetBSD::SelectTool(const Compilation &C, const JobAction &JA,
1268                         const ActionList &Inputs) const {
1269  Action::ActionClass Key;
1270  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1271    Key = Action::AnalyzeJobClass;
1272  else
1273    Key = JA.getKind();
1274
1275  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1276                                             options::OPT_no_integrated_as,
1277                                             IsIntegratedAssemblerDefault());
1278
1279  Tool *&T = Tools[Key];
1280  if (!T) {
1281    switch (Key) {
1282    case Action::AssembleJobClass:
1283      if (UseIntegratedAs)
1284        T = new tools::ClangAs(*this);
1285      else
1286        T = new tools::netbsd::Assemble(*this, ToolTriple);
1287      break;
1288    case Action::LinkJobClass:
1289      T = new tools::netbsd::Link(*this, ToolTriple);
1290      break;
1291    default:
1292      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1293    }
1294  }
1295
1296  return *T;
1297}
1298
1299/// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1300
1301Minix::Minix(const HostInfo &Host, const llvm::Triple& Triple)
1302  : Generic_GCC(Host, Triple) {
1303  getFilePaths().push_back(getDriver().Dir + "/../lib");
1304  getFilePaths().push_back("/usr/lib");
1305  getFilePaths().push_back("/usr/gnu/lib");
1306  getFilePaths().push_back("/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
1307}
1308
1309Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA,
1310                        const ActionList &Inputs) const {
1311  Action::ActionClass Key;
1312  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1313    Key = Action::AnalyzeJobClass;
1314  else
1315    Key = JA.getKind();
1316
1317  Tool *&T = Tools[Key];
1318  if (!T) {
1319    switch (Key) {
1320    case Action::AssembleJobClass:
1321      T = new tools::minix::Assemble(*this); break;
1322    case Action::LinkJobClass:
1323      T = new tools::minix::Link(*this); break;
1324    default:
1325      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1326    }
1327  }
1328
1329  return *T;
1330}
1331
1332/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1333
1334AuroraUX::AuroraUX(const HostInfo &Host, const llvm::Triple& Triple)
1335  : Generic_GCC(Host, Triple) {
1336
1337  getProgramPaths().push_back(getDriver().getInstalledDir());
1338  if (getDriver().getInstalledDir() != getDriver().Dir)
1339    getProgramPaths().push_back(getDriver().Dir);
1340
1341  getFilePaths().push_back(getDriver().Dir + "/../lib");
1342  getFilePaths().push_back("/usr/lib");
1343  getFilePaths().push_back("/usr/sfw/lib");
1344  getFilePaths().push_back("/opt/gcc4/lib");
1345  getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
1346
1347}
1348
1349Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA,
1350                           const ActionList &Inputs) const {
1351  Action::ActionClass Key;
1352  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1353    Key = Action::AnalyzeJobClass;
1354  else
1355    Key = JA.getKind();
1356
1357  Tool *&T = Tools[Key];
1358  if (!T) {
1359    switch (Key) {
1360    case Action::AssembleJobClass:
1361      T = new tools::auroraux::Assemble(*this); break;
1362    case Action::LinkJobClass:
1363      T = new tools::auroraux::Link(*this); break;
1364    default:
1365      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1366    }
1367  }
1368
1369  return *T;
1370}
1371
1372
1373/// Linux toolchain (very bare-bones at the moment).
1374
1375enum LinuxDistro {
1376  ArchLinux,
1377  DebianLenny,
1378  DebianSqueeze,
1379  DebianWheezy,
1380  Exherbo,
1381  RHEL4,
1382  RHEL5,
1383  RHEL6,
1384  Fedora13,
1385  Fedora14,
1386  Fedora15,
1387  FedoraRawhide,
1388  OpenSuse11_3,
1389  OpenSuse11_4,
1390  OpenSuse12_1,
1391  UbuntuHardy,
1392  UbuntuIntrepid,
1393  UbuntuJaunty,
1394  UbuntuKarmic,
1395  UbuntuLucid,
1396  UbuntuMaverick,
1397  UbuntuNatty,
1398  UbuntuOneiric,
1399  UnknownDistro
1400};
1401
1402static bool IsRedhat(enum LinuxDistro Distro) {
1403  return Distro == Fedora13 || Distro == Fedora14 ||
1404         Distro == Fedora15 || Distro == FedoraRawhide ||
1405         Distro == RHEL4 || Distro == RHEL5 || Distro == RHEL6;
1406}
1407
1408static bool IsOpenSuse(enum LinuxDistro Distro) {
1409  return Distro == OpenSuse11_3 || Distro == OpenSuse11_4 ||
1410         Distro == OpenSuse12_1;
1411}
1412
1413static bool IsDebian(enum LinuxDistro Distro) {
1414  return Distro == DebianLenny || Distro == DebianSqueeze ||
1415         Distro == DebianWheezy;
1416}
1417
1418static bool IsUbuntu(enum LinuxDistro Distro) {
1419  return Distro == UbuntuHardy  || Distro == UbuntuIntrepid ||
1420         Distro == UbuntuLucid  || Distro == UbuntuMaverick ||
1421         Distro == UbuntuJaunty || Distro == UbuntuKarmic ||
1422         Distro == UbuntuNatty  || Distro == UbuntuOneiric;
1423}
1424
1425// FIXME: This should be deleted. We should assume a multilib environment, and
1426// fallback gracefully if any parts of it are absent.
1427static bool HasMultilib(llvm::Triple::ArchType Arch, enum LinuxDistro Distro) {
1428  if (Arch == llvm::Triple::x86_64) {
1429    bool Exists;
1430    if (Distro == Exherbo &&
1431        (llvm::sys::fs::exists("/usr/lib32/libc.so", Exists) || !Exists))
1432      return false;
1433  }
1434
1435  return true;
1436}
1437
1438static LinuxDistro DetectLinuxDistro(llvm::Triple::ArchType Arch) {
1439  llvm::OwningPtr<llvm::MemoryBuffer> File;
1440  if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
1441    StringRef Data = File.get()->getBuffer();
1442    SmallVector<StringRef, 8> Lines;
1443    Data.split(Lines, "\n");
1444    for (unsigned int i = 0, s = Lines.size(); i < s; ++ i) {
1445      if (Lines[i] == "DISTRIB_CODENAME=hardy")
1446        return UbuntuHardy;
1447      else if (Lines[i] == "DISTRIB_CODENAME=intrepid")
1448        return UbuntuIntrepid;
1449      else if (Lines[i] == "DISTRIB_CODENAME=jaunty")
1450        return UbuntuJaunty;
1451      else if (Lines[i] == "DISTRIB_CODENAME=karmic")
1452        return UbuntuKarmic;
1453      else if (Lines[i] == "DISTRIB_CODENAME=lucid")
1454        return UbuntuLucid;
1455      else if (Lines[i] == "DISTRIB_CODENAME=maverick")
1456        return UbuntuMaverick;
1457      else if (Lines[i] == "DISTRIB_CODENAME=natty")
1458        return UbuntuNatty;
1459      else if (Lines[i] == "DISTRIB_CODENAME=oneiric")
1460        return UbuntuOneiric;
1461    }
1462    return UnknownDistro;
1463  }
1464
1465  if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
1466    StringRef Data = File.get()->getBuffer();
1467    if (Data.startswith("Fedora release 15"))
1468      return Fedora15;
1469    else if (Data.startswith("Fedora release 14"))
1470      return Fedora14;
1471    else if (Data.startswith("Fedora release 13"))
1472      return Fedora13;
1473    else if (Data.startswith("Fedora release") &&
1474             Data.find("Rawhide") != StringRef::npos)
1475      return FedoraRawhide;
1476    else if (Data.startswith("Red Hat Enterprise Linux") &&
1477             Data.find("release 6") != StringRef::npos)
1478      return RHEL6;
1479    else if ((Data.startswith("Red Hat Enterprise Linux") ||
1480	      Data.startswith("CentOS")) &&
1481             Data.find("release 5") != StringRef::npos)
1482      return RHEL5;
1483    else if ((Data.startswith("Red Hat Enterprise Linux") ||
1484	      Data.startswith("CentOS")) &&
1485             Data.find("release 4") != StringRef::npos)
1486      return RHEL4;
1487    return UnknownDistro;
1488  }
1489
1490  if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
1491    StringRef Data = File.get()->getBuffer();
1492    if (Data[0] == '5')
1493      return DebianLenny;
1494    else if (Data.startswith("squeeze/sid"))
1495      return DebianSqueeze;
1496    else if (Data.startswith("wheezy/sid"))
1497      return DebianWheezy;
1498    return UnknownDistro;
1499  }
1500
1501  if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File)) {
1502    StringRef Data = File.get()->getBuffer();
1503    if (Data.startswith("openSUSE 11.3"))
1504      return OpenSuse11_3;
1505    else if (Data.startswith("openSUSE 11.4"))
1506      return OpenSuse11_4;
1507    else if (Data.startswith("openSUSE 12.1"))
1508      return OpenSuse12_1;
1509    return UnknownDistro;
1510  }
1511
1512  bool Exists;
1513  if (!llvm::sys::fs::exists("/etc/exherbo-release", Exists) && Exists)
1514    return Exherbo;
1515
1516  if (!llvm::sys::fs::exists("/etc/arch-release", Exists) && Exists)
1517    return ArchLinux;
1518
1519  return UnknownDistro;
1520}
1521
1522/// \brief Struct to store and manipulate GCC versions.
1523///
1524/// We rely on assumptions about the form and structure of GCC version
1525/// numbers: they consist of at most three '.'-separated components, and each
1526/// component is a non-negative integer except for the last component. For the
1527/// last component we are very flexible in order to tolerate release candidates
1528/// or 'x' wildcards.
1529///
1530/// Note that the ordering established among GCCVersions is based on the
1531/// preferred version string to use. For example we prefer versions without
1532/// a hard-coded patch number to those with a hard coded patch number.
1533///
1534/// Currently this doesn't provide any logic for textual suffixes to patches in
1535/// the way that (for example) Debian's version format does. If that ever
1536/// becomes necessary, it can be added.
1537struct Linux::GCCVersion {
1538  /// \brief The unparsed text of the version.
1539  StringRef Text;
1540
1541  /// \brief The parsed major, minor, and patch numbers.
1542  int Major, Minor, Patch;
1543
1544  /// \brief Any textual suffix on the patch number.
1545  StringRef PatchSuffix;
1546
1547  static GCCVersion Parse(StringRef VersionText) {
1548    const GCCVersion BadVersion = { VersionText, -1, -1, -1, "" };
1549    std::pair<StringRef, StringRef> First = VersionText.split('.');
1550    std::pair<StringRef, StringRef> Second = First.second.split('.');
1551
1552    GCCVersion GoodVersion = { VersionText, -1, -1, -1, "" };
1553    if (First.first.getAsInteger(10, GoodVersion.Major) ||
1554        GoodVersion.Major < 0)
1555      return BadVersion;
1556    if (Second.first.getAsInteger(10, GoodVersion.Minor) ||
1557        GoodVersion.Minor < 0)
1558      return BadVersion;
1559
1560    // First look for a number prefix and parse that if present. Otherwise just
1561    // stash the entire patch string in the suffix, and leave the number
1562    // unspecified. This covers versions strings such as:
1563    //   4.4
1564    //   4.4.0
1565    //   4.4.x
1566    //   4.4.2-rc4
1567    //   4.4.x-patched
1568    // And retains any patch number it finds.
1569    StringRef PatchText = GoodVersion.PatchSuffix = Second.second;
1570    if (!PatchText.empty()) {
1571      if (unsigned EndNumber = PatchText.find_first_not_of("0123456789")) {
1572        // Try to parse the number and any suffix.
1573        if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1574            GoodVersion.Patch < 0)
1575          return BadVersion;
1576        GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
1577      }
1578    }
1579
1580    return GoodVersion;
1581  }
1582
1583  bool operator<(const GCCVersion &RHS) const {
1584    if (Major < RHS.Major) return true; if (Major > RHS.Major) return false;
1585    if (Minor < RHS.Minor) return true; if (Minor > RHS.Minor) return false;
1586
1587    // Note that we rank versions with *no* patch specified is better than ones
1588    // hard-coding a patch version. Thus if the RHS has no patch, it always
1589    // wins, and the LHS only wins if it has no patch and the RHS does have
1590    // a patch.
1591    if (RHS.Patch == -1) return true;   if (Patch == -1) return false;
1592    if (Patch < RHS.Patch) return true; if (Patch > RHS.Patch) return false;
1593
1594    // Finally, between completely tied version numbers, the version with the
1595    // suffix loses as we prefer full releases.
1596    if (RHS.PatchSuffix.empty()) return true;
1597    return false;
1598  }
1599  bool operator>(const GCCVersion &RHS) const { return RHS < *this; }
1600  bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); }
1601  bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); }
1602};
1603
1604/// \brief Construct a GCCInstallationDetector from the driver.
1605///
1606/// This performs all of the autodetection and sets up the various paths.
1607/// Once constructed, a GCCInstallation is esentially immutable.
1608Linux::GCCInstallationDetector::GCCInstallationDetector(const Driver &D)
1609  : IsValid(false),
1610    GccTriple(D.DefaultHostTriple) {
1611  // FIXME: Using CXX_INCLUDE_ROOT is here is a bit of a hack, but
1612  // avoids adding yet another option to configure/cmake.
1613  // It would probably be cleaner to break it in two variables
1614  // CXX_GCC_ROOT with just /foo/bar
1615  // CXX_GCC_VER with 4.5.2
1616  // Then we would have
1617  // CXX_INCLUDE_ROOT = CXX_GCC_ROOT/include/c++/CXX_GCC_VER
1618  // and this function would return
1619  // CXX_GCC_ROOT/lib/gcc/CXX_INCLUDE_ARCH/CXX_GCC_VER
1620  llvm::SmallString<128> CxxIncludeRoot(CXX_INCLUDE_ROOT);
1621  if (CxxIncludeRoot != "") {
1622    // This is of the form /foo/bar/include/c++/4.5.2/
1623    if (CxxIncludeRoot.back() == '/')
1624      llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the /
1625    StringRef Version = llvm::sys::path::filename(CxxIncludeRoot);
1626    llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the version
1627    llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the c++
1628    llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the include
1629    GccInstallPath = CxxIncludeRoot.str();
1630    GccInstallPath.append("/lib/gcc/");
1631    GccInstallPath.append(CXX_INCLUDE_ARCH);
1632    GccInstallPath.append("/");
1633    GccInstallPath.append(Version);
1634    GccParentLibPath = GccInstallPath + "/../../..";
1635    IsValid = true;
1636    return;
1637  }
1638
1639  llvm::Triple::ArchType HostArch = llvm::Triple(GccTriple).getArch();
1640  // The library directories which may contain GCC installations.
1641  SmallVector<StringRef, 4> CandidateLibDirs;
1642  // The compatible GCC triples for this particular architecture.
1643  SmallVector<StringRef, 10> CandidateTriples;
1644  CollectLibDirsAndTriples(HostArch, CandidateLibDirs, CandidateTriples);
1645
1646  // Always include the default host triple as the final fallback if no
1647  // specific triple is detected.
1648  CandidateTriples.push_back(D.DefaultHostTriple);
1649
1650  // Compute the set of prefixes for our search.
1651  SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1652                                       D.PrefixDirs.end());
1653  Prefixes.push_back(D.SysRoot);
1654  Prefixes.push_back(D.SysRoot + "/usr");
1655  Prefixes.push_back(D.InstalledDir + "/..");
1656
1657  // Loop over the various components which exist and select the best GCC
1658  // installation available. GCC installs are ranked by version number.
1659  GCCVersion BestVersion = GCCVersion::Parse("0.0.0");
1660  for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) {
1661    if (!llvm::sys::fs::exists(Prefixes[i]))
1662      continue;
1663    for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) {
1664      const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str();
1665      if (!llvm::sys::fs::exists(LibDir))
1666        continue;
1667      for (unsigned k = 0, ke = CandidateTriples.size(); k < ke; ++k)
1668        ScanLibDirForGCCTriple(LibDir, CandidateTriples[k], BestVersion);
1669    }
1670  }
1671}
1672
1673/*static*/ void Linux::GCCInstallationDetector::CollectLibDirsAndTriples(
1674    llvm::Triple::ArchType HostArch, SmallVectorImpl<StringRef> &LibDirs,
1675    SmallVectorImpl<StringRef> &Triples) {
1676  if (HostArch == llvm::Triple::arm || HostArch == llvm::Triple::thumb) {
1677    static const char *const ARMLibDirs[] = { "/lib" };
1678    static const char *const ARMTriples[] = { "arm-linux-gnueabi" };
1679    LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs));
1680    Triples.append(ARMTriples, ARMTriples + llvm::array_lengthof(ARMTriples));
1681  } else if (HostArch == llvm::Triple::x86_64) {
1682    static const char *const X86_64LibDirs[] = { "/lib64", "/lib" };
1683    static const char *const X86_64Triples[] = {
1684      "x86_64-linux-gnu",
1685      "x86_64-unknown-linux-gnu",
1686      "x86_64-pc-linux-gnu",
1687      "x86_64-redhat-linux6E",
1688      "x86_64-redhat-linux",
1689      "x86_64-suse-linux",
1690      "x86_64-manbo-linux-gnu",
1691      "x86_64-linux-gnu",
1692      "x86_64-slackware-linux"
1693    };
1694    LibDirs.append(X86_64LibDirs,
1695                   X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1696    Triples.append(X86_64Triples,
1697                   X86_64Triples + llvm::array_lengthof(X86_64Triples));
1698  } else if (HostArch == llvm::Triple::x86) {
1699    static const char *const X86LibDirs[] = { "/lib32", "/lib" };
1700    static const char *const X86Triples[] = {
1701      "i686-linux-gnu",
1702      "i386-linux-gnu",
1703      "i686-pc-linux-gnu",
1704      "i486-linux-gnu",
1705      "i686-redhat-linux",
1706      "i386-redhat-linux",
1707      "i586-suse-linux",
1708      "i486-slackware-linux"
1709    };
1710    LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1711    Triples.append(X86Triples, X86Triples + llvm::array_lengthof(X86Triples));
1712  } else if (HostArch == llvm::Triple::ppc) {
1713    static const char *const PPCLibDirs[] = { "/lib32", "/lib" };
1714    static const char *const PPCTriples[] = {
1715      "powerpc-linux-gnu",
1716      "powerpc-unknown-linux-gnu"
1717    };
1718    LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1719    Triples.append(PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples));
1720  } else if (HostArch == llvm::Triple::ppc64) {
1721    static const char *const PPC64LibDirs[] = { "/lib64", "/lib" };
1722    static const char *const PPC64Triples[] = {
1723      "powerpc64-unknown-linux-gnu"
1724    };
1725    LibDirs.append(PPC64LibDirs,
1726                   PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1727    Triples.append(PPC64Triples,
1728                   PPC64Triples + llvm::array_lengthof(PPC64Triples));
1729  }
1730}
1731
1732void Linux::GCCInstallationDetector::ScanLibDirForGCCTriple(
1733    const std::string &LibDir, StringRef CandidateTriple,
1734    GCCVersion &BestVersion) {
1735  // There are various different suffixes involving the triple we
1736  // check for. We also record what is necessary to walk from each back
1737  // up to the lib directory.
1738  const std::string Suffixes[] = {
1739    "/gcc/" + CandidateTriple.str(),
1740    "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
1741
1742    // Ubuntu has a strange mis-matched pair of triples that this happens to
1743    // match.
1744    // FIXME: It may be worthwhile to generalize this and look for a second
1745    // triple.
1746    "/" + CandidateTriple.str() + "/gcc/i686-linux-gnu"
1747  };
1748  const std::string InstallSuffixes[] = {
1749    "/../../..",
1750    "/../../../..",
1751    "/../../../.."
1752  };
1753  // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
1754  const unsigned NumSuffixes = (llvm::array_lengthof(Suffixes) -
1755                                (CandidateTriple != "i386-linux-gnu"));
1756  for (unsigned i = 0; i < NumSuffixes; ++i) {
1757    StringRef Suffix = Suffixes[i];
1758    llvm::error_code EC;
1759    for (llvm::sys::fs::directory_iterator LI(LibDir + Suffix, EC), LE;
1760         !EC && LI != LE; LI = LI.increment(EC)) {
1761      StringRef VersionText = llvm::sys::path::filename(LI->path());
1762      GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1763      static const GCCVersion MinVersion = { "4.1.1", 4, 1, 1, "" };
1764      if (CandidateVersion < MinVersion)
1765        continue;
1766      if (CandidateVersion <= BestVersion)
1767        continue;
1768      if (!llvm::sys::fs::exists(LI->path() + "/crtbegin.o"))
1769        continue;
1770
1771      BestVersion = CandidateVersion;
1772      GccTriple = CandidateTriple.str();
1773      // FIXME: We hack together the directory name here instead of
1774      // using LI to ensure stable path separators across Windows and
1775      // Linux.
1776      GccInstallPath = LibDir + Suffixes[i] + "/" + VersionText.str();
1777      GccParentLibPath = GccInstallPath + InstallSuffixes[i];
1778      IsValid = true;
1779    }
1780  }
1781}
1782
1783static void addPathIfExists(const std::string &Path,
1784                            ToolChain::path_list &Paths) {
1785  if (llvm::sys::fs::exists(Path)) Paths.push_back(Path);
1786}
1787
1788/// \brief Get our best guess at the multiarch triple for a target.
1789///
1790/// Debian-based systems are starting to use a multiarch setup where they use
1791/// a target-triple directory in the library and header search paths.
1792/// Unfortunately, this triple does not align with the vanilla target triple,
1793/// so we provide a rough mapping here.
1794static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
1795                                      StringRef SysRoot) {
1796  // For most architectures, just use whatever we have rather than trying to be
1797  // clever.
1798  switch (TargetTriple.getArch()) {
1799  default:
1800    return TargetTriple.str();
1801
1802    // We use the existence of '/lib/<triple>' as a directory to detect some
1803    // common linux triples that don't quite match the Clang triple for both
1804    // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
1805    // regardless of what the actual target triple is.
1806  case llvm::Triple::x86:
1807    if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
1808      return "i386-linux-gnu";
1809    return TargetTriple.str();
1810  case llvm::Triple::x86_64:
1811    if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
1812      return "x86_64-linux-gnu";
1813    return TargetTriple.str();
1814  }
1815}
1816
1817Linux::Linux(const HostInfo &Host, const llvm::Triple &Triple)
1818  : Generic_ELF(Host, Triple), GCCInstallation(getDriver()) {
1819  llvm::Triple::ArchType Arch =
1820    llvm::Triple(getDriver().DefaultHostTriple).getArch();
1821  const std::string &SysRoot = getDriver().SysRoot;
1822
1823  // OpenSuse stores the linker with the compiler, add that to the search
1824  // path.
1825  ToolChain::path_list &PPaths = getProgramPaths();
1826  PPaths.push_back(GCCInstallation.getParentLibPath() + "/../" +
1827                   GCCInstallation.getTriple() + "/bin");
1828
1829  Linker = GetProgramPath("ld");
1830
1831  LinuxDistro Distro = DetectLinuxDistro(Arch);
1832
1833  if (IsOpenSuse(Distro) || IsUbuntu(Distro)) {
1834    ExtraOpts.push_back("-z");
1835    ExtraOpts.push_back("relro");
1836  }
1837
1838  if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
1839    ExtraOpts.push_back("-X");
1840
1841  if (IsRedhat(Distro) || IsOpenSuse(Distro) || Distro == UbuntuMaverick ||
1842      Distro == UbuntuNatty || Distro == UbuntuOneiric)
1843    ExtraOpts.push_back("--hash-style=gnu");
1844
1845  if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid ||
1846      Distro == UbuntuJaunty || Distro == UbuntuKarmic)
1847    ExtraOpts.push_back("--hash-style=both");
1848
1849  if (IsRedhat(Distro))
1850    ExtraOpts.push_back("--no-add-needed");
1851
1852  if (Distro == DebianSqueeze || Distro == DebianWheezy ||
1853      IsOpenSuse(Distro) ||
1854      (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
1855      Distro == UbuntuLucid ||
1856      Distro == UbuntuMaverick || Distro == UbuntuKarmic ||
1857      Distro == UbuntuNatty || Distro == UbuntuOneiric)
1858    ExtraOpts.push_back("--build-id");
1859
1860  if (IsOpenSuse(Distro))
1861    ExtraOpts.push_back("--enable-new-dtags");
1862
1863  // The selection of paths to try here is designed to match the patterns which
1864  // the GCC driver itself uses, as this is part of the GCC-compatible driver.
1865  // This was determined by running GCC in a fake filesystem, creating all
1866  // possible permutations of these directories, and seeing which ones it added
1867  // to the link paths.
1868  path_list &Paths = getFilePaths();
1869  const bool Is32Bits = (getArch() == llvm::Triple::x86 ||
1870                         getArch() == llvm::Triple::ppc);
1871
1872  const std::string Suffix32 = Arch == llvm::Triple::x86_64 ? "/32" : "";
1873  const std::string Suffix64 = Arch == llvm::Triple::x86_64 ? "" : "/64";
1874  const std::string Suffix = Is32Bits ? Suffix32 : Suffix64;
1875  const std::string Multilib = Is32Bits ? "lib32" : "lib64";
1876  const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
1877
1878  // FIXME: Because we add paths only when they exist on the system, I think we
1879  // should remove the concept of 'HasMultilib'. It's more likely to break the
1880  // behavior than to preserve any useful invariant on the system.
1881  if (HasMultilib(Arch, Distro)) {
1882    // Add the multilib suffixed paths.
1883    if (GCCInstallation.isValid()) {
1884      const std::string &LibPath = GCCInstallation.getParentLibPath();
1885      const std::string &GccTriple = GCCInstallation.getTriple();
1886      // FIXME: This OpenSuse-specific path shouldn't be needed any more, but
1887      // I don't want to remove it without finding someone to test.
1888      if (IsOpenSuse(Distro) && Is32Bits)
1889        Paths.push_back(LibPath + "/../" + GccTriple + "/lib/../lib");
1890
1891      addPathIfExists(GCCInstallation.getInstallPath() + Suffix, Paths);
1892      addPathIfExists(LibPath + "/../" + GccTriple + "/lib/../" + Multilib,
1893                      Paths);
1894      addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
1895      addPathIfExists(LibPath + "/../" + Multilib, Paths);
1896    }
1897    addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
1898    addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
1899    addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
1900    addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
1901
1902    // Try walking via the GCC triple path in case of multiarch GCC
1903    // installations with strange symlinks.
1904    if (GCCInstallation.isValid())
1905      addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple() +
1906                      "/../../" + Multilib, Paths);
1907  }
1908
1909  // Add the non-multilib suffixed paths (if potentially different).
1910  if (GCCInstallation.isValid()) {
1911    const std::string &LibPath = GCCInstallation.getParentLibPath();
1912    const std::string &GccTriple = GCCInstallation.getTriple();
1913    if (!Suffix.empty() || !HasMultilib(Arch, Distro))
1914      addPathIfExists(GCCInstallation.getInstallPath(), Paths);
1915    addPathIfExists(LibPath + "/../" + GccTriple + "/lib", Paths);
1916    addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
1917    addPathIfExists(LibPath, Paths);
1918  }
1919  addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
1920  addPathIfExists(SysRoot + "/lib", Paths);
1921  addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
1922  addPathIfExists(SysRoot + "/usr/lib", Paths);
1923}
1924
1925bool Linux::HasNativeLLVMSupport() const {
1926  return true;
1927}
1928
1929Tool &Linux::SelectTool(const Compilation &C, const JobAction &JA,
1930                        const ActionList &Inputs) const {
1931  Action::ActionClass Key;
1932  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1933    Key = Action::AnalyzeJobClass;
1934  else
1935    Key = JA.getKind();
1936
1937  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1938                                             options::OPT_no_integrated_as,
1939                                             IsIntegratedAssemblerDefault());
1940
1941  Tool *&T = Tools[Key];
1942  if (!T) {
1943    switch (Key) {
1944    case Action::AssembleJobClass:
1945      if (UseIntegratedAs)
1946        T = new tools::ClangAs(*this);
1947      else
1948        T = new tools::linuxtools::Assemble(*this);
1949      break;
1950    case Action::LinkJobClass:
1951      T = new tools::linuxtools::Link(*this); break;
1952    default:
1953      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1954    }
1955  }
1956
1957  return *T;
1958}
1959
1960void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
1961                                      ArgStringList &CC1Args) const {
1962  const Driver &D = getDriver();
1963
1964  if (DriverArgs.hasArg(options::OPT_nostdinc))
1965    return;
1966
1967  if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
1968    addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include");
1969
1970  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
1971    // Ignore the sysroot, we *always* look for clang headers relative to
1972    // supplied path.
1973    llvm::sys::Path P(D.ResourceDir);
1974    P.appendComponent("include");
1975    CC1Args.push_back("-internal-nosysroot-isystem");
1976    CC1Args.push_back(DriverArgs.MakeArgString(P.str()));
1977  }
1978
1979  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
1980    return;
1981
1982  // Check for configure-time C include directories.
1983  StringRef CIncludeDirs(C_INCLUDE_DIRS);
1984  if (CIncludeDirs != "") {
1985    SmallVector<StringRef, 5> dirs;
1986    CIncludeDirs.split(dirs, ":");
1987    for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
1988         I != E; ++I) {
1989      StringRef Prefix = llvm::sys::path::is_absolute(*I) ? D.SysRoot : "";
1990      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
1991    }
1992    return;
1993  }
1994
1995  // Lacking those, try to detect the correct set of system includes for the
1996  // target triple.
1997
1998  // Generic Debian multiarch support:
1999  if (getTriple().getArch() == llvm::Triple::x86_64) {
2000    addExternCSystemInclude(DriverArgs, CC1Args,
2001                            "/usr/include/x86_64-linux-gnu");
2002    addExternCSystemInclude(DriverArgs, CC1Args,
2003                            "/usr/include/i686-linux-gnu/64");
2004    addExternCSystemInclude(DriverArgs, CC1Args,
2005                            "/usr/include/i486-linux-gnu/64");
2006  } else if (getTriple().getArch() == llvm::Triple::x86) {
2007    addExternCSystemInclude(DriverArgs, CC1Args,
2008                            "/usr/include/x86_64-linux-gnu/32");
2009    addExternCSystemInclude(DriverArgs, CC1Args, "/usr/include/i686-linux-gnu");
2010    addExternCSystemInclude(DriverArgs, CC1Args, "/usr/include/i486-linux-gnu");
2011    addExternCSystemInclude(DriverArgs, CC1Args, "/usr/include/i386-linux-gnu");
2012  } else if (getTriple().getArch() == llvm::Triple::arm) {
2013    addExternCSystemInclude(DriverArgs, CC1Args,
2014                            "/usr/include/arm-linux-gnueabi");
2015  }
2016
2017  if (getTriple().getOS() == llvm::Triple::RTEMS)
2018    return;
2019
2020  addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include");
2021}
2022
2023static void AddLibStdCXXIncludePaths(StringRef Base, StringRef ArchDir,
2024                                     StringRef Dir32, StringRef Dir64,
2025                                     const llvm::Triple &Triple,
2026                                     const ArgList &DriverArgs,
2027                                     ArgStringList &CC1Args) {
2028  addSystemInclude(DriverArgs, CC1Args, Base);
2029
2030  // Add the multilib dirs
2031  llvm::Triple::ArchType Arch = Triple.getArch();
2032  bool Is64bit = Arch == llvm::Triple::ppc64 || Arch == llvm::Triple::x86_64;
2033  if (Is64bit)
2034    addSystemInclude(DriverArgs, CC1Args, Base + "/" + ArchDir + "/" + Dir64);
2035  else
2036    addSystemInclude(DriverArgs, CC1Args, Base + "/" + ArchDir + "/" + Dir32);
2037
2038  // Add the backward dir
2039  addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
2040}
2041
2042void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2043                                         ArgStringList &CC1Args) const {
2044  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2045      DriverArgs.hasArg(options::OPT_nostdincxx))
2046    return;
2047
2048  const llvm::Triple &Triple = getTriple();
2049  StringRef CxxIncludeRoot(CXX_INCLUDE_ROOT);
2050  if (CxxIncludeRoot != "") {
2051    StringRef CxxIncludeArch(CXX_INCLUDE_ARCH);
2052    if (CxxIncludeArch == "")
2053      AddLibStdCXXIncludePaths(CxxIncludeRoot, Triple.str().c_str(),
2054                               CXX_INCLUDE_32BIT_DIR, CXX_INCLUDE_64BIT_DIR,
2055                               Triple, DriverArgs, CC1Args);
2056    else
2057      AddLibStdCXXIncludePaths(CxxIncludeRoot, CXX_INCLUDE_ARCH,
2058                               CXX_INCLUDE_32BIT_DIR, CXX_INCLUDE_64BIT_DIR,
2059                               Triple, DriverArgs, CC1Args);
2060    return;
2061  }
2062  // FIXME: temporary hack: hard-coded paths.
2063
2064  //===------------------------------------------------------------------===//
2065  // Debian based distros.
2066  // Note: these distros symlink /usr/include/c++/X.Y.Z -> X.Y
2067  //===------------------------------------------------------------------===//
2068
2069  // Ubuntu 11.11 "Oneiric Ocelot" -- gcc-4.6.0
2070  AddLibStdCXXIncludePaths(
2071    "/usr/include/c++/4.6",
2072    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2073  AddLibStdCXXIncludePaths(
2074    "/usr/include/c++/4.6",
2075    "i686-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2076  AddLibStdCXXIncludePaths(
2077    "/usr/include/c++/4.6",
2078    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2079  AddLibStdCXXIncludePaths(
2080    "/usr/include/c++/4.6",
2081    "arm-linux-gnueabi", "", "", Triple, DriverArgs, CC1Args);
2082
2083  // Ubuntu 11.04 "Natty Narwhal" -- gcc-4.5.2
2084  AddLibStdCXXIncludePaths(
2085    "/usr/include/c++/4.5",
2086    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2087  AddLibStdCXXIncludePaths(
2088    "/usr/include/c++/4.5",
2089    "i686-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2090  AddLibStdCXXIncludePaths(
2091    "/usr/include/c++/4.5",
2092    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2093  AddLibStdCXXIncludePaths(
2094    "/usr/include/c++/4.5",
2095    "arm-linux-gnueabi", "", "", Triple, DriverArgs, CC1Args);
2096
2097  // Ubuntu 10.10 "Maverick Meerkat" -- gcc-4.4.5
2098  AddLibStdCXXIncludePaths(
2099    "/usr/include/c++/4.4",
2100    "i686-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2101  // The rest of 10.10 is the same as previous versions.
2102
2103  // Ubuntu 10.04 LTS "Lucid Lynx" -- gcc-4.4.3
2104  // Ubuntu 9.10 "Karmic Koala"    -- gcc-4.4.1
2105  // Debian 6.0 "squeeze"          -- gcc-4.4.2
2106  AddLibStdCXXIncludePaths(
2107    "/usr/include/c++/4.4",
2108    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2109  AddLibStdCXXIncludePaths(
2110    "/usr/include/c++/4.4",
2111    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2112  AddLibStdCXXIncludePaths(
2113    "/usr/include/c++/4.4",
2114    "arm-linux-gnueabi", "", "", Triple, DriverArgs, CC1Args);
2115  // Ubuntu 9.04 "Jaunty Jackalope" -- gcc-4.3.3
2116  // Ubuntu 8.10 "Intrepid Ibex"    -- gcc-4.3.2
2117  // Debian 5.0 "lenny"             -- gcc-4.3.2
2118  AddLibStdCXXIncludePaths(
2119    "/usr/include/c++/4.3",
2120    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2121  AddLibStdCXXIncludePaths(
2122    "/usr/include/c++/4.3",
2123    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2124  AddLibStdCXXIncludePaths(
2125    "/usr/include/c++/4.3",
2126    "arm-linux-gnueabi", "", "", Triple, DriverArgs, CC1Args);
2127  // Ubuntu 8.04.4 LTS "Hardy Heron"     -- gcc-4.2.4
2128  // Ubuntu 8.04.[0-3] LTS "Hardy Heron" -- gcc-4.2.3
2129  AddLibStdCXXIncludePaths(
2130    "/usr/include/c++/4.2",
2131    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2132  AddLibStdCXXIncludePaths(
2133    "/usr/include/c++/4.2",
2134    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2135  // Ubuntu 7.10 "Gutsy Gibbon" -- gcc-4.1.3
2136  AddLibStdCXXIncludePaths(
2137    "/usr/include/c++/4.1",
2138    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2139  AddLibStdCXXIncludePaths(
2140    "/usr/include/c++/4.1",
2141    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2142
2143  //===------------------------------------------------------------------===//
2144  // Redhat based distros.
2145  //===------------------------------------------------------------------===//
2146  // Fedora 15 (GCC 4.6.1)
2147  AddLibStdCXXIncludePaths(
2148    "/usr/include/c++/4.6.1",
2149    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2150  AddLibStdCXXIncludePaths(
2151    "/usr/include/c++/4.6.1",
2152    "i686-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2153  // Fedora 15 (GCC 4.6.0)
2154  AddLibStdCXXIncludePaths(
2155    "/usr/include/c++/4.6.0",
2156    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2157  AddLibStdCXXIncludePaths(
2158    "/usr/include/c++/4.6.0",
2159    "i686-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2160  // Fedora 14
2161  AddLibStdCXXIncludePaths(
2162    "/usr/include/c++/4.5.1",
2163    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2164  AddLibStdCXXIncludePaths(
2165    "/usr/include/c++/4.5.1",
2166    "i686-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2167  // RHEL5(gcc44)
2168  AddLibStdCXXIncludePaths(
2169    "/usr/include/c++/4.4.4",
2170    "x86_64-redhat-linux6E", "32", "", Triple, DriverArgs, CC1Args);
2171  // Fedora 13
2172  AddLibStdCXXIncludePaths(
2173    "/usr/include/c++/4.4.4",
2174    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2175  AddLibStdCXXIncludePaths(
2176    "/usr/include/c++/4.4.4",
2177    "i686-redhat-linux","", "", Triple, DriverArgs, CC1Args);
2178  // Fedora 12
2179  AddLibStdCXXIncludePaths(
2180    "/usr/include/c++/4.4.3",
2181    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2182  AddLibStdCXXIncludePaths(
2183    "/usr/include/c++/4.4.3",
2184    "i686-redhat-linux","", "", Triple, DriverArgs, CC1Args);
2185  // Fedora 12 (pre-FEB-2010)
2186  AddLibStdCXXIncludePaths(
2187    "/usr/include/c++/4.4.2",
2188    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2189  AddLibStdCXXIncludePaths(
2190    "/usr/include/c++/4.4.2",
2191    "i686-redhat-linux","", "", Triple, DriverArgs, CC1Args);
2192  // Fedora 11
2193  AddLibStdCXXIncludePaths(
2194    "/usr/include/c++/4.4.1",
2195    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2196  AddLibStdCXXIncludePaths(
2197    "/usr/include/c++/4.4.1",
2198    "i586-redhat-linux","", "", Triple, DriverArgs, CC1Args);
2199  // Fedora 10
2200  AddLibStdCXXIncludePaths(
2201    "/usr/include/c++/4.3.2",
2202    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2203  AddLibStdCXXIncludePaths(
2204    "/usr/include/c++/4.3.2",
2205    "i386-redhat-linux","", "", Triple, DriverArgs, CC1Args);
2206  // Fedora 9
2207  AddLibStdCXXIncludePaths(
2208    "/usr/include/c++/4.3.0",
2209    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2210  AddLibStdCXXIncludePaths(
2211    "/usr/include/c++/4.3.0",
2212    "i386-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2213  // Fedora 8
2214  AddLibStdCXXIncludePaths(
2215    "/usr/include/c++/4.1.2",
2216    "x86_64-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2217  AddLibStdCXXIncludePaths(
2218    "/usr/include/c++/4.1.2",
2219    "i386-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2220
2221  // RHEL 5
2222  AddLibStdCXXIncludePaths(
2223    "/usr/include/c++/4.1.1",
2224    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2225  AddLibStdCXXIncludePaths(
2226    "/usr/include/c++/4.1.1",
2227    "i386-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2228
2229
2230  //===------------------------------------------------------------------===//
2231
2232  // Exherbo (2010-01-25)
2233  AddLibStdCXXIncludePaths(
2234    "/usr/include/c++/4.4.3",
2235    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2236  AddLibStdCXXIncludePaths(
2237    "/usr/include/c++/4.4.3",
2238    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2239
2240  // openSUSE 11.1 32 bit
2241  AddLibStdCXXIncludePaths(
2242    "/usr/include/c++/4.3",
2243    "i586-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2244  // openSUSE 11.1 64 bit
2245  AddLibStdCXXIncludePaths(
2246    "/usr/include/c++/4.3",
2247    "x86_64-suse-linux", "32", "", Triple, DriverArgs, CC1Args);
2248  // openSUSE 11.2
2249  AddLibStdCXXIncludePaths(
2250    "/usr/include/c++/4.4",
2251    "i586-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2252  AddLibStdCXXIncludePaths(
2253    "/usr/include/c++/4.4",
2254    "x86_64-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2255
2256  // openSUSE 11.4
2257  AddLibStdCXXIncludePaths(
2258    "/usr/include/c++/4.5",
2259    "i586-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2260  AddLibStdCXXIncludePaths(
2261    "/usr/include/c++/4.5",
2262    "x86_64-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2263
2264  // openSUSE 12.1
2265  AddLibStdCXXIncludePaths(
2266    "/usr/include/c++/4.6",
2267    "i586-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2268  AddLibStdCXXIncludePaths(
2269    "/usr/include/c++/4.6",
2270    "x86_64-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2271  // Arch Linux 2008-06-24
2272  AddLibStdCXXIncludePaths(
2273    "/usr/include/c++/4.3.1",
2274    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2275  AddLibStdCXXIncludePaths(
2276    "/usr/include/c++/4.3.1",
2277    "x86_64-unknown-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2278
2279  // Arch Linux gcc 4.6
2280  AddLibStdCXXIncludePaths(
2281    "/usr/include/c++/4.6.1",
2282    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2283  AddLibStdCXXIncludePaths(
2284    "/usr/include/c++/4.6.1",
2285    "x86_64-unknown-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2286  AddLibStdCXXIncludePaths(
2287    "/usr/include/c++/4.6.0",
2288    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2289  AddLibStdCXXIncludePaths(
2290    "/usr/include/c++/4.6.0",
2291    "x86_64-unknown-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2292
2293  // Slackware gcc 4.5.2 (13.37)
2294  AddLibStdCXXIncludePaths(
2295    "/usr/include/c++/4.5.2",
2296    "i486-slackware-linux", "", "", Triple, DriverArgs, CC1Args);
2297  AddLibStdCXXIncludePaths(
2298    "/usr/include/c++/4.5.2",
2299    "x86_64-slackware-linux", "", "", Triple, DriverArgs, CC1Args);
2300  // Slackware gcc 4.5.3 (-current)
2301  AddLibStdCXXIncludePaths(
2302    "/usr/include/c++/4.5.3",
2303    "i486-slackware-linux", "", "", Triple, DriverArgs, CC1Args);
2304  AddLibStdCXXIncludePaths(
2305    "/usr/include/c++/4.5.3",
2306    "x86_64-slackware-linux", "", "", Triple, DriverArgs, CC1Args);
2307
2308  // Gentoo x86 gcc 4.5.3
2309  AddLibStdCXXIncludePaths(
2310    "/usr/lib/gcc/i686-pc-linux-gnu/4.5.3/include/g++-v4",
2311    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2312  // Gentoo x86 gcc 4.5.2
2313  AddLibStdCXXIncludePaths(
2314    "/usr/lib/gcc/i686-pc-linux-gnu/4.5.2/include/g++-v4",
2315    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2316  // Gentoo x86 gcc 4.4.5
2317  AddLibStdCXXIncludePaths(
2318    "/usr/lib/gcc/i686-pc-linux-gnu/4.4.5/include/g++-v4",
2319    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2320  // Gentoo x86 gcc 4.4.4
2321  AddLibStdCXXIncludePaths(
2322    "/usr/lib/gcc/i686-pc-linux-gnu/4.4.4/include/g++-v4",
2323    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2324  // Gentoo x86 2010.0 stable
2325  AddLibStdCXXIncludePaths(
2326    "/usr/lib/gcc/i686-pc-linux-gnu/4.4.3/include/g++-v4",
2327    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2328  // Gentoo x86 2009.1 stable
2329  AddLibStdCXXIncludePaths(
2330    "/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4",
2331    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2332  // Gentoo x86 2009.0 stable
2333  AddLibStdCXXIncludePaths(
2334    "/usr/lib/gcc/i686-pc-linux-gnu/4.3.2/include/g++-v4",
2335    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2336  // Gentoo x86 2008.0 stable
2337  AddLibStdCXXIncludePaths(
2338    "/usr/lib/gcc/i686-pc-linux-gnu/4.1.2/include/g++-v4",
2339    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2340
2341  // Gentoo amd64 gcc 4.5.3
2342  AddLibStdCXXIncludePaths(
2343    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.3/include/g++-v4",
2344    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2345  // Gentoo amd64 gcc 4.5.2
2346  AddLibStdCXXIncludePaths(
2347    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.2/include/g++-v4",
2348    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2349  // Gentoo amd64 gcc 4.4.5
2350  AddLibStdCXXIncludePaths(
2351    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.5/include/g++-v4",
2352    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2353  // Gentoo amd64 gcc 4.4.4
2354  AddLibStdCXXIncludePaths(
2355    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.4/include/g++-v4",
2356    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2357  // Gentoo amd64 gcc 4.4.3
2358  AddLibStdCXXIncludePaths(
2359    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4",
2360    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2361  // Gentoo amd64 gcc 4.3.4
2362  AddLibStdCXXIncludePaths(
2363    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.3.4/include/g++-v4",
2364    "x86_64-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2365  // Gentoo amd64 gcc 4.3.2
2366  AddLibStdCXXIncludePaths(
2367    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.3.2/include/g++-v4",
2368    "x86_64-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2369  // Gentoo amd64 stable
2370  AddLibStdCXXIncludePaths(
2371    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.1.2/include/g++-v4",
2372    "x86_64-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2373}
2374
2375/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2376
2377DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple)
2378  : Generic_ELF(Host, Triple) {
2379
2380  // Path mangling to find libexec
2381  getProgramPaths().push_back(getDriver().getInstalledDir());
2382  if (getDriver().getInstalledDir() != getDriver().Dir)
2383    getProgramPaths().push_back(getDriver().Dir);
2384
2385  getFilePaths().push_back(getDriver().Dir + "/../lib");
2386  getFilePaths().push_back("/usr/lib");
2387  getFilePaths().push_back("/usr/lib/gcc41");
2388}
2389
2390Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA,
2391                            const ActionList &Inputs) const {
2392  Action::ActionClass Key;
2393  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
2394    Key = Action::AnalyzeJobClass;
2395  else
2396    Key = JA.getKind();
2397
2398  Tool *&T = Tools[Key];
2399  if (!T) {
2400    switch (Key) {
2401    case Action::AssembleJobClass:
2402      T = new tools::dragonfly::Assemble(*this); break;
2403    case Action::LinkJobClass:
2404      T = new tools::dragonfly::Link(*this); break;
2405    default:
2406      T = &Generic_GCC::SelectTool(C, JA, Inputs);
2407    }
2408  }
2409
2410  return *T;
2411}
2412
2413Windows::Windows(const HostInfo &Host, const llvm::Triple& Triple)
2414  : ToolChain(Host, Triple) {
2415}
2416
2417Tool &Windows::SelectTool(const Compilation &C, const JobAction &JA,
2418                          const ActionList &Inputs) const {
2419  Action::ActionClass Key;
2420  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
2421    Key = Action::AnalyzeJobClass;
2422  else
2423    Key = JA.getKind();
2424
2425  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
2426                                             options::OPT_no_integrated_as,
2427                                             IsIntegratedAssemblerDefault());
2428
2429  Tool *&T = Tools[Key];
2430  if (!T) {
2431    switch (Key) {
2432    case Action::InputClass:
2433    case Action::BindArchClass:
2434    case Action::LipoJobClass:
2435    case Action::DsymutilJobClass:
2436    case Action::VerifyJobClass:
2437      llvm_unreachable("Invalid tool kind.");
2438    case Action::PreprocessJobClass:
2439    case Action::PrecompileJobClass:
2440    case Action::AnalyzeJobClass:
2441    case Action::CompileJobClass:
2442      T = new tools::Clang(*this); break;
2443    case Action::AssembleJobClass:
2444      if (!UseIntegratedAs && getTriple().getEnvironment() == llvm::Triple::MachO)
2445        T = new tools::darwin::Assemble(*this);
2446      else
2447        T = new tools::ClangAs(*this);
2448      break;
2449    case Action::LinkJobClass:
2450      T = new tools::visualstudio::Link(*this); break;
2451    }
2452  }
2453
2454  return *T;
2455}
2456
2457bool Windows::IsIntegratedAssemblerDefault() const {
2458  return true;
2459}
2460
2461bool Windows::IsUnwindTablesDefault() const {
2462  // FIXME: Gross; we should probably have some separate target
2463  // definition, possibly even reusing the one in clang.
2464  return getArchName() == "x86_64";
2465}
2466
2467const char *Windows::GetDefaultRelocationModel() const {
2468  return "static";
2469}
2470
2471const char *Windows::GetForcedPicModel() const {
2472  if (getArchName() == "x86_64")
2473    return "pic";
2474  return 0;
2475}
2476
2477// FIXME: This probably should goto to some platform utils place.
2478#ifdef _MSC_VER
2479
2480/// \brief Read registry string.
2481/// This also supports a means to look for high-versioned keys by use
2482/// of a $VERSION placeholder in the key path.
2483/// $VERSION in the key path is a placeholder for the version number,
2484/// causing the highest value path to be searched for and used.
2485/// I.e. "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\$VERSION".
2486/// There can be additional characters in the component.  Only the numberic
2487/// characters are compared.
2488static bool getSystemRegistryString(const char *keyPath, const char *valueName,
2489                                    char *value, size_t maxLength) {
2490  HKEY hRootKey = NULL;
2491  HKEY hKey = NULL;
2492  const char* subKey = NULL;
2493  DWORD valueType;
2494  DWORD valueSize = maxLength - 1;
2495  long lResult;
2496  bool returnValue = false;
2497
2498  if (strncmp(keyPath, "HKEY_CLASSES_ROOT\\", 18) == 0) {
2499    hRootKey = HKEY_CLASSES_ROOT;
2500    subKey = keyPath + 18;
2501  } else if (strncmp(keyPath, "HKEY_USERS\\", 11) == 0) {
2502    hRootKey = HKEY_USERS;
2503    subKey = keyPath + 11;
2504  } else if (strncmp(keyPath, "HKEY_LOCAL_MACHINE\\", 19) == 0) {
2505    hRootKey = HKEY_LOCAL_MACHINE;
2506    subKey = keyPath + 19;
2507  } else if (strncmp(keyPath, "HKEY_CURRENT_USER\\", 18) == 0) {
2508    hRootKey = HKEY_CURRENT_USER;
2509    subKey = keyPath + 18;
2510  } else {
2511    return false;
2512  }
2513
2514  const char *placeHolder = strstr(subKey, "$VERSION");
2515  char bestName[256];
2516  bestName[0] = '\0';
2517  // If we have a $VERSION placeholder, do the highest-version search.
2518  if (placeHolder) {
2519    const char *keyEnd = placeHolder - 1;
2520    const char *nextKey = placeHolder;
2521    // Find end of previous key.
2522    while ((keyEnd > subKey) && (*keyEnd != '\\'))
2523      keyEnd--;
2524    // Find end of key containing $VERSION.
2525    while (*nextKey && (*nextKey != '\\'))
2526      nextKey++;
2527    size_t partialKeyLength = keyEnd - subKey;
2528    char partialKey[256];
2529    if (partialKeyLength > sizeof(partialKey))
2530      partialKeyLength = sizeof(partialKey);
2531    strncpy(partialKey, subKey, partialKeyLength);
2532    partialKey[partialKeyLength] = '\0';
2533    HKEY hTopKey = NULL;
2534    lResult = RegOpenKeyEx(hRootKey, partialKey, 0, KEY_READ, &hTopKey);
2535    if (lResult == ERROR_SUCCESS) {
2536      char keyName[256];
2537      int bestIndex = -1;
2538      double bestValue = 0.0;
2539      DWORD index, size = sizeof(keyName) - 1;
2540      for (index = 0; RegEnumKeyEx(hTopKey, index, keyName, &size, NULL,
2541          NULL, NULL, NULL) == ERROR_SUCCESS; index++) {
2542        const char *sp = keyName;
2543        while (*sp && !isdigit(*sp))
2544          sp++;
2545        if (!*sp)
2546          continue;
2547        const char *ep = sp + 1;
2548        while (*ep && (isdigit(*ep) || (*ep == '.')))
2549          ep++;
2550        char numBuf[32];
2551        strncpy(numBuf, sp, sizeof(numBuf) - 1);
2552        numBuf[sizeof(numBuf) - 1] = '\0';
2553        double value = strtod(numBuf, NULL);
2554        if (value > bestValue) {
2555          bestIndex = (int)index;
2556          bestValue = value;
2557          strcpy(bestName, keyName);
2558        }
2559        size = sizeof(keyName) - 1;
2560      }
2561      // If we found the highest versioned key, open the key and get the value.
2562      if (bestIndex != -1) {
2563        // Append rest of key.
2564        strncat(bestName, nextKey, sizeof(bestName) - 1);
2565        bestName[sizeof(bestName) - 1] = '\0';
2566        // Open the chosen key path remainder.
2567        lResult = RegOpenKeyEx(hTopKey, bestName, 0, KEY_READ, &hKey);
2568        if (lResult == ERROR_SUCCESS) {
2569          lResult = RegQueryValueEx(hKey, valueName, NULL, &valueType,
2570            (LPBYTE)value, &valueSize);
2571          if (lResult == ERROR_SUCCESS)
2572            returnValue = true;
2573          RegCloseKey(hKey);
2574        }
2575      }
2576      RegCloseKey(hTopKey);
2577    }
2578  } else {
2579    lResult = RegOpenKeyEx(hRootKey, subKey, 0, KEY_READ, &hKey);
2580    if (lResult == ERROR_SUCCESS) {
2581      lResult = RegQueryValueEx(hKey, valueName, NULL, &valueType,
2582        (LPBYTE)value, &valueSize);
2583      if (lResult == ERROR_SUCCESS)
2584        returnValue = true;
2585      RegCloseKey(hKey);
2586    }
2587  }
2588  return returnValue;
2589}
2590
2591/// \brief Get Windows SDK installation directory.
2592static bool getWindowsSDKDir(std::string &path) {
2593  char windowsSDKInstallDir[256];
2594  // Try the Windows registry.
2595  bool hasSDKDir = getSystemRegistryString(
2596   "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
2597                                           "InstallationFolder",
2598                                           windowsSDKInstallDir,
2599                                           sizeof(windowsSDKInstallDir) - 1);
2600    // If we have both vc80 and vc90, pick version we were compiled with.
2601  if (hasSDKDir && windowsSDKInstallDir[0]) {
2602    path = windowsSDKInstallDir;
2603    return true;
2604  }
2605  return false;
2606}
2607
2608  // Get Visual Studio installation directory.
2609static bool getVisualStudioDir(std::string &path) {
2610  // First check the environment variables that vsvars32.bat sets.
2611  const char* vcinstalldir = getenv("VCINSTALLDIR");
2612  if (vcinstalldir) {
2613    char *p = const_cast<char *>(strstr(vcinstalldir, "\\VC"));
2614    if (p)
2615      *p = '\0';
2616    path = vcinstalldir;
2617    return true;
2618  }
2619
2620  char vsIDEInstallDir[256];
2621  char vsExpressIDEInstallDir[256];
2622  // Then try the windows registry.
2623  bool hasVCDir = getSystemRegistryString(
2624    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\$VERSION",
2625    "InstallDir", vsIDEInstallDir, sizeof(vsIDEInstallDir) - 1);
2626  bool hasVCExpressDir = getSystemRegistryString(
2627    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\$VERSION",
2628    "InstallDir", vsExpressIDEInstallDir, sizeof(vsExpressIDEInstallDir) - 1);
2629    // If we have both vc80 and vc90, pick version we were compiled with.
2630  if (hasVCDir && vsIDEInstallDir[0]) {
2631    char *p = (char*)strstr(vsIDEInstallDir, "\\Common7\\IDE");
2632    if (p)
2633      *p = '\0';
2634    path = vsIDEInstallDir;
2635    return true;
2636  }
2637
2638  if (hasVCExpressDir && vsExpressIDEInstallDir[0]) {
2639    char *p = (char*)strstr(vsExpressIDEInstallDir, "\\Common7\\IDE");
2640    if (p)
2641      *p = '\0';
2642    path = vsExpressIDEInstallDir;
2643    return true;
2644  }
2645
2646  // Try the environment.
2647  const char *vs100comntools = getenv("VS100COMNTOOLS");
2648  const char *vs90comntools = getenv("VS90COMNTOOLS");
2649  const char *vs80comntools = getenv("VS80COMNTOOLS");
2650  const char *vscomntools = NULL;
2651
2652  // Try to find the version that we were compiled with
2653  if(false) {}
2654  #if (_MSC_VER >= 1600)  // VC100
2655  else if(vs100comntools) {
2656    vscomntools = vs100comntools;
2657  }
2658  #elif (_MSC_VER == 1500) // VC80
2659  else if(vs90comntools) {
2660    vscomntools = vs90comntools;
2661  }
2662  #elif (_MSC_VER == 1400) // VC80
2663  else if(vs80comntools) {
2664    vscomntools = vs80comntools;
2665  }
2666  #endif
2667  // Otherwise find any version we can
2668  else if (vs100comntools)
2669    vscomntools = vs100comntools;
2670  else if (vs90comntools)
2671    vscomntools = vs90comntools;
2672  else if (vs80comntools)
2673    vscomntools = vs80comntools;
2674
2675  if (vscomntools && *vscomntools) {
2676    const char *p = strstr(vscomntools, "\\Common7\\Tools");
2677    path = p ? std::string(vscomntools, p) : vscomntools;
2678    return true;
2679  }
2680  return false;
2681}
2682
2683#endif // _MSC_VER
2684
2685void Windows::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2686                                        ArgStringList &CC1Args) const {
2687  if (DriverArgs.hasArg(options::OPT_nostdinc))
2688    return;
2689
2690  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2691    // Ignore the sysroot, we *always* look for clang headers relative to
2692    // supplied path.
2693    llvm::sys::Path P(getDriver().ResourceDir);
2694    P.appendComponent("include");
2695    CC1Args.push_back("-internal-nosysroot-isystem");
2696    CC1Args.push_back(DriverArgs.MakeArgString(P.str()));
2697  }
2698
2699  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2700    return;
2701
2702  std::string VSDir;
2703  std::string WindowsSDKDir;
2704
2705#ifdef _MSC_VER
2706  // When built with access to the proper Windows APIs, try to actually find
2707  // the correct include paths first.
2708  if (getVisualStudioDir(VSDir)) {
2709    addSystemInclude(DriverArgs, CC1Args, VSDir + "\\VC\\include");
2710    if (getWindowsSDKDir(WindowsSDKDir))
2711      addSystemInclude(DriverArgs, CC1Args, WindowsSDKDir + "\\include");
2712    else
2713      addSystemInclude(DriverArgs, CC1Args,
2714                       VSDir + "\\VC\\PlatformSDK\\Include");
2715    return;
2716  }
2717#endif // _MSC_VER
2718
2719  // As a fallback, select default install paths.
2720  const StringRef Paths[] = {
2721    "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
2722    "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
2723    "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
2724    "C:/Program Files/Microsoft Visual Studio 8/VC/include",
2725    "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
2726  };
2727  addSystemIncludes(DriverArgs, CC1Args, Paths);
2728}
2729
2730void Windows::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2731                                           ArgStringList &CC1Args) const {
2732  // FIXME: There should probably be logic here to find libc++ on Windows.
2733}
2734