ToolChains.cpp revision 258883b544bfc220b801b66a5fad416c83cd956f 
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 Trivial helper function to simplify code checking path existence.
1523static bool PathExists(StringRef Path) {
1524  bool Exists;
1525  if (!llvm::sys::fs::exists(Path, Exists))
1526    return Exists;
1527  return false;
1528}
1529
1530namespace {
1531/// \brief This is a class to find a viable GCC installation for Clang to use.
1532///
1533/// This class tries to find a GCC installation on the system, and report
1534/// information about it. It starts from the host information provided to the
1535/// Driver, and has logic for fuzzing that where appropriate.
1536class GCCInstallationDetector {
1537  /// \brief Struct to store and manipulate GCC versions.
1538  ///
1539  /// We rely on assumptions about the form and structure of GCC version
1540  /// numbers: they consist of at most three '.'-separated components, and each
1541  /// component is a non-negative integer.
1542  struct GCCVersion {
1543    unsigned Major, Minor, Patch;
1544
1545    static GCCVersion Parse(StringRef VersionText) {
1546      const GCCVersion BadVersion = {0, 0, 0};
1547      std::pair<StringRef, StringRef> First = VersionText.split('.');
1548      std::pair<StringRef, StringRef> Second = First.second.split('.');
1549
1550      GCCVersion GoodVersion = {0, 0, 0};
1551      if (First.first.getAsInteger(10, GoodVersion.Major))
1552        return BadVersion;
1553      if (Second.first.getAsInteger(10, GoodVersion.Minor))
1554        return BadVersion;
1555      // We accept a number, or a string for the patch version, in case there
1556      // is a strang suffix, or other mangling: '4.1.x', '4.1.2-rc3'. When it
1557      // isn't a number, we just use '0' as the number but accept it.
1558      if (Second.first.getAsInteger(10, GoodVersion.Patch))
1559        GoodVersion.Patch = 0;
1560      return GoodVersion;
1561    }
1562
1563    bool operator<(const GCCVersion &RHS) const {
1564      if (Major < RHS.Major) return true;
1565      if (Major > RHS.Major) return false;
1566      if (Minor < RHS.Minor) return true;
1567      if (Minor > RHS.Minor) return false;
1568      return Patch < RHS.Patch;
1569    }
1570    bool operator>(const GCCVersion &RHS) const { return RHS < *this; }
1571    bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); }
1572    bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); }
1573  };
1574
1575  bool IsValid;
1576  std::string GccTriple;
1577
1578  // FIXME: These might be better as path objects.
1579  std::string GccInstallPath;
1580  std::string GccParentLibPath;
1581
1582  llvm::SmallString<128> CxxIncludeRoot;
1583
1584public:
1585  /// \brief Construct a GCCInstallationDetector from the driver.
1586  ///
1587  /// This performs all of the autodetection and sets up the various paths.
1588  /// Once constructed, a GCCInstallation is esentially immutable.
1589  GCCInstallationDetector(const Driver &D)
1590    : IsValid(false),
1591      GccTriple(D.DefaultHostTriple),
1592      CxxIncludeRoot(CXX_INCLUDE_ROOT) {
1593    // FIXME: Using CXX_INCLUDE_ROOT is here is a bit of a hack, but
1594    // avoids adding yet another option to configure/cmake.
1595    // It would probably be cleaner to break it in two variables
1596    // CXX_GCC_ROOT with just /foo/bar
1597    // CXX_GCC_VER with 4.5.2
1598    // Then we would have
1599    // CXX_INCLUDE_ROOT = CXX_GCC_ROOT/include/c++/CXX_GCC_VER
1600    // and this function would return
1601    // CXX_GCC_ROOT/lib/gcc/CXX_INCLUDE_ARCH/CXX_GCC_VER
1602    if (CxxIncludeRoot != "") {
1603      // This is of the form /foo/bar/include/c++/4.5.2/
1604      if (CxxIncludeRoot.back() == '/')
1605        llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the /
1606      StringRef Version = llvm::sys::path::filename(CxxIncludeRoot);
1607      llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the version
1608      llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the c++
1609      llvm::sys::path::remove_filename(CxxIncludeRoot); // remove the include
1610      GccInstallPath = CxxIncludeRoot.str();
1611      GccInstallPath.append("/lib/gcc/");
1612      GccInstallPath.append(CXX_INCLUDE_ARCH);
1613      GccInstallPath.append("/");
1614      GccInstallPath.append(Version);
1615      GccParentLibPath = GccInstallPath + "/../../..";
1616      IsValid = true;
1617      return;
1618    }
1619
1620    llvm::Triple::ArchType HostArch = llvm::Triple(GccTriple).getArch();
1621    // The library directories which may contain GCC installations.
1622    SmallVector<StringRef, 4> CandidateLibDirs;
1623    // The compatible GCC triples for this particular architecture.
1624    SmallVector<StringRef, 10> CandidateTriples;
1625    CollectLibDirsAndTriples(HostArch, CandidateLibDirs, CandidateTriples);
1626
1627    // Always include the default host triple as the final fallback if no
1628    // specific triple is detected.
1629    CandidateTriples.push_back(D.DefaultHostTriple);
1630
1631    // Compute the set of prefixes for our search.
1632    SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1633                                         D.PrefixDirs.end());
1634    Prefixes.push_back(D.SysRoot);
1635    Prefixes.push_back(D.SysRoot + "/usr");
1636    Prefixes.push_back(D.InstalledDir + "/..");
1637
1638    // Loop over the various components which exist and select the best GCC
1639    // installation available. GCC installs are ranked by version number.
1640    GCCVersion BestVersion = {0, 0, 0};
1641    for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) {
1642      if (!PathExists(Prefixes[i]))
1643        continue;
1644      for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) {
1645        const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str();
1646        if (!PathExists(LibDir))
1647          continue;
1648        for (unsigned k = 0, ke = CandidateTriples.size(); k < ke; ++k)
1649          ScanLibDirForGCCTriple(LibDir, CandidateTriples[k], BestVersion);
1650      }
1651    }
1652  }
1653
1654  /// \brief Check whether we detected a valid GCC install.
1655  bool isValid() const { return IsValid; }
1656
1657  /// \brief Get the GCC triple for the detected install.
1658  const std::string &getTriple() const { return GccTriple; }
1659
1660  /// \brief Get the detected GCC installation path.
1661  const std::string &getInstallPath() const { return GccInstallPath; }
1662
1663  /// \brief Get the detected GCC parent lib path.
1664  const std::string &getParentLibPath() const { return GccParentLibPath; }
1665
1666private:
1667  static void CollectLibDirsAndTriples(llvm::Triple::ArchType HostArch,
1668                                       SmallVectorImpl<StringRef> &LibDirs,
1669                                       SmallVectorImpl<StringRef> &Triples) {
1670    if (HostArch == llvm::Triple::arm || HostArch == llvm::Triple::thumb) {
1671      static const char *const ARMLibDirs[] = { "/lib" };
1672      static const char *const ARMTriples[] = { "arm-linux-gnueabi" };
1673      LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs));
1674      Triples.append(ARMTriples, ARMTriples + llvm::array_lengthof(ARMTriples));
1675    } else if (HostArch == llvm::Triple::x86_64) {
1676      static const char *const X86_64LibDirs[] = { "/lib64", "/lib" };
1677      static const char *const X86_64Triples[] = {
1678        "x86_64-linux-gnu",
1679        "x86_64-unknown-linux-gnu",
1680        "x86_64-pc-linux-gnu",
1681        "x86_64-redhat-linux6E",
1682        "x86_64-redhat-linux",
1683        "x86_64-suse-linux",
1684        "x86_64-manbo-linux-gnu",
1685        "x86_64-linux-gnu",
1686        "x86_64-slackware-linux"
1687      };
1688      LibDirs.append(X86_64LibDirs,
1689                     X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1690      Triples.append(X86_64Triples,
1691                     X86_64Triples + llvm::array_lengthof(X86_64Triples));
1692    } else if (HostArch == llvm::Triple::x86) {
1693      static const char *const X86LibDirs[] = { "/lib32", "/lib" };
1694      static const char *const X86Triples[] = {
1695        "i686-linux-gnu",
1696        "i386-linux-gnu",
1697        "i686-pc-linux-gnu",
1698        "i486-linux-gnu",
1699        "i686-redhat-linux",
1700        "i386-redhat-linux",
1701        "i586-suse-linux",
1702        "i486-slackware-linux"
1703      };
1704      LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1705      Triples.append(X86Triples, X86Triples + llvm::array_lengthof(X86Triples));
1706    } else if (HostArch == llvm::Triple::ppc) {
1707      static const char *const PPCLibDirs[] = { "/lib32", "/lib" };
1708      static const char *const PPCTriples[] = {
1709        "powerpc-linux-gnu",
1710        "powerpc-unknown-linux-gnu"
1711      };
1712      LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1713      Triples.append(PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples));
1714    } else if (HostArch == llvm::Triple::ppc64) {
1715      static const char *const PPC64LibDirs[] = { "/lib64", "/lib" };
1716      static const char *const PPC64Triples[] = {
1717        "powerpc64-unknown-linux-gnu"
1718      };
1719      LibDirs.append(PPC64LibDirs,
1720                     PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1721      Triples.append(PPC64Triples,
1722                     PPC64Triples + llvm::array_lengthof(PPC64Triples));
1723    }
1724  }
1725
1726  void ScanLibDirForGCCTriple(const std::string &LibDir,
1727                              StringRef CandidateTriple,
1728                              GCCVersion &BestVersion) {
1729    // There are various different suffixes involving the triple we
1730    // check for. We also record what is necessary to walk from each back
1731    // up to the lib directory.
1732    const std::string Suffixes[] = {
1733      "/gcc/" + CandidateTriple.str(),
1734      "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
1735
1736      // Ubuntu has a strange mis-matched pair of triples that this happens to
1737      // match.
1738      // FIXME: It may be worthwhile to generalize this and look for a second
1739      // triple.
1740      "/" + CandidateTriple.str() + "/gcc/i686-linux-gnu"
1741    };
1742    const std::string InstallSuffixes[] = {
1743      "/../../..",
1744      "/../../../..",
1745      "/../../../.."
1746    };
1747    // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
1748    const unsigned NumSuffixes = (llvm::array_lengthof(Suffixes) -
1749                                  (CandidateTriple != "i386-linux-gnu"));
1750    for (unsigned i = 0; i < NumSuffixes; ++i) {
1751      StringRef Suffix = Suffixes[i];
1752      llvm::error_code EC;
1753      for (llvm::sys::fs::directory_iterator LI(LibDir + Suffix, EC), LE;
1754           !EC && LI != LE; LI = LI.increment(EC)) {
1755        StringRef VersionText = llvm::sys::path::filename(LI->path());
1756        GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1757        static const GCCVersion MinVersion = { 4, 1, 1 };
1758        if (CandidateVersion < MinVersion)
1759          continue;
1760        if (CandidateVersion <= BestVersion)
1761          continue;
1762        if (!PathExists(LI->path() + "/crtbegin.o"))
1763          continue;
1764
1765        BestVersion = CandidateVersion;
1766        GccTriple = CandidateTriple.str();
1767        // FIXME: We hack together the directory name here instead of
1768        // using LI to ensure stable path separators across Windows and
1769        // Linux.
1770        GccInstallPath = LibDir + Suffixes[i] + "/" + VersionText.str();
1771        GccParentLibPath = GccInstallPath + InstallSuffixes[i];
1772        IsValid = true;
1773      }
1774    }
1775  }
1776};
1777}
1778
1779static void addPathIfExists(const std::string &Path,
1780                            ToolChain::path_list &Paths) {
1781  if (PathExists(Path)) Paths.push_back(Path);
1782}
1783
1784/// \brief Get our best guess at the multiarch triple for a target.
1785///
1786/// Debian-based systems are starting to use a multiarch setup where they use
1787/// a target-triple directory in the library and header search paths.
1788/// Unfortunately, this triple does not align with the vanilla target triple,
1789/// so we provide a rough mapping here.
1790static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
1791                                      StringRef SysRoot) {
1792  // For most architectures, just use whatever we have rather than trying to be
1793  // clever.
1794  switch (TargetTriple.getArch()) {
1795  default:
1796    return TargetTriple.str();
1797
1798    // We use the existence of '/lib/<triple>' as a directory to detect some
1799    // common linux triples that don't quite match the Clang triple for both
1800    // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
1801    // regardless of what the actual target triple is.
1802  case llvm::Triple::x86:
1803    if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
1804      return "i386-linux-gnu";
1805    return TargetTriple.str();
1806  case llvm::Triple::x86_64:
1807    if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
1808      return "x86_64-linux-gnu";
1809    return TargetTriple.str();
1810  }
1811}
1812
1813Linux::Linux(const HostInfo &Host, const llvm::Triple &Triple)
1814  : Generic_ELF(Host, Triple) {
1815  llvm::Triple::ArchType Arch =
1816    llvm::Triple(getDriver().DefaultHostTriple).getArch();
1817  const std::string &SysRoot = getDriver().SysRoot;
1818  GCCInstallationDetector GCCInstallation(getDriver());
1819
1820  // OpenSuse stores the linker with the compiler, add that to the search
1821  // path.
1822  ToolChain::path_list &PPaths = getProgramPaths();
1823  PPaths.push_back(GCCInstallation.getParentLibPath() + "/../" +
1824                   GCCInstallation.getTriple() + "/bin");
1825
1826  Linker = GetProgramPath("ld");
1827
1828  LinuxDistro Distro = DetectLinuxDistro(Arch);
1829
1830  if (IsOpenSuse(Distro) || IsUbuntu(Distro)) {
1831    ExtraOpts.push_back("-z");
1832    ExtraOpts.push_back("relro");
1833  }
1834
1835  if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
1836    ExtraOpts.push_back("-X");
1837
1838  if (IsRedhat(Distro) || IsOpenSuse(Distro) || Distro == UbuntuMaverick ||
1839      Distro == UbuntuNatty || Distro == UbuntuOneiric)
1840    ExtraOpts.push_back("--hash-style=gnu");
1841
1842  if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid ||
1843      Distro == UbuntuJaunty || Distro == UbuntuKarmic)
1844    ExtraOpts.push_back("--hash-style=both");
1845
1846  if (IsRedhat(Distro))
1847    ExtraOpts.push_back("--no-add-needed");
1848
1849  if (Distro == DebianSqueeze || Distro == DebianWheezy ||
1850      IsOpenSuse(Distro) ||
1851      (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
1852      Distro == UbuntuLucid ||
1853      Distro == UbuntuMaverick || Distro == UbuntuKarmic ||
1854      Distro == UbuntuNatty || Distro == UbuntuOneiric)
1855    ExtraOpts.push_back("--build-id");
1856
1857  if (IsOpenSuse(Distro))
1858    ExtraOpts.push_back("--enable-new-dtags");
1859
1860  // The selection of paths to try here is designed to match the patterns which
1861  // the GCC driver itself uses, as this is part of the GCC-compatible driver.
1862  // This was determined by running GCC in a fake filesystem, creating all
1863  // possible permutations of these directories, and seeing which ones it added
1864  // to the link paths.
1865  path_list &Paths = getFilePaths();
1866  const bool Is32Bits = (getArch() == llvm::Triple::x86 ||
1867                         getArch() == llvm::Triple::ppc);
1868
1869  const std::string Suffix32 = Arch == llvm::Triple::x86_64 ? "/32" : "";
1870  const std::string Suffix64 = Arch == llvm::Triple::x86_64 ? "" : "/64";
1871  const std::string Suffix = Is32Bits ? Suffix32 : Suffix64;
1872  const std::string Multilib = Is32Bits ? "lib32" : "lib64";
1873  const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
1874
1875  // FIXME: Because we add paths only when they exist on the system, I think we
1876  // should remove the concept of 'HasMultilib'. It's more likely to break the
1877  // behavior than to preserve any useful invariant on the system.
1878  if (HasMultilib(Arch, Distro)) {
1879    // Add the multilib suffixed paths.
1880    if (GCCInstallation.isValid()) {
1881      const std::string &LibPath = GCCInstallation.getParentLibPath();
1882      const std::string &GccTriple = GCCInstallation.getTriple();
1883      // FIXME: This OpenSuse-specific path shouldn't be needed any more, but
1884      // I don't want to remove it without finding someone to test.
1885      if (IsOpenSuse(Distro) && Is32Bits)
1886        Paths.push_back(LibPath + "/../" + GccTriple + "/lib/../lib");
1887
1888      addPathIfExists(GCCInstallation.getInstallPath() + Suffix, Paths);
1889      addPathIfExists(LibPath + "/../" + GccTriple + "/lib/../" + Multilib,
1890                      Paths);
1891      addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
1892      addPathIfExists(LibPath + "/../" + Multilib, Paths);
1893    }
1894    addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
1895    addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
1896    addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
1897    addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
1898
1899    // Try walking via the GCC triple path in case of multiarch GCC
1900    // installations with strange symlinks.
1901    if (GCCInstallation.isValid())
1902      addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple() +
1903                      "/../../" + Multilib, Paths);
1904  }
1905
1906  // Add the non-multilib suffixed paths (if potentially different).
1907  if (GCCInstallation.isValid()) {
1908    const std::string &LibPath = GCCInstallation.getParentLibPath();
1909    const std::string &GccTriple = GCCInstallation.getTriple();
1910    if (!Suffix.empty() || !HasMultilib(Arch, Distro))
1911      addPathIfExists(GCCInstallation.getInstallPath(), Paths);
1912    addPathIfExists(LibPath + "/../" + GccTriple + "/lib", Paths);
1913    addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
1914    addPathIfExists(LibPath, Paths);
1915  }
1916  addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
1917  addPathIfExists(SysRoot + "/lib", Paths);
1918  addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
1919  addPathIfExists(SysRoot + "/usr/lib", Paths);
1920}
1921
1922bool Linux::HasNativeLLVMSupport() const {
1923  return true;
1924}
1925
1926Tool &Linux::SelectTool(const Compilation &C, const JobAction &JA,
1927                        const ActionList &Inputs) const {
1928  Action::ActionClass Key;
1929  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1930    Key = Action::AnalyzeJobClass;
1931  else
1932    Key = JA.getKind();
1933
1934  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1935                                             options::OPT_no_integrated_as,
1936                                             IsIntegratedAssemblerDefault());
1937
1938  Tool *&T = Tools[Key];
1939  if (!T) {
1940    switch (Key) {
1941    case Action::AssembleJobClass:
1942      if (UseIntegratedAs)
1943        T = new tools::ClangAs(*this);
1944      else
1945        T = new tools::linuxtools::Assemble(*this);
1946      break;
1947    case Action::LinkJobClass:
1948      T = new tools::linuxtools::Link(*this); break;
1949    default:
1950      T = &Generic_GCC::SelectTool(C, JA, Inputs);
1951    }
1952  }
1953
1954  return *T;
1955}
1956
1957void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
1958                                      ArgStringList &CC1Args) const {
1959  const Driver &D = getDriver();
1960
1961  if (DriverArgs.hasArg(options::OPT_nostdinc))
1962    return;
1963
1964  if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
1965    addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include");
1966
1967  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
1968    // Ignore the sysroot, we *always* look for clang headers relative to
1969    // supplied path.
1970    llvm::sys::Path P(D.ResourceDir);
1971    P.appendComponent("include");
1972    CC1Args.push_back("-internal-nosysroot-isystem");
1973    CC1Args.push_back(DriverArgs.MakeArgString(P.str()));
1974  }
1975
1976  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
1977    return;
1978
1979  // Check for configure-time C include directories.
1980  StringRef CIncludeDirs(C_INCLUDE_DIRS);
1981  if (CIncludeDirs != "") {
1982    SmallVector<StringRef, 5> dirs;
1983    CIncludeDirs.split(dirs, ":");
1984    for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
1985         I != E; ++I) {
1986      StringRef Prefix = llvm::sys::path::is_absolute(*I) ? D.SysRoot : "";
1987      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
1988    }
1989    return;
1990  }
1991
1992  // Lacking those, try to detect the correct set of system includes for the
1993  // target triple.
1994
1995  // Generic Debian multiarch support:
1996  if (getTriple().getArch() == llvm::Triple::x86_64) {
1997    addExternCSystemInclude(DriverArgs, CC1Args,
1998                            "/usr/include/x86_64-linux-gnu");
1999    addExternCSystemInclude(DriverArgs, CC1Args,
2000                            "/usr/include/i686-linux-gnu/64");
2001    addExternCSystemInclude(DriverArgs, CC1Args,
2002                            "/usr/include/i486-linux-gnu/64");
2003  } else if (getTriple().getArch() == llvm::Triple::x86) {
2004    addExternCSystemInclude(DriverArgs, CC1Args,
2005                            "/usr/include/x86_64-linux-gnu/32");
2006    addExternCSystemInclude(DriverArgs, CC1Args, "/usr/include/i686-linux-gnu");
2007    addExternCSystemInclude(DriverArgs, CC1Args, "/usr/include/i486-linux-gnu");
2008    addExternCSystemInclude(DriverArgs, CC1Args, "/usr/include/i386-linux-gnu");
2009  } else if (getTriple().getArch() == llvm::Triple::arm) {
2010    addExternCSystemInclude(DriverArgs, CC1Args,
2011                            "/usr/include/arm-linux-gnueabi");
2012  }
2013
2014  if (getTriple().getOS() == llvm::Triple::RTEMS)
2015    return;
2016
2017  addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include");
2018}
2019
2020static void AddLibStdCXXIncludePaths(StringRef Base, StringRef ArchDir,
2021                                     StringRef Dir32, StringRef Dir64,
2022                                     const llvm::Triple &Triple,
2023                                     const ArgList &DriverArgs,
2024                                     ArgStringList &CC1Args) {
2025  addSystemInclude(DriverArgs, CC1Args, Base);
2026
2027  // Add the multilib dirs
2028  llvm::Triple::ArchType Arch = Triple.getArch();
2029  bool Is64bit = Arch == llvm::Triple::ppc64 || Arch == llvm::Triple::x86_64;
2030  if (Is64bit)
2031    addSystemInclude(DriverArgs, CC1Args, Base + "/" + ArchDir + "/" + Dir64);
2032  else
2033    addSystemInclude(DriverArgs, CC1Args, Base + "/" + ArchDir + "/" + Dir32);
2034
2035  // Add the backward dir
2036  addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
2037}
2038
2039void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2040                                         ArgStringList &CC1Args) const {
2041  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2042      DriverArgs.hasArg(options::OPT_nostdincxx))
2043    return;
2044
2045  const llvm::Triple &Triple = getTriple();
2046  StringRef CxxIncludeRoot(CXX_INCLUDE_ROOT);
2047  if (CxxIncludeRoot != "") {
2048    StringRef CxxIncludeArch(CXX_INCLUDE_ARCH);
2049    if (CxxIncludeArch == "")
2050      AddLibStdCXXIncludePaths(CxxIncludeRoot, Triple.str().c_str(),
2051                               CXX_INCLUDE_32BIT_DIR, CXX_INCLUDE_64BIT_DIR,
2052                               Triple, DriverArgs, CC1Args);
2053    else
2054      AddLibStdCXXIncludePaths(CxxIncludeRoot, CXX_INCLUDE_ARCH,
2055                               CXX_INCLUDE_32BIT_DIR, CXX_INCLUDE_64BIT_DIR,
2056                               Triple, DriverArgs, CC1Args);
2057    return;
2058  }
2059  // FIXME: temporary hack: hard-coded paths.
2060
2061  //===------------------------------------------------------------------===//
2062  // Debian based distros.
2063  // Note: these distros symlink /usr/include/c++/X.Y.Z -> X.Y
2064  //===------------------------------------------------------------------===//
2065
2066  // Ubuntu 11.11 "Oneiric Ocelot" -- gcc-4.6.0
2067  AddLibStdCXXIncludePaths(
2068    "/usr/include/c++/4.6",
2069    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2070  AddLibStdCXXIncludePaths(
2071    "/usr/include/c++/4.6",
2072    "i686-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2073  AddLibStdCXXIncludePaths(
2074    "/usr/include/c++/4.6",
2075    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2076  AddLibStdCXXIncludePaths(
2077    "/usr/include/c++/4.6",
2078    "arm-linux-gnueabi", "", "", Triple, DriverArgs, CC1Args);
2079
2080  // Ubuntu 11.04 "Natty Narwhal" -- gcc-4.5.2
2081  AddLibStdCXXIncludePaths(
2082    "/usr/include/c++/4.5",
2083    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2084  AddLibStdCXXIncludePaths(
2085    "/usr/include/c++/4.5",
2086    "i686-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2087  AddLibStdCXXIncludePaths(
2088    "/usr/include/c++/4.5",
2089    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2090  AddLibStdCXXIncludePaths(
2091    "/usr/include/c++/4.5",
2092    "arm-linux-gnueabi", "", "", Triple, DriverArgs, CC1Args);
2093
2094  // Ubuntu 10.10 "Maverick Meerkat" -- gcc-4.4.5
2095  AddLibStdCXXIncludePaths(
2096    "/usr/include/c++/4.4",
2097    "i686-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2098  // The rest of 10.10 is the same as previous versions.
2099
2100  // Ubuntu 10.04 LTS "Lucid Lynx" -- gcc-4.4.3
2101  // Ubuntu 9.10 "Karmic Koala"    -- gcc-4.4.1
2102  // Debian 6.0 "squeeze"          -- gcc-4.4.2
2103  AddLibStdCXXIncludePaths(
2104    "/usr/include/c++/4.4",
2105    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2106  AddLibStdCXXIncludePaths(
2107    "/usr/include/c++/4.4",
2108    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2109  AddLibStdCXXIncludePaths(
2110    "/usr/include/c++/4.4",
2111    "arm-linux-gnueabi", "", "", Triple, DriverArgs, CC1Args);
2112  // Ubuntu 9.04 "Jaunty Jackalope" -- gcc-4.3.3
2113  // Ubuntu 8.10 "Intrepid Ibex"    -- gcc-4.3.2
2114  // Debian 5.0 "lenny"             -- gcc-4.3.2
2115  AddLibStdCXXIncludePaths(
2116    "/usr/include/c++/4.3",
2117    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2118  AddLibStdCXXIncludePaths(
2119    "/usr/include/c++/4.3",
2120    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2121  AddLibStdCXXIncludePaths(
2122    "/usr/include/c++/4.3",
2123    "arm-linux-gnueabi", "", "", Triple, DriverArgs, CC1Args);
2124  // Ubuntu 8.04.4 LTS "Hardy Heron"     -- gcc-4.2.4
2125  // Ubuntu 8.04.[0-3] LTS "Hardy Heron" -- gcc-4.2.3
2126  AddLibStdCXXIncludePaths(
2127    "/usr/include/c++/4.2",
2128    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2129  AddLibStdCXXIncludePaths(
2130    "/usr/include/c++/4.2",
2131    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2132  // Ubuntu 7.10 "Gutsy Gibbon" -- gcc-4.1.3
2133  AddLibStdCXXIncludePaths(
2134    "/usr/include/c++/4.1",
2135    "x86_64-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2136  AddLibStdCXXIncludePaths(
2137    "/usr/include/c++/4.1",
2138    "i486-linux-gnu", "", "64", Triple, DriverArgs, CC1Args);
2139
2140  //===------------------------------------------------------------------===//
2141  // Redhat based distros.
2142  //===------------------------------------------------------------------===//
2143  // Fedora 15 (GCC 4.6.1)
2144  AddLibStdCXXIncludePaths(
2145    "/usr/include/c++/4.6.1",
2146    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2147  AddLibStdCXXIncludePaths(
2148    "/usr/include/c++/4.6.1",
2149    "i686-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2150  // Fedora 15 (GCC 4.6.0)
2151  AddLibStdCXXIncludePaths(
2152    "/usr/include/c++/4.6.0",
2153    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2154  AddLibStdCXXIncludePaths(
2155    "/usr/include/c++/4.6.0",
2156    "i686-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2157  // Fedora 14
2158  AddLibStdCXXIncludePaths(
2159    "/usr/include/c++/4.5.1",
2160    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2161  AddLibStdCXXIncludePaths(
2162    "/usr/include/c++/4.5.1",
2163    "i686-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2164  // RHEL5(gcc44)
2165  AddLibStdCXXIncludePaths(
2166    "/usr/include/c++/4.4.4",
2167    "x86_64-redhat-linux6E", "32", "", Triple, DriverArgs, CC1Args);
2168  // Fedora 13
2169  AddLibStdCXXIncludePaths(
2170    "/usr/include/c++/4.4.4",
2171    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2172  AddLibStdCXXIncludePaths(
2173    "/usr/include/c++/4.4.4",
2174    "i686-redhat-linux","", "", Triple, DriverArgs, CC1Args);
2175  // Fedora 12
2176  AddLibStdCXXIncludePaths(
2177    "/usr/include/c++/4.4.3",
2178    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2179  AddLibStdCXXIncludePaths(
2180    "/usr/include/c++/4.4.3",
2181    "i686-redhat-linux","", "", Triple, DriverArgs, CC1Args);
2182  // Fedora 12 (pre-FEB-2010)
2183  AddLibStdCXXIncludePaths(
2184    "/usr/include/c++/4.4.2",
2185    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2186  AddLibStdCXXIncludePaths(
2187    "/usr/include/c++/4.4.2",
2188    "i686-redhat-linux","", "", Triple, DriverArgs, CC1Args);
2189  // Fedora 11
2190  AddLibStdCXXIncludePaths(
2191    "/usr/include/c++/4.4.1",
2192    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2193  AddLibStdCXXIncludePaths(
2194    "/usr/include/c++/4.4.1",
2195    "i586-redhat-linux","", "", Triple, DriverArgs, CC1Args);
2196  // Fedora 10
2197  AddLibStdCXXIncludePaths(
2198    "/usr/include/c++/4.3.2",
2199    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2200  AddLibStdCXXIncludePaths(
2201    "/usr/include/c++/4.3.2",
2202    "i386-redhat-linux","", "", Triple, DriverArgs, CC1Args);
2203  // Fedora 9
2204  AddLibStdCXXIncludePaths(
2205    "/usr/include/c++/4.3.0",
2206    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2207  AddLibStdCXXIncludePaths(
2208    "/usr/include/c++/4.3.0",
2209    "i386-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2210  // Fedora 8
2211  AddLibStdCXXIncludePaths(
2212    "/usr/include/c++/4.1.2",
2213    "x86_64-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2214  AddLibStdCXXIncludePaths(
2215    "/usr/include/c++/4.1.2",
2216    "i386-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2217
2218  // RHEL 5
2219  AddLibStdCXXIncludePaths(
2220    "/usr/include/c++/4.1.1",
2221    "x86_64-redhat-linux", "32", "", Triple, DriverArgs, CC1Args);
2222  AddLibStdCXXIncludePaths(
2223    "/usr/include/c++/4.1.1",
2224    "i386-redhat-linux", "", "", Triple, DriverArgs, CC1Args);
2225
2226
2227  //===------------------------------------------------------------------===//
2228
2229  // Exherbo (2010-01-25)
2230  AddLibStdCXXIncludePaths(
2231    "/usr/include/c++/4.4.3",
2232    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2233  AddLibStdCXXIncludePaths(
2234    "/usr/include/c++/4.4.3",
2235    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2236
2237  // openSUSE 11.1 32 bit
2238  AddLibStdCXXIncludePaths(
2239    "/usr/include/c++/4.3",
2240    "i586-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2241  // openSUSE 11.1 64 bit
2242  AddLibStdCXXIncludePaths(
2243    "/usr/include/c++/4.3",
2244    "x86_64-suse-linux", "32", "", Triple, DriverArgs, CC1Args);
2245  // openSUSE 11.2
2246  AddLibStdCXXIncludePaths(
2247    "/usr/include/c++/4.4",
2248    "i586-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2249  AddLibStdCXXIncludePaths(
2250    "/usr/include/c++/4.4",
2251    "x86_64-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2252
2253  // openSUSE 11.4
2254  AddLibStdCXXIncludePaths(
2255    "/usr/include/c++/4.5",
2256    "i586-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2257  AddLibStdCXXIncludePaths(
2258    "/usr/include/c++/4.5",
2259    "x86_64-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2260
2261  // openSUSE 12.1
2262  AddLibStdCXXIncludePaths(
2263    "/usr/include/c++/4.6",
2264    "i586-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2265  AddLibStdCXXIncludePaths(
2266    "/usr/include/c++/4.6",
2267    "x86_64-suse-linux", "", "", Triple, DriverArgs, CC1Args);
2268  // Arch Linux 2008-06-24
2269  AddLibStdCXXIncludePaths(
2270    "/usr/include/c++/4.3.1",
2271    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2272  AddLibStdCXXIncludePaths(
2273    "/usr/include/c++/4.3.1",
2274    "x86_64-unknown-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2275
2276  // Arch Linux gcc 4.6
2277  AddLibStdCXXIncludePaths(
2278    "/usr/include/c++/4.6.1",
2279    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2280  AddLibStdCXXIncludePaths(
2281    "/usr/include/c++/4.6.1",
2282    "x86_64-unknown-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2283  AddLibStdCXXIncludePaths(
2284    "/usr/include/c++/4.6.0",
2285    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2286  AddLibStdCXXIncludePaths(
2287    "/usr/include/c++/4.6.0",
2288    "x86_64-unknown-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2289
2290  // Slackware gcc 4.5.2 (13.37)
2291  AddLibStdCXXIncludePaths(
2292    "/usr/include/c++/4.5.2",
2293    "i486-slackware-linux", "", "", Triple, DriverArgs, CC1Args);
2294  AddLibStdCXXIncludePaths(
2295    "/usr/include/c++/4.5.2",
2296    "x86_64-slackware-linux", "", "", Triple, DriverArgs, CC1Args);
2297  // Slackware gcc 4.5.3 (-current)
2298  AddLibStdCXXIncludePaths(
2299    "/usr/include/c++/4.5.3",
2300    "i486-slackware-linux", "", "", Triple, DriverArgs, CC1Args);
2301  AddLibStdCXXIncludePaths(
2302    "/usr/include/c++/4.5.3",
2303    "x86_64-slackware-linux", "", "", Triple, DriverArgs, CC1Args);
2304
2305  // Gentoo x86 gcc 4.5.3
2306  AddLibStdCXXIncludePaths(
2307    "/usr/lib/gcc/i686-pc-linux-gnu/4.5.3/include/g++-v4",
2308    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2309  // Gentoo x86 gcc 4.5.2
2310  AddLibStdCXXIncludePaths(
2311    "/usr/lib/gcc/i686-pc-linux-gnu/4.5.2/include/g++-v4",
2312    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2313  // Gentoo x86 gcc 4.4.5
2314  AddLibStdCXXIncludePaths(
2315    "/usr/lib/gcc/i686-pc-linux-gnu/4.4.5/include/g++-v4",
2316    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2317  // Gentoo x86 gcc 4.4.4
2318  AddLibStdCXXIncludePaths(
2319    "/usr/lib/gcc/i686-pc-linux-gnu/4.4.4/include/g++-v4",
2320    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2321  // Gentoo x86 2010.0 stable
2322  AddLibStdCXXIncludePaths(
2323    "/usr/lib/gcc/i686-pc-linux-gnu/4.4.3/include/g++-v4",
2324    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2325  // Gentoo x86 2009.1 stable
2326  AddLibStdCXXIncludePaths(
2327    "/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4",
2328    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2329  // Gentoo x86 2009.0 stable
2330  AddLibStdCXXIncludePaths(
2331    "/usr/lib/gcc/i686-pc-linux-gnu/4.3.2/include/g++-v4",
2332    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2333  // Gentoo x86 2008.0 stable
2334  AddLibStdCXXIncludePaths(
2335    "/usr/lib/gcc/i686-pc-linux-gnu/4.1.2/include/g++-v4",
2336    "i686-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2337
2338  // Gentoo amd64 gcc 4.5.3
2339  AddLibStdCXXIncludePaths(
2340    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.3/include/g++-v4",
2341    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2342  // Gentoo amd64 gcc 4.5.2
2343  AddLibStdCXXIncludePaths(
2344    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.2/include/g++-v4",
2345    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2346  // Gentoo amd64 gcc 4.4.5
2347  AddLibStdCXXIncludePaths(
2348    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.5/include/g++-v4",
2349    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2350  // Gentoo amd64 gcc 4.4.4
2351  AddLibStdCXXIncludePaths(
2352    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.4/include/g++-v4",
2353    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2354  // Gentoo amd64 gcc 4.4.3
2355  AddLibStdCXXIncludePaths(
2356    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/include/g++-v4",
2357    "x86_64-pc-linux-gnu", "32", "", Triple, DriverArgs, CC1Args);
2358  // Gentoo amd64 gcc 4.3.4
2359  AddLibStdCXXIncludePaths(
2360    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.3.4/include/g++-v4",
2361    "x86_64-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2362  // Gentoo amd64 gcc 4.3.2
2363  AddLibStdCXXIncludePaths(
2364    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.3.2/include/g++-v4",
2365    "x86_64-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2366  // Gentoo amd64 stable
2367  AddLibStdCXXIncludePaths(
2368    "/usr/lib/gcc/x86_64-pc-linux-gnu/4.1.2/include/g++-v4",
2369    "x86_64-pc-linux-gnu", "", "", Triple, DriverArgs, CC1Args);
2370}
2371
2372/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2373
2374DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple)
2375  : Generic_ELF(Host, Triple) {
2376
2377  // Path mangling to find libexec
2378  getProgramPaths().push_back(getDriver().getInstalledDir());
2379  if (getDriver().getInstalledDir() != getDriver().Dir)
2380    getProgramPaths().push_back(getDriver().Dir);
2381
2382  getFilePaths().push_back(getDriver().Dir + "/../lib");
2383  getFilePaths().push_back("/usr/lib");
2384  getFilePaths().push_back("/usr/lib/gcc41");
2385}
2386
2387Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA,
2388                            const ActionList &Inputs) const {
2389  Action::ActionClass Key;
2390  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
2391    Key = Action::AnalyzeJobClass;
2392  else
2393    Key = JA.getKind();
2394
2395  Tool *&T = Tools[Key];
2396  if (!T) {
2397    switch (Key) {
2398    case Action::AssembleJobClass:
2399      T = new tools::dragonfly::Assemble(*this); break;
2400    case Action::LinkJobClass:
2401      T = new tools::dragonfly::Link(*this); break;
2402    default:
2403      T = &Generic_GCC::SelectTool(C, JA, Inputs);
2404    }
2405  }
2406
2407  return *T;
2408}
2409
2410Windows::Windows(const HostInfo &Host, const llvm::Triple& Triple)
2411  : ToolChain(Host, Triple) {
2412}
2413
2414Tool &Windows::SelectTool(const Compilation &C, const JobAction &JA,
2415                          const ActionList &Inputs) const {
2416  Action::ActionClass Key;
2417  if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
2418    Key = Action::AnalyzeJobClass;
2419  else
2420    Key = JA.getKind();
2421
2422  bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
2423                                             options::OPT_no_integrated_as,
2424                                             IsIntegratedAssemblerDefault());
2425
2426  Tool *&T = Tools[Key];
2427  if (!T) {
2428    switch (Key) {
2429    case Action::InputClass:
2430    case Action::BindArchClass:
2431    case Action::LipoJobClass:
2432    case Action::DsymutilJobClass:
2433    case Action::VerifyJobClass:
2434      llvm_unreachable("Invalid tool kind.");
2435    case Action::PreprocessJobClass:
2436    case Action::PrecompileJobClass:
2437    case Action::AnalyzeJobClass:
2438    case Action::CompileJobClass:
2439      T = new tools::Clang(*this); break;
2440    case Action::AssembleJobClass:
2441      if (!UseIntegratedAs && getTriple().getEnvironment() == llvm::Triple::MachO)
2442        T = new tools::darwin::Assemble(*this);
2443      else
2444        T = new tools::ClangAs(*this);
2445      break;
2446    case Action::LinkJobClass:
2447      T = new tools::visualstudio::Link(*this); break;
2448    }
2449  }
2450
2451  return *T;
2452}
2453
2454bool Windows::IsIntegratedAssemblerDefault() const {
2455  return true;
2456}
2457
2458bool Windows::IsUnwindTablesDefault() const {
2459  // FIXME: Gross; we should probably have some separate target
2460  // definition, possibly even reusing the one in clang.
2461  return getArchName() == "x86_64";
2462}
2463
2464const char *Windows::GetDefaultRelocationModel() const {
2465  return "static";
2466}
2467
2468const char *Windows::GetForcedPicModel() const {
2469  if (getArchName() == "x86_64")
2470    return "pic";
2471  return 0;
2472}
2473
2474// FIXME: This probably should goto to some platform utils place.
2475#ifdef _MSC_VER
2476
2477/// \brief Read registry string.
2478/// This also supports a means to look for high-versioned keys by use
2479/// of a $VERSION placeholder in the key path.
2480/// $VERSION in the key path is a placeholder for the version number,
2481/// causing the highest value path to be searched for and used.
2482/// I.e. "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\$VERSION".
2483/// There can be additional characters in the component.  Only the numberic
2484/// characters are compared.
2485static bool getSystemRegistryString(const char *keyPath, const char *valueName,
2486                                    char *value, size_t maxLength) {
2487  HKEY hRootKey = NULL;
2488  HKEY hKey = NULL;
2489  const char* subKey = NULL;
2490  DWORD valueType;
2491  DWORD valueSize = maxLength - 1;
2492  long lResult;
2493  bool returnValue = false;
2494
2495  if (strncmp(keyPath, "HKEY_CLASSES_ROOT\\", 18) == 0) {
2496    hRootKey = HKEY_CLASSES_ROOT;
2497    subKey = keyPath + 18;
2498  } else if (strncmp(keyPath, "HKEY_USERS\\", 11) == 0) {
2499    hRootKey = HKEY_USERS;
2500    subKey = keyPath + 11;
2501  } else if (strncmp(keyPath, "HKEY_LOCAL_MACHINE\\", 19) == 0) {
2502    hRootKey = HKEY_LOCAL_MACHINE;
2503    subKey = keyPath + 19;
2504  } else if (strncmp(keyPath, "HKEY_CURRENT_USER\\", 18) == 0) {
2505    hRootKey = HKEY_CURRENT_USER;
2506    subKey = keyPath + 18;
2507  } else {
2508    return false;
2509  }
2510
2511  const char *placeHolder = strstr(subKey, "$VERSION");
2512  char bestName[256];
2513  bestName[0] = '\0';
2514  // If we have a $VERSION placeholder, do the highest-version search.
2515  if (placeHolder) {
2516    const char *keyEnd = placeHolder - 1;
2517    const char *nextKey = placeHolder;
2518    // Find end of previous key.
2519    while ((keyEnd > subKey) && (*keyEnd != '\\'))
2520      keyEnd--;
2521    // Find end of key containing $VERSION.
2522    while (*nextKey && (*nextKey != '\\'))
2523      nextKey++;
2524    size_t partialKeyLength = keyEnd - subKey;
2525    char partialKey[256];
2526    if (partialKeyLength > sizeof(partialKey))
2527      partialKeyLength = sizeof(partialKey);
2528    strncpy(partialKey, subKey, partialKeyLength);
2529    partialKey[partialKeyLength] = '\0';
2530    HKEY hTopKey = NULL;
2531    lResult = RegOpenKeyEx(hRootKey, partialKey, 0, KEY_READ, &hTopKey);
2532    if (lResult == ERROR_SUCCESS) {
2533      char keyName[256];
2534      int bestIndex = -1;
2535      double bestValue = 0.0;
2536      DWORD index, size = sizeof(keyName) - 1;
2537      for (index = 0; RegEnumKeyEx(hTopKey, index, keyName, &size, NULL,
2538          NULL, NULL, NULL) == ERROR_SUCCESS; index++) {
2539        const char *sp = keyName;
2540        while (*sp && !isdigit(*sp))
2541          sp++;
2542        if (!*sp)
2543          continue;
2544        const char *ep = sp + 1;
2545        while (*ep && (isdigit(*ep) || (*ep == '.')))
2546          ep++;
2547        char numBuf[32];
2548        strncpy(numBuf, sp, sizeof(numBuf) - 1);
2549        numBuf[sizeof(numBuf) - 1] = '\0';
2550        double value = strtod(numBuf, NULL);
2551        if (value > bestValue) {
2552          bestIndex = (int)index;
2553          bestValue = value;
2554          strcpy(bestName, keyName);
2555        }
2556        size = sizeof(keyName) - 1;
2557      }
2558      // If we found the highest versioned key, open the key and get the value.
2559      if (bestIndex != -1) {
2560        // Append rest of key.
2561        strncat(bestName, nextKey, sizeof(bestName) - 1);
2562        bestName[sizeof(bestName) - 1] = '\0';
2563        // Open the chosen key path remainder.
2564        lResult = RegOpenKeyEx(hTopKey, bestName, 0, KEY_READ, &hKey);
2565        if (lResult == ERROR_SUCCESS) {
2566          lResult = RegQueryValueEx(hKey, valueName, NULL, &valueType,
2567            (LPBYTE)value, &valueSize);
2568          if (lResult == ERROR_SUCCESS)
2569            returnValue = true;
2570          RegCloseKey(hKey);
2571        }
2572      }
2573      RegCloseKey(hTopKey);
2574    }
2575  } else {
2576    lResult = RegOpenKeyEx(hRootKey, subKey, 0, KEY_READ, &hKey);
2577    if (lResult == ERROR_SUCCESS) {
2578      lResult = RegQueryValueEx(hKey, valueName, NULL, &valueType,
2579        (LPBYTE)value, &valueSize);
2580      if (lResult == ERROR_SUCCESS)
2581        returnValue = true;
2582      RegCloseKey(hKey);
2583    }
2584  }
2585  return returnValue;
2586}
2587
2588/// \brief Get Windows SDK installation directory.
2589static bool getWindowsSDKDir(std::string &path) {
2590  char windowsSDKInstallDir[256];
2591  // Try the Windows registry.
2592  bool hasSDKDir = getSystemRegistryString(
2593   "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
2594                                           "InstallationFolder",
2595                                           windowsSDKInstallDir,
2596                                           sizeof(windowsSDKInstallDir) - 1);
2597    // If we have both vc80 and vc90, pick version we were compiled with.
2598  if (hasSDKDir && windowsSDKInstallDir[0]) {
2599    path = windowsSDKInstallDir;
2600    return true;
2601  }
2602  return false;
2603}
2604
2605  // Get Visual Studio installation directory.
2606static bool getVisualStudioDir(std::string &path) {
2607  // First check the environment variables that vsvars32.bat sets.
2608  const char* vcinstalldir = getenv("VCINSTALLDIR");
2609  if (vcinstalldir) {
2610    char *p = const_cast<char *>(strstr(vcinstalldir, "\\VC"));
2611    if (p)
2612      *p = '\0';
2613    path = vcinstalldir;
2614    return true;
2615  }
2616
2617  char vsIDEInstallDir[256];
2618  char vsExpressIDEInstallDir[256];
2619  // Then try the windows registry.
2620  bool hasVCDir = getSystemRegistryString(
2621    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\$VERSION",
2622    "InstallDir", vsIDEInstallDir, sizeof(vsIDEInstallDir) - 1);
2623  bool hasVCExpressDir = getSystemRegistryString(
2624    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\$VERSION",
2625    "InstallDir", vsExpressIDEInstallDir, sizeof(vsExpressIDEInstallDir) - 1);
2626    // If we have both vc80 and vc90, pick version we were compiled with.
2627  if (hasVCDir && vsIDEInstallDir[0]) {
2628    char *p = (char*)strstr(vsIDEInstallDir, "\\Common7\\IDE");
2629    if (p)
2630      *p = '\0';
2631    path = vsIDEInstallDir;
2632    return true;
2633  }
2634
2635  if (hasVCExpressDir && vsExpressIDEInstallDir[0]) {
2636    char *p = (char*)strstr(vsExpressIDEInstallDir, "\\Common7\\IDE");
2637    if (p)
2638      *p = '\0';
2639    path = vsExpressIDEInstallDir;
2640    return true;
2641  }
2642
2643  // Try the environment.
2644  const char *vs100comntools = getenv("VS100COMNTOOLS");
2645  const char *vs90comntools = getenv("VS90COMNTOOLS");
2646  const char *vs80comntools = getenv("VS80COMNTOOLS");
2647  const char *vscomntools = NULL;
2648
2649  // Try to find the version that we were compiled with
2650  if(false) {}
2651  #if (_MSC_VER >= 1600)  // VC100
2652  else if(vs100comntools) {
2653    vscomntools = vs100comntools;
2654  }
2655  #elif (_MSC_VER == 1500) // VC80
2656  else if(vs90comntools) {
2657    vscomntools = vs90comntools;
2658  }
2659  #elif (_MSC_VER == 1400) // VC80
2660  else if(vs80comntools) {
2661    vscomntools = vs80comntools;
2662  }
2663  #endif
2664  // Otherwise find any version we can
2665  else if (vs100comntools)
2666    vscomntools = vs100comntools;
2667  else if (vs90comntools)
2668    vscomntools = vs90comntools;
2669  else if (vs80comntools)
2670    vscomntools = vs80comntools;
2671
2672  if (vscomntools && *vscomntools) {
2673    const char *p = strstr(vscomntools, "\\Common7\\Tools");
2674    path = p ? std::string(vscomntools, p) : vscomntools;
2675    return true;
2676  }
2677  return false;
2678}
2679
2680#endif // _MSC_VER
2681
2682void Windows::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2683                                        ArgStringList &CC1Args) const {
2684  if (DriverArgs.hasArg(options::OPT_nostdinc))
2685    return;
2686
2687  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2688    // Ignore the sysroot, we *always* look for clang headers relative to
2689    // supplied path.
2690    llvm::sys::Path P(getDriver().ResourceDir);
2691    P.appendComponent("include");
2692    CC1Args.push_back("-internal-nosysroot-isystem");
2693    CC1Args.push_back(DriverArgs.MakeArgString(P.str()));
2694  }
2695
2696  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2697    return;
2698
2699  std::string VSDir;
2700  std::string WindowsSDKDir;
2701
2702#ifdef _MSC_VER
2703  // When built with access to the proper Windows APIs, try to actually find
2704  // the correct include paths first.
2705  if (getVisualStudioDir(VSDir)) {
2706    addSystemInclude(DriverArgs, CC1Args, VSDir + "\\VC\\include");
2707    if (getWindowsSDKDir(WindowsSDKDir))
2708      addSystemInclude(DriverArgs, CC1Args, WindowsSDKDir + "\\include");
2709    else
2710      addSystemInclude(DriverArgs, CC1Args,
2711                       VSDir + "\\VC\\PlatformSDK\\Include");
2712    return;
2713  }
2714#endif // _MSC_VER
2715
2716  // As a fallback, select default install paths.
2717  const StringRef Paths[] = {
2718    "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
2719    "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
2720    "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
2721    "C:/Program Files/Microsoft Visual Studio 8/VC/include",
2722    "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
2723  };
2724  addSystemIncludes(DriverArgs, CC1Args, Paths);
2725}
2726
2727void Windows::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2728                                           ArgStringList &CC1Args) const {
2729  // FIXME: There should probably be logic here to find libc++ on Windows.
2730}
2731