1 //===--- ToolChains.cpp - ToolChain Implementations -----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "ToolChains.h"
12 #include "clang/Driver/Arg.h"
13 #include "clang/Driver/ArgList.h"
14 #include "clang/Driver/Compilation.h"
15 #include "clang/Driver/Driver.h"
16 #include "clang/Driver/DriverDiagnostic.h"
17 #include "clang/Driver/OptTable.h"
18 #include "clang/Driver/Option.h"
19 #include "clang/Driver/Options.h"
20 #include "clang/Basic/ObjCRuntime.h"
21 #include "clang/Basic/Version.h"
23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/ADT/StringSwitch.h"
26 #include "llvm/ADT/STLExtras.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/FileSystem.h"
29 #include "llvm/Support/MemoryBuffer.h"
30 #include "llvm/Support/raw_ostream.h"
31 #include "llvm/Support/Path.h"
32 #include "llvm/Support/system_error.h"
34 #include <cstdlib> // ::getenv
36 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
38 using namespace clang::driver;
39 using namespace clang::driver::toolchains;
40 using namespace clang;
42 /// Darwin - Darwin tool chain for i386 and x86_64.
44 Darwin::Darwin(const Driver &D, const llvm::Triple& Triple)
45 : ToolChain(D, Triple), TargetInitialized(false)
47 // Compute the initial Darwin version from the triple
48 unsigned Major, Minor, Micro;
49 if (!Triple.getMacOSXVersion(Major, Minor, Micro))
50 getDriver().Diag(diag::err_drv_invalid_darwin_version) <<
52 llvm::raw_string_ostream(MacosxVersionMin)
53 << Major << '.' << Minor << '.' << Micro;
55 // FIXME: DarwinVersion is only used to find GCC's libexec directory.
56 // It should be removed when we stop supporting that.
57 DarwinVersion[0] = Minor + 4;
58 DarwinVersion[1] = Micro;
61 // Compute the initial iOS version from the triple
62 Triple.getiOSVersion(Major, Minor, Micro);
63 llvm::raw_string_ostream(iOSVersionMin)
64 << Major << '.' << Minor << '.' << Micro;
67 types::ID Darwin::LookupTypeForExtension(const char *Ext) const {
68 types::ID Ty = types::lookupTypeForExtension(Ext);
70 // Darwin always preprocesses assembly files (unless -x is used explicitly).
71 if (Ty == types::TY_PP_Asm)
77 bool Darwin::HasNativeLLVMSupport() const {
81 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
82 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
83 if (isTargetIPhoneOS()) {
84 return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
85 } else if (TargetSimulatorVersionFromDefines != VersionTuple()) {
86 return ObjCRuntime(ObjCRuntime::iOS, TargetSimulatorVersionFromDefines);
89 return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
91 return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
96 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
97 bool Darwin::hasBlocksRuntime() const {
98 if (isTargetIPhoneOS())
99 return !isIPhoneOSVersionLT(3, 2);
101 return !isMacosxVersionLT(10, 6);
104 static const char *GetArmArchForMArch(StringRef Value) {
105 return llvm::StringSwitch<const char*>(Value)
106 .Case("armv6k", "armv6")
107 .Case("armv5tej", "armv5")
108 .Case("xscale", "xscale")
109 .Case("armv4t", "armv4t")
110 .Case("armv7", "armv7")
111 .Cases("armv7a", "armv7-a", "armv7")
112 .Cases("armv7r", "armv7-r", "armv7")
113 .Cases("armv7m", "armv7-m", "armv7")
117 static const char *GetArmArchForMCpu(StringRef Value) {
118 return llvm::StringSwitch<const char *>(Value)
119 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "arm926ej-s","armv5")
120 .Cases("arm10e", "arm10tdmi", "armv5")
121 .Cases("arm1020t", "arm1020e", "arm1022e", "arm1026ej-s", "armv5")
122 .Case("xscale", "xscale")
123 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s",
124 "arm1176jzf-s", "cortex-m0", "armv6")
125 .Cases("cortex-a8", "cortex-r4", "cortex-m3", "cortex-a9", "armv7")
129 StringRef Darwin::getDarwinArchName(const ArgList &Args) const {
130 switch (getTriple().getArch()) {
132 return getArchName();
134 case llvm::Triple::thumb:
135 case llvm::Triple::arm: {
136 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
137 if (const char *Arch = GetArmArchForMArch(A->getValue(Args)))
140 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
141 if (const char *Arch = GetArmArchForMCpu(A->getValue(Args)))
150 // Free tool implementations.
151 for (llvm::DenseMap<unsigned, Tool*>::iterator
152 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
156 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
157 types::ID InputType) const {
158 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
160 // If the target isn't initialized (e.g., an unknown Darwin platform, return
161 // the default triple).
162 if (!isTargetInitialized())
163 return Triple.getTriple();
166 Str += isTargetIPhoneOS() ? "ios" : "macosx";
167 Str += getTargetVersion().getAsString();
168 Triple.setOSName(Str);
170 return Triple.getTriple();
173 void Generic_ELF::anchor() {}
175 Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA,
176 const ActionList &Inputs) const {
177 Action::ActionClass Key = JA.getKind();
178 bool useClang = false;
180 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) {
182 // Fallback to llvm-gcc for i386 kext compiles, we don't support that ABI.
183 if (!getDriver().shouldForceClangUse() &&
184 Inputs.size() == 1 &&
185 types::isCXX(Inputs[0]->getType()) &&
186 getTriple().isOSDarwin() &&
187 getTriple().getArch() == llvm::Triple::x86 &&
188 (C.getArgs().getLastArg(options::OPT_fapple_kext) ||
189 C.getArgs().getLastArg(options::OPT_mkernel)))
193 // FIXME: This seems like a hacky way to choose clang frontend.
195 Key = Action::AnalyzeJobClass;
197 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
198 options::OPT_no_integrated_as,
199 IsIntegratedAssemblerDefault());
201 Tool *&T = Tools[Key];
204 case Action::InputClass:
205 case Action::BindArchClass:
206 llvm_unreachable("Invalid tool kind.");
207 case Action::PreprocessJobClass:
208 T = new tools::darwin::Preprocess(*this); break;
209 case Action::AnalyzeJobClass:
210 case Action::MigrateJobClass:
211 T = new tools::Clang(*this); break;
212 case Action::PrecompileJobClass:
213 case Action::CompileJobClass:
214 T = new tools::darwin::Compile(*this); break;
215 case Action::AssembleJobClass: {
217 T = new tools::ClangAs(*this);
219 T = new tools::darwin::Assemble(*this);
222 case Action::LinkJobClass:
223 T = new tools::darwin::Link(*this); break;
224 case Action::LipoJobClass:
225 T = new tools::darwin::Lipo(*this); break;
226 case Action::DsymutilJobClass:
227 T = new tools::darwin::Dsymutil(*this); break;
228 case Action::VerifyJobClass:
229 T = new tools::darwin::VerifyDebug(*this); break;
237 DarwinClang::DarwinClang(const Driver &D, const llvm::Triple& Triple)
240 getProgramPaths().push_back(getDriver().getInstalledDir());
241 if (getDriver().getInstalledDir() != getDriver().Dir)
242 getProgramPaths().push_back(getDriver().Dir);
244 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
245 getProgramPaths().push_back(getDriver().getInstalledDir());
246 if (getDriver().getInstalledDir() != getDriver().Dir)
247 getProgramPaths().push_back(getDriver().Dir);
249 // For fallback, we need to know how to find the GCC cc1 executables, so we
250 // also add the GCC libexec paths. This is legacy code that can be removed
251 // once fallback is no longer useful.
252 AddGCCLibexecPath(DarwinVersion[0]);
253 AddGCCLibexecPath(DarwinVersion[0] - 2);
254 AddGCCLibexecPath(DarwinVersion[0] - 1);
255 AddGCCLibexecPath(DarwinVersion[0] + 1);
256 AddGCCLibexecPath(DarwinVersion[0] + 2);
259 void DarwinClang::AddGCCLibexecPath(unsigned darwinVersion) {
260 std::string ToolChainDir = "i686-apple-darwin";
261 ToolChainDir += llvm::utostr(darwinVersion);
262 ToolChainDir += "/4.2.1";
264 std::string Path = getDriver().Dir;
265 Path += "/../llvm-gcc-4.2/libexec/gcc/";
266 Path += ToolChainDir;
267 getProgramPaths().push_back(Path);
269 Path = "/usr/llvm-gcc-4.2/libexec/gcc/";
270 Path += ToolChainDir;
271 getProgramPaths().push_back(Path);
274 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
275 ArgStringList &CmdArgs) const {
277 CmdArgs.push_back("-force_load");
278 llvm::sys::Path P(getDriver().ClangExecutable);
279 P.eraseComponent(); // 'clang'
280 P.eraseComponent(); // 'bin'
281 P.appendComponent("lib");
282 P.appendComponent("arc");
283 P.appendComponent("libarclite_");
284 std::string s = P.str();
285 // Mash in the platform.
286 if (isTargetIOSSimulator())
287 s += "iphonesimulator";
288 else if (isTargetIPhoneOS())
290 // FIXME: Remove this once we depend fully on -mios-simulator-version-min.
291 else if (TargetSimulatorVersionFromDefines != VersionTuple())
292 s += "iphonesimulator";
297 CmdArgs.push_back(Args.MakeArgString(s));
300 void DarwinClang::AddLinkRuntimeLib(const ArgList &Args,
301 ArgStringList &CmdArgs,
302 const char *DarwinStaticLib) const {
303 llvm::sys::Path P(getDriver().ResourceDir);
304 P.appendComponent("lib");
305 P.appendComponent("darwin");
306 P.appendComponent(DarwinStaticLib);
308 // For now, allow missing resource libraries to support developers who may
309 // not have compiler-rt checked out or integrated into their build.
311 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
312 CmdArgs.push_back(Args.MakeArgString(P.str()));
315 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
316 ArgStringList &CmdArgs) const {
317 // Darwin only supports the compiler-rt based runtime libraries.
318 switch (GetRuntimeLibType(Args)) {
319 case ToolChain::RLT_CompilerRT:
322 getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
323 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue(Args) << "darwin";
327 // Darwin doesn't support real static executables, don't link any runtime
328 // libraries with -static.
329 if (Args.hasArg(options::OPT_static))
332 // Reject -static-libgcc for now, we can deal with this when and if someone
333 // cares. This is useful in situations where someone wants to statically link
334 // something like libstdc++, and needs its runtime support routines.
335 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
336 getDriver().Diag(diag::err_drv_unsupported_opt)
337 << A->getAsString(Args);
341 // If we are building profile support, link that library in.
342 if (Args.hasArg(options::OPT_fprofile_arcs) ||
343 Args.hasArg(options::OPT_fprofile_generate) ||
344 Args.hasArg(options::OPT_fcreate_profile) ||
345 Args.hasArg(options::OPT_coverage)) {
346 // Select the appropriate runtime library for the target.
347 if (isTargetIPhoneOS()) {
348 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_ios.a");
350 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_osx.a");
354 // Add ASAN runtime library, if required. Dynamic libraries and bundles
355 // should not be linked with the runtime library.
356 if (Args.hasFlag(options::OPT_faddress_sanitizer,
357 options::OPT_fno_address_sanitizer, false)) {
358 if (Args.hasArg(options::OPT_dynamiclib) ||
359 Args.hasArg(options::OPT_bundle)) return;
360 if (isTargetIPhoneOS()) {
361 getDriver().Diag(diag::err_drv_clang_unsupported_per_platform)
362 << "-faddress-sanitizer";
364 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.asan_osx.a");
366 // The ASAN runtime library requires C++ and CoreFoundation.
367 AddCXXStdlibLibArgs(Args, CmdArgs);
368 CmdArgs.push_back("-framework");
369 CmdArgs.push_back("CoreFoundation");
373 // Otherwise link libSystem, then the dynamic runtime library, and finally any
374 // target specific static runtime library.
375 CmdArgs.push_back("-lSystem");
377 // Select the dynamic runtime library and the target specific static library.
378 if (isTargetIPhoneOS()) {
379 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
380 // it never went into the SDK.
381 // Linking against libgcc_s.1 isn't needed for iOS 5.0+
382 if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator())
383 CmdArgs.push_back("-lgcc_s.1");
385 // We currently always need a static runtime library for iOS.
386 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
388 // The dynamic runtime library was merged with libSystem for 10.6 and
389 // beyond; only 10.4 and 10.5 need an additional runtime library.
390 if (isMacosxVersionLT(10, 5))
391 CmdArgs.push_back("-lgcc_s.10.4");
392 else if (isMacosxVersionLT(10, 6))
393 CmdArgs.push_back("-lgcc_s.10.5");
395 // For OS X, we thought we would only need a static runtime library when
396 // targeting 10.4, to provide versions of the static functions which were
397 // omitted from 10.4.dylib.
399 // Unfortunately, that turned out to not be true, because Darwin system
400 // headers can still use eprintf on i386, and it is not exported from
401 // libSystem. Therefore, we still must provide a runtime library just for
402 // the tiny tiny handful of projects that *might* use that symbol.
403 if (isMacosxVersionLT(10, 5)) {
404 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
406 if (getTriple().getArch() == llvm::Triple::x86)
407 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.eprintf.a");
408 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
413 static inline StringRef SimulatorVersionDefineName() {
414 return "__IPHONE_OS_VERSION_MIN_REQUIRED";
417 /// \brief Parse the simulator version define:
418 /// __IPHONE_OS_VERSION_MIN_REQUIRED=([0-9])([0-9][0-9])([0-9][0-9])
419 // and return the grouped values as integers, e.g:
420 // __IPHONE_OS_VERSION_MIN_REQUIRED=40201
421 // will return Major=4, Minor=2, Micro=1.
422 static bool GetVersionFromSimulatorDefine(StringRef define,
423 unsigned &Major, unsigned &Minor,
425 assert(define.startswith(SimulatorVersionDefineName()));
426 StringRef name, version;
427 llvm::tie(name, version) = define.split('=');
430 std::string verstr = version.str();
432 unsigned num = (unsigned) strtol(verstr.c_str(), &end, 10);
442 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
443 const OptTable &Opts = getDriver().getOpts();
445 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
446 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
447 Arg *iOSSimVersion = Args.getLastArg(
448 options::OPT_mios_simulator_version_min_EQ);
450 // FIXME: HACK! When compiling for the simulator we don't get a
451 // '-miphoneos-version-min' to help us know whether there is an ARC runtime
452 // or not; try to parse a __IPHONE_OS_VERSION_MIN_REQUIRED
453 // define passed in command-line.
454 if (!iOSVersion && !iOSSimVersion) {
455 for (arg_iterator it = Args.filtered_begin(options::OPT_D),
456 ie = Args.filtered_end(); it != ie; ++it) {
457 StringRef define = (*it)->getValue(Args);
458 if (define.startswith(SimulatorVersionDefineName())) {
459 unsigned Major = 0, Minor = 0, Micro = 0;
460 if (GetVersionFromSimulatorDefine(define, Major, Minor, Micro) &&
461 Major < 10 && Minor < 100 && Micro < 100) {
462 TargetSimulatorVersionFromDefines = VersionTuple(Major, Minor, Micro);
464 // When using the define to indicate the simulator, we force
465 // 10.6 macosx target.
466 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
467 OSXVersion = Args.MakeJoinedArg(0, O, "10.6");
468 Args.append(OSXVersion);
474 if (OSXVersion && (iOSVersion || iOSSimVersion)) {
475 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
476 << OSXVersion->getAsString(Args)
477 << (iOSVersion ? iOSVersion : iOSSimVersion)->getAsString(Args);
478 iOSVersion = iOSSimVersion = 0;
479 } else if (iOSVersion && iOSSimVersion) {
480 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
481 << iOSVersion->getAsString(Args)
482 << iOSSimVersion->getAsString(Args);
484 } else if (!OSXVersion && !iOSVersion && !iOSSimVersion) {
485 // If no deployment target was specified on the command line, check for
486 // environment defines.
489 StringRef iOSSimTarget;
490 if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
492 if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
494 if (char *env = ::getenv("IOS_SIMULATOR_DEPLOYMENT_TARGET"))
497 // If no '-miphoneos-version-min' specified on the command line and
498 // IPHONEOS_DEPLOYMENT_TARGET is not defined, see if we can set the default
499 // based on -isysroot.
500 if (iOSTarget.empty()) {
501 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
502 StringRef first, second;
503 StringRef isysroot = A->getValue(Args);
504 llvm::tie(first, second) = isysroot.split(StringRef("SDKs/iPhoneOS"));
506 iOSTarget = second.substr(0,3);
510 // If no OSX or iOS target has been specified and we're compiling for armv7,
511 // go ahead as assume we're targeting iOS.
512 if (OSXTarget.empty() && iOSTarget.empty() &&
513 getDarwinArchName(Args) == "armv7")
514 iOSTarget = iOSVersionMin;
516 // Handle conflicting deployment targets
518 // FIXME: Don't hardcode default here.
520 // Do not allow conflicts with the iOS simulator target.
521 if (!iOSSimTarget.empty() && (!OSXTarget.empty() || !iOSTarget.empty())) {
522 getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
523 << "IOS_SIMULATOR_DEPLOYMENT_TARGET"
524 << (!OSXTarget.empty() ? "MACOSX_DEPLOYMENT_TARGET" :
525 "IPHONEOS_DEPLOYMENT_TARGET");
528 // Allow conflicts among OSX and iOS for historical reasons, but choose the
530 if (!OSXTarget.empty() && !iOSTarget.empty()) {
531 if (getTriple().getArch() == llvm::Triple::arm ||
532 getTriple().getArch() == llvm::Triple::thumb)
538 if (!OSXTarget.empty()) {
539 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
540 OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget);
541 Args.append(OSXVersion);
542 } else if (!iOSTarget.empty()) {
543 const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
544 iOSVersion = Args.MakeJoinedArg(0, O, iOSTarget);
545 Args.append(iOSVersion);
546 } else if (!iOSSimTarget.empty()) {
547 const Option *O = Opts.getOption(
548 options::OPT_mios_simulator_version_min_EQ);
549 iOSSimVersion = Args.MakeJoinedArg(0, O, iOSSimTarget);
550 Args.append(iOSSimVersion);
552 // Otherwise, assume we are targeting OS X.
553 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
554 OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin);
555 Args.append(OSXVersion);
559 // Reject invalid architecture combinations.
560 if (iOSSimVersion && (getTriple().getArch() != llvm::Triple::x86 &&
561 getTriple().getArch() != llvm::Triple::x86_64)) {
562 getDriver().Diag(diag::err_drv_invalid_arch_for_deployment_target)
563 << getTriple().getArchName() << iOSSimVersion->getAsString(Args);
566 // Set the tool chain target information.
567 unsigned Major, Minor, Micro;
570 assert((!iOSVersion && !iOSSimVersion) && "Unknown target platform!");
571 if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor,
572 Micro, HadExtra) || HadExtra ||
573 Major != 10 || Minor >= 100 || Micro >= 100)
574 getDriver().Diag(diag::err_drv_invalid_version_number)
575 << OSXVersion->getAsString(Args);
577 const Arg *Version = iOSVersion ? iOSVersion : iOSSimVersion;
578 assert(Version && "Unknown target platform!");
579 if (!Driver::GetReleaseVersion(Version->getValue(Args), Major, Minor,
580 Micro, HadExtra) || HadExtra ||
581 Major >= 10 || Minor >= 100 || Micro >= 100)
582 getDriver().Diag(diag::err_drv_invalid_version_number)
583 << Version->getAsString(Args);
586 bool IsIOSSim = bool(iOSSimVersion);
588 // In GCC, the simulator historically was treated as being OS X in some
589 // contexts, like determining the link logic, despite generally being called
590 // with an iOS deployment target. For compatibility, we detect the
591 // simulator as iOS + x86, and treat it differently in a few contexts.
592 if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
593 getTriple().getArch() == llvm::Triple::x86_64))
596 setTarget(/*IsIPhoneOS=*/ !OSXVersion, Major, Minor, Micro, IsIOSSim);
599 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
600 ArgStringList &CmdArgs) const {
601 CXXStdlibType Type = GetCXXStdlibType(Args);
604 case ToolChain::CST_Libcxx:
605 CmdArgs.push_back("-lc++");
608 case ToolChain::CST_Libstdcxx: {
609 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
610 // it was previously found in the gcc lib dir. However, for all the Darwin
611 // platforms we care about it was -lstdc++.6, so we search for that
612 // explicitly if we can't see an obvious -lstdc++ candidate.
614 // Check in the sysroot first.
616 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
617 llvm::sys::Path P(A->getValue(Args));
618 P.appendComponent("usr");
619 P.appendComponent("lib");
620 P.appendComponent("libstdc++.dylib");
622 if (llvm::sys::fs::exists(P.str(), Exists) || !Exists) {
624 P.appendComponent("libstdc++.6.dylib");
625 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
626 CmdArgs.push_back(Args.MakeArgString(P.str()));
632 // Otherwise, look in the root.
633 // FIXME: This should be removed someday when we don't have to care about
634 // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
635 if ((llvm::sys::fs::exists("/usr/lib/libstdc++.dylib", Exists) || !Exists)&&
636 (!llvm::sys::fs::exists("/usr/lib/libstdc++.6.dylib", Exists) && Exists)){
637 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
641 // Otherwise, let the linker search.
642 CmdArgs.push_back("-lstdc++");
648 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
649 ArgStringList &CmdArgs) const {
651 // For Darwin platforms, use the compiler-rt-based support library
652 // instead of the gcc-provided one (which is also incidentally
653 // only present in the gcc lib dir, which makes it hard to find).
655 llvm::sys::Path P(getDriver().ResourceDir);
656 P.appendComponent("lib");
657 P.appendComponent("darwin");
658 P.appendComponent("libclang_rt.cc_kext.a");
660 // For now, allow missing resource libraries to support developers who may
661 // not have compiler-rt checked out or integrated into their build.
663 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
664 CmdArgs.push_back(Args.MakeArgString(P.str()));
667 DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
668 const char *BoundArch) const {
669 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
670 const OptTable &Opts = getDriver().getOpts();
672 // FIXME: We really want to get out of the tool chain level argument
673 // translation business, as it makes the driver functionality much
674 // more opaque. For now, we follow gcc closely solely for the
675 // purpose of easily achieving feature parity & testability. Once we
676 // have something that works, we should reevaluate each translation
677 // and try to push it down into tool specific logic.
679 for (ArgList::const_iterator it = Args.begin(),
680 ie = Args.end(); it != ie; ++it) {
683 if (A->getOption().matches(options::OPT_Xarch__)) {
684 // Skip this argument unless the architecture matches either the toolchain
685 // triple arch, or the arch being bound.
687 // FIXME: Canonicalize name.
688 StringRef XarchArch = A->getValue(Args, 0);
689 if (!(XarchArch == getArchName() ||
690 (BoundArch && XarchArch == BoundArch)))
693 Arg *OriginalArg = A;
694 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1));
695 unsigned Prev = Index;
696 Arg *XarchArg = Opts.ParseOneArg(Args, Index);
698 // If the argument parsing failed or more than one argument was
699 // consumed, the -Xarch_ argument's parameter tried to consume
700 // extra arguments. Emit an error and ignore.
702 // We also want to disallow any options which would alter the
703 // driver behavior; that isn't going to work in our model. We
704 // use isDriverOption() as an approximation, although things
705 // like -O4 are going to slip through.
706 if (!XarchArg || Index > Prev + 1) {
707 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
708 << A->getAsString(Args);
710 } else if (XarchArg->getOption().isDriverOption()) {
711 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
712 << A->getAsString(Args);
716 XarchArg->setBaseArg(A);
719 DAL->AddSynthesizedArg(A);
721 // Linker input arguments require custom handling. The problem is that we
722 // have already constructed the phase actions, so we can not treat them as
723 // "input arguments".
724 if (A->getOption().isLinkerInput()) {
725 // Convert the argument into individual Zlinker_input_args.
726 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
727 DAL->AddSeparateArg(OriginalArg,
728 Opts.getOption(options::OPT_Zlinker_input),
729 A->getValue(Args, i));
736 // Sob. These is strictly gcc compatible for the time being. Apple
737 // gcc translates options twice, which means that self-expanding
738 // options add duplicates.
739 switch ((options::ID) A->getOption().getID()) {
744 case options::OPT_mkernel:
745 case options::OPT_fapple_kext:
747 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
750 case options::OPT_dependency_file:
751 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF),
755 case options::OPT_gfull:
756 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
758 Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
761 case options::OPT_gused:
762 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
764 Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
767 case options::OPT_shared:
768 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
771 case options::OPT_fconstant_cfstrings:
772 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
775 case options::OPT_fno_constant_cfstrings:
776 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
779 case options::OPT_Wnonportable_cfstrings:
781 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
784 case options::OPT_Wno_nonportable_cfstrings:
786 Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
789 case options::OPT_fpascal_strings:
790 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
793 case options::OPT_fno_pascal_strings:
794 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
799 if (getTriple().getArch() == llvm::Triple::x86 ||
800 getTriple().getArch() == llvm::Triple::x86_64)
801 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
802 DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2");
804 // Add the arch options based on the particular spelling of -arch, to match
805 // how the driver driver works.
807 StringRef Name = BoundArch;
808 const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ);
809 const Option *MArch = Opts.getOption(options::OPT_march_EQ);
811 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
812 // which defines the list of which architectures we accept.
815 else if (Name == "ppc601")
816 DAL->AddJoinedArg(0, MCpu, "601");
817 else if (Name == "ppc603")
818 DAL->AddJoinedArg(0, MCpu, "603");
819 else if (Name == "ppc604")
820 DAL->AddJoinedArg(0, MCpu, "604");
821 else if (Name == "ppc604e")
822 DAL->AddJoinedArg(0, MCpu, "604e");
823 else if (Name == "ppc750")
824 DAL->AddJoinedArg(0, MCpu, "750");
825 else if (Name == "ppc7400")
826 DAL->AddJoinedArg(0, MCpu, "7400");
827 else if (Name == "ppc7450")
828 DAL->AddJoinedArg(0, MCpu, "7450");
829 else if (Name == "ppc970")
830 DAL->AddJoinedArg(0, MCpu, "970");
832 else if (Name == "ppc64")
833 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
835 else if (Name == "i386")
837 else if (Name == "i486")
838 DAL->AddJoinedArg(0, MArch, "i486");
839 else if (Name == "i586")
840 DAL->AddJoinedArg(0, MArch, "i586");
841 else if (Name == "i686")
842 DAL->AddJoinedArg(0, MArch, "i686");
843 else if (Name == "pentium")
844 DAL->AddJoinedArg(0, MArch, "pentium");
845 else if (Name == "pentium2")
846 DAL->AddJoinedArg(0, MArch, "pentium2");
847 else if (Name == "pentpro")
848 DAL->AddJoinedArg(0, MArch, "pentiumpro");
849 else if (Name == "pentIIm3")
850 DAL->AddJoinedArg(0, MArch, "pentium2");
852 else if (Name == "x86_64")
853 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64));
855 else if (Name == "arm")
856 DAL->AddJoinedArg(0, MArch, "armv4t");
857 else if (Name == "armv4t")
858 DAL->AddJoinedArg(0, MArch, "armv4t");
859 else if (Name == "armv5")
860 DAL->AddJoinedArg(0, MArch, "armv5tej");
861 else if (Name == "xscale")
862 DAL->AddJoinedArg(0, MArch, "xscale");
863 else if (Name == "armv6")
864 DAL->AddJoinedArg(0, MArch, "armv6k");
865 else if (Name == "armv7")
866 DAL->AddJoinedArg(0, MArch, "armv7a");
869 llvm_unreachable("invalid Darwin arch");
872 // Add an explicit version min argument for the deployment target. We do this
873 // after argument translation because -Xarch_ arguments may add a version min
876 AddDeploymentTarget(*DAL);
878 // Validate the C++ standard library choice.
879 CXXStdlibType Type = GetCXXStdlibType(*DAL);
880 if (Type == ToolChain::CST_Libcxx) {
881 // Check whether the target provides libc++.
884 // Complain about targetting iOS < 5.0 in any way.
885 if (TargetSimulatorVersionFromDefines != VersionTuple()) {
886 if (TargetSimulatorVersionFromDefines < VersionTuple(5, 0))
888 } else if (isTargetIPhoneOS()) {
889 if (isIPhoneOSVersionLT(5, 0))
893 if (where != StringRef()) {
894 getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment)
902 bool Darwin::IsUnwindTablesDefault() const {
903 // FIXME: Gross; we should probably have some separate target
904 // definition, possibly even reusing the one in clang.
905 return getArchName() == "x86_64";
908 bool Darwin::UseDwarfDebugFlags() const {
909 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
914 bool Darwin::UseSjLjExceptions() const {
915 // Darwin uses SjLj exceptions on ARM.
916 return (getTriple().getArch() == llvm::Triple::arm ||
917 getTriple().getArch() == llvm::Triple::thumb);
920 const char *Darwin::GetDefaultRelocationModel() const {
924 const char *Darwin::GetForcedPicModel() const {
925 if (getArchName() == "x86_64")
930 bool Darwin::SupportsProfiling() const {
931 // Profiling instrumentation is only supported on x86.
932 return getArchName() == "i386" || getArchName() == "x86_64";
935 bool Darwin::SupportsObjCGC() const {
936 // Garbage collection is supported everywhere except on iPhone OS.
937 return !isTargetIPhoneOS();
940 bool Darwin::SupportsObjCARC() const {
941 return isTargetIPhoneOS() || !isMacosxVersionLT(10, 6);
945 Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args,
946 types::ID InputType) const {
947 return ComputeLLVMTriple(Args, InputType);
950 /// Generic_GCC - A tool chain using the 'gcc' command to perform
951 /// all subcommands; this relies on gcc translating the majority of
952 /// command line options.
954 /// \brief Parse a GCCVersion object out of a string of text.
956 /// This is the primary means of forming GCCVersion objects.
958 Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) {
959 const GCCVersion BadVersion = { VersionText.str(), -1, -1, -1, "" };
960 std::pair<StringRef, StringRef> First = VersionText.split('.');
961 std::pair<StringRef, StringRef> Second = First.second.split('.');
963 GCCVersion GoodVersion = { VersionText.str(), -1, -1, -1, "" };
964 if (First.first.getAsInteger(10, GoodVersion.Major) ||
965 GoodVersion.Major < 0)
967 if (Second.first.getAsInteger(10, GoodVersion.Minor) ||
968 GoodVersion.Minor < 0)
971 // First look for a number prefix and parse that if present. Otherwise just
972 // stash the entire patch string in the suffix, and leave the number
973 // unspecified. This covers versions strings such as:
979 // And retains any patch number it finds.
980 StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
981 if (!PatchText.empty()) {
982 if (unsigned EndNumber = PatchText.find_first_not_of("0123456789")) {
983 // Try to parse the number and any suffix.
984 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
985 GoodVersion.Patch < 0)
987 GoodVersion.PatchSuffix = PatchText.substr(EndNumber).str();
994 /// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering.
995 bool Generic_GCC::GCCVersion::operator<(const GCCVersion &RHS) const {
996 if (Major < RHS.Major) return true; if (Major > RHS.Major) return false;
997 if (Minor < RHS.Minor) return true; if (Minor > RHS.Minor) return false;
999 // Note that we rank versions with *no* patch specified is better than ones
1000 // hard-coding a patch version. Thus if the RHS has no patch, it always
1001 // wins, and the LHS only wins if it has no patch and the RHS does have
1003 if (RHS.Patch == -1) return true; if (Patch == -1) return false;
1004 if (Patch < RHS.Patch) return true; if (Patch > RHS.Patch) return false;
1005 if (PatchSuffix == RHS.PatchSuffix) return false;
1007 // Finally, between completely tied version numbers, the version with the
1008 // suffix loses as we prefer full releases.
1009 if (RHS.PatchSuffix.empty()) return true;
1013 static StringRef getGCCToolchainDir(const ArgList &Args) {
1014 const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
1016 return A->getValue(Args);
1017 return GCC_INSTALL_PREFIX;
1020 /// \brief Construct a GCCInstallationDetector from the driver.
1022 /// This performs all of the autodetection and sets up the various paths.
1023 /// Once constructed, a GCCInstallationDetector is essentially immutable.
1025 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
1026 /// should instead pull the target out of the driver. This is currently
1027 /// necessary because the driver doesn't store the final version of the target
1029 Generic_GCC::GCCInstallationDetector::GCCInstallationDetector(
1031 const llvm::Triple &TargetTriple,
1032 const ArgList &Args)
1034 llvm::Triple MultiarchTriple
1035 = TargetTriple.isArch32Bit() ? TargetTriple.get64BitArchVariant()
1036 : TargetTriple.get32BitArchVariant();
1037 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1038 // The library directories which may contain GCC installations.
1039 SmallVector<StringRef, 4> CandidateLibDirs, CandidateMultiarchLibDirs;
1040 // The compatible GCC triples for this particular architecture.
1041 SmallVector<StringRef, 10> CandidateTripleAliases;
1042 SmallVector<StringRef, 10> CandidateMultiarchTripleAliases;
1043 CollectLibDirsAndTriples(TargetTriple, MultiarchTriple, CandidateLibDirs,
1044 CandidateTripleAliases,
1045 CandidateMultiarchLibDirs,
1046 CandidateMultiarchTripleAliases);
1048 // Compute the set of prefixes for our search.
1049 SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1050 D.PrefixDirs.end());
1052 StringRef GCCToolchainDir = getGCCToolchainDir(Args);
1053 if (GCCToolchainDir != "") {
1054 if (GCCToolchainDir.back() == '/')
1055 GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1057 Prefixes.push_back(GCCToolchainDir);
1059 Prefixes.push_back(D.SysRoot);
1060 Prefixes.push_back(D.SysRoot + "/usr");
1061 Prefixes.push_back(D.InstalledDir + "/..");
1064 // Loop over the various components which exist and select the best GCC
1065 // installation available. GCC installs are ranked by version number.
1066 Version = GCCVersion::Parse("0.0.0");
1067 for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) {
1068 if (!llvm::sys::fs::exists(Prefixes[i]))
1070 for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) {
1071 const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str();
1072 if (!llvm::sys::fs::exists(LibDir))
1074 for (unsigned k = 0, ke = CandidateTripleAliases.size(); k < ke; ++k)
1075 ScanLibDirForGCCTriple(TargetArch, LibDir, CandidateTripleAliases[k]);
1077 for (unsigned j = 0, je = CandidateMultiarchLibDirs.size(); j < je; ++j) {
1078 const std::string LibDir
1079 = Prefixes[i] + CandidateMultiarchLibDirs[j].str();
1080 if (!llvm::sys::fs::exists(LibDir))
1082 for (unsigned k = 0, ke = CandidateMultiarchTripleAliases.size(); k < ke;
1084 ScanLibDirForGCCTriple(TargetArch, LibDir,
1085 CandidateMultiarchTripleAliases[k],
1086 /*NeedsMultiarchSuffix=*/true);
1091 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1092 const llvm::Triple &TargetTriple,
1093 const llvm::Triple &MultiarchTriple,
1094 SmallVectorImpl<StringRef> &LibDirs,
1095 SmallVectorImpl<StringRef> &TripleAliases,
1096 SmallVectorImpl<StringRef> &MultiarchLibDirs,
1097 SmallVectorImpl<StringRef> &MultiarchTripleAliases) {
1098 // Declare a bunch of static data sets that we'll select between below. These
1099 // are specifically designed to always refer to string literals to avoid any
1100 // lifetime or initialization issues.
1101 static const char *const ARMLibDirs[] = { "/lib" };
1102 static const char *const ARMTriples[] = {
1103 "arm-linux-gnueabi",
1104 "arm-linux-androideabi"
1106 static const char *const ARMHFTriples[] = {
1107 "arm-linux-gnueabihf",
1110 static const char *const X86_64LibDirs[] = { "/lib64", "/lib" };
1111 static const char *const X86_64Triples[] = {
1113 "x86_64-unknown-linux-gnu",
1114 "x86_64-pc-linux-gnu",
1115 "x86_64-redhat-linux6E",
1116 "x86_64-redhat-linux",
1117 "x86_64-suse-linux",
1118 "x86_64-manbo-linux-gnu",
1120 "x86_64-slackware-linux"
1122 static const char *const X86LibDirs[] = { "/lib32", "/lib" };
1123 static const char *const X86Triples[] = {
1125 "i686-pc-linux-gnu",
1128 "i686-redhat-linux",
1129 "i586-redhat-linux",
1130 "i386-redhat-linux",
1132 "i486-slackware-linux",
1133 "i686-montavista-linux"
1136 static const char *const MIPSLibDirs[] = { "/lib" };
1137 static const char *const MIPSTriples[] = { "mips-linux-gnu" };
1138 static const char *const MIPSELLibDirs[] = { "/lib" };
1139 static const char *const MIPSELTriples[] = { "mipsel-linux-gnu" };
1141 static const char *const MIPS64LibDirs[] = { "/lib64", "/lib" };
1142 static const char *const MIPS64Triples[] = { "mips64-linux-gnu" };
1143 static const char *const MIPS64ELLibDirs[] = { "/lib64", "/lib" };
1144 static const char *const MIPS64ELTriples[] = { "mips64el-linux-gnu" };
1146 static const char *const PPCLibDirs[] = { "/lib32", "/lib" };
1147 static const char *const PPCTriples[] = {
1148 "powerpc-linux-gnu",
1149 "powerpc-unknown-linux-gnu",
1150 "powerpc-suse-linux",
1151 "powerpc-montavista-linuxspe"
1153 static const char *const PPC64LibDirs[] = { "/lib64", "/lib" };
1154 static const char *const PPC64Triples[] = {
1155 "powerpc64-linux-gnu",
1156 "powerpc64-unknown-linux-gnu",
1157 "powerpc64-suse-linux",
1158 "ppc64-redhat-linux"
1161 switch (TargetTriple.getArch()) {
1162 case llvm::Triple::arm:
1163 case llvm::Triple::thumb:
1164 LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs));
1165 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1166 TripleAliases.append(
1167 ARMHFTriples, ARMHFTriples + llvm::array_lengthof(ARMHFTriples));
1169 TripleAliases.append(
1170 ARMTriples, ARMTriples + llvm::array_lengthof(ARMTriples));
1173 case llvm::Triple::x86_64:
1175 X86_64LibDirs, X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1176 TripleAliases.append(
1177 X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples));
1178 MultiarchLibDirs.append(
1179 X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1180 MultiarchTripleAliases.append(
1181 X86Triples, X86Triples + llvm::array_lengthof(X86Triples));
1183 case llvm::Triple::x86:
1184 LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs));
1185 TripleAliases.append(
1186 X86Triples, X86Triples + llvm::array_lengthof(X86Triples));
1187 MultiarchLibDirs.append(
1188 X86_64LibDirs, X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs));
1189 MultiarchTripleAliases.append(
1190 X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples));
1192 case llvm::Triple::mips:
1194 MIPSLibDirs, MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1195 TripleAliases.append(
1196 MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples));
1197 MultiarchLibDirs.append(
1198 MIPS64LibDirs, MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1199 MultiarchTripleAliases.append(
1200 MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1202 case llvm::Triple::mipsel:
1204 MIPSELLibDirs, MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1205 TripleAliases.append(
1206 MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1207 MultiarchLibDirs.append(
1208 MIPS64ELLibDirs, MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1209 MultiarchTripleAliases.append(
1210 MIPS64ELTriples, MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1212 case llvm::Triple::mips64:
1214 MIPS64LibDirs, MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs));
1215 TripleAliases.append(
1216 MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples));
1217 MultiarchLibDirs.append(
1218 MIPSLibDirs, MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs));
1219 MultiarchTripleAliases.append(
1220 MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples));
1222 case llvm::Triple::mips64el:
1224 MIPS64ELLibDirs, MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs));
1225 TripleAliases.append(
1226 MIPS64ELTriples, MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples));
1227 MultiarchLibDirs.append(
1228 MIPSELLibDirs, MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs));
1229 MultiarchTripleAliases.append(
1230 MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples));
1232 case llvm::Triple::ppc:
1233 LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1234 TripleAliases.append(
1235 PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples));
1236 MultiarchLibDirs.append(
1237 PPC64LibDirs, PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1238 MultiarchTripleAliases.append(
1239 PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples));
1241 case llvm::Triple::ppc64:
1243 PPC64LibDirs, PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs));
1244 TripleAliases.append(
1245 PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples));
1246 MultiarchLibDirs.append(
1247 PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs));
1248 MultiarchTripleAliases.append(
1249 PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples));
1253 // By default, just rely on the standard lib directories and the original
1258 // Always append the drivers target triple to the end, in case it doesn't
1259 // match any of our aliases.
1260 TripleAliases.push_back(TargetTriple.str());
1262 // Also include the multiarch variant if it's different.
1263 if (TargetTriple.str() != MultiarchTriple.str())
1264 MultiarchTripleAliases.push_back(MultiarchTriple.str());
1267 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
1268 llvm::Triple::ArchType TargetArch, const std::string &LibDir,
1269 StringRef CandidateTriple, bool NeedsMultiarchSuffix) {
1270 // There are various different suffixes involving the triple we
1271 // check for. We also record what is necessary to walk from each back
1272 // up to the lib directory.
1273 const std::string LibSuffixes[] = {
1274 "/gcc/" + CandidateTriple.str(),
1275 "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
1277 // Ubuntu has a strange mis-matched pair of triples that this happens to
1279 // FIXME: It may be worthwhile to generalize this and look for a second
1281 "/i386-linux-gnu/gcc/" + CandidateTriple.str()
1283 const std::string InstallSuffixes[] = {
1288 // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
1289 const unsigned NumLibSuffixes = (llvm::array_lengthof(LibSuffixes) -
1290 (TargetArch != llvm::Triple::x86));
1291 for (unsigned i = 0; i < NumLibSuffixes; ++i) {
1292 StringRef LibSuffix = LibSuffixes[i];
1293 llvm::error_code EC;
1294 for (llvm::sys::fs::directory_iterator LI(LibDir + LibSuffix, EC), LE;
1295 !EC && LI != LE; LI = LI.increment(EC)) {
1296 StringRef VersionText = llvm::sys::path::filename(LI->path());
1297 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1298 static const GCCVersion MinVersion = { "4.1.1", 4, 1, 1, "" };
1299 if (CandidateVersion < MinVersion)
1301 if (CandidateVersion <= Version)
1304 // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1305 // in what would normally be GCCInstallPath and put the 64-bit
1306 // libs in a subdirectory named 64. The simple logic we follow is that
1307 // *if* there is a subdirectory of the right name with crtbegin.o in it,
1308 // we use that. If not, and if not a multiarch triple, we look for
1309 // crtbegin.o without the subdirectory.
1310 StringRef MultiarchSuffix
1311 = (TargetArch == llvm::Triple::x86_64 ||
1312 TargetArch == llvm::Triple::ppc64 ||
1313 TargetArch == llvm::Triple::mips64 ||
1314 TargetArch == llvm::Triple::mips64el) ? "/64" : "/32";
1315 if (llvm::sys::fs::exists(LI->path() + MultiarchSuffix + "/crtbegin.o")) {
1316 GCCMultiarchSuffix = MultiarchSuffix.str();
1318 if (NeedsMultiarchSuffix ||
1319 !llvm::sys::fs::exists(LI->path() + "/crtbegin.o"))
1321 GCCMultiarchSuffix.clear();
1324 Version = CandidateVersion;
1325 GCCTriple.setTriple(CandidateTriple);
1326 // FIXME: We hack together the directory name here instead of
1327 // using LI to ensure stable path separators across Windows and
1329 GCCInstallPath = LibDir + LibSuffixes[i] + "/" + VersionText.str();
1330 GCCParentLibPath = GCCInstallPath + InstallSuffixes[i];
1336 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple& Triple,
1337 const ArgList &Args)
1338 : ToolChain(D, Triple), GCCInstallation(getDriver(), Triple, Args) {
1339 getProgramPaths().push_back(getDriver().getInstalledDir());
1340 if (getDriver().getInstalledDir() != getDriver().Dir)
1341 getProgramPaths().push_back(getDriver().Dir);
1344 Generic_GCC::~Generic_GCC() {
1345 // Free tool implementations.
1346 for (llvm::DenseMap<unsigned, Tool*>::iterator
1347 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
1351 Tool &Generic_GCC::SelectTool(const Compilation &C,
1352 const JobAction &JA,
1353 const ActionList &Inputs) const {
1354 Action::ActionClass Key;
1355 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1356 Key = Action::AnalyzeJobClass;
1360 Tool *&T = Tools[Key];
1363 case Action::InputClass:
1364 case Action::BindArchClass:
1365 llvm_unreachable("Invalid tool kind.");
1366 case Action::PreprocessJobClass:
1367 T = new tools::gcc::Preprocess(*this); break;
1368 case Action::PrecompileJobClass:
1369 T = new tools::gcc::Precompile(*this); break;
1370 case Action::AnalyzeJobClass:
1371 case Action::MigrateJobClass:
1372 T = new tools::Clang(*this); break;
1373 case Action::CompileJobClass:
1374 T = new tools::gcc::Compile(*this); break;
1375 case Action::AssembleJobClass:
1376 T = new tools::gcc::Assemble(*this); break;
1377 case Action::LinkJobClass:
1378 T = new tools::gcc::Link(*this); break;
1380 // This is a bit ungeneric, but the only platform using a driver
1381 // driver is Darwin.
1382 case Action::LipoJobClass:
1383 T = new tools::darwin::Lipo(*this); break;
1384 case Action::DsymutilJobClass:
1385 T = new tools::darwin::Dsymutil(*this); break;
1386 case Action::VerifyJobClass:
1387 T = new tools::darwin::VerifyDebug(*this); break;
1394 bool Generic_GCC::IsUnwindTablesDefault() const {
1395 // FIXME: Gross; we should probably have some separate target
1396 // definition, possibly even reusing the one in clang.
1397 return getArchName() == "x86_64";
1400 const char *Generic_GCC::GetDefaultRelocationModel() const {
1404 const char *Generic_GCC::GetForcedPicModel() const {
1407 /// Hexagon Toolchain
1409 Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple& Triple)
1410 : ToolChain(D, Triple) {
1411 getProgramPaths().push_back(getDriver().getInstalledDir());
1412 if (getDriver().getInstalledDir() != getDriver().Dir.c_str())
1413 getProgramPaths().push_back(getDriver().Dir);
1416 Hexagon_TC::~Hexagon_TC() {
1417 // Free tool implementations.
1418 for (llvm::DenseMap<unsigned, Tool*>::iterator
1419 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
1423 Tool &Hexagon_TC::SelectTool(const Compilation &C,
1424 const JobAction &JA,
1425 const ActionList &Inputs) const {
1426 Action::ActionClass Key;
1427 // if (JA.getKind () == Action::CompileJobClass)
1428 // Key = JA.getKind ();
1431 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1432 Key = Action::AnalyzeJobClass;
1435 // if ((JA.getKind () == Action::CompileJobClass)
1436 // && (JA.getType () != types::TY_LTO_BC)) {
1437 // Key = JA.getKind ();
1440 Tool *&T = Tools[Key];
1443 case Action::InputClass:
1444 case Action::BindArchClass:
1445 assert(0 && "Invalid tool kind.");
1446 case Action::AnalyzeJobClass:
1447 T = new tools::Clang(*this); break;
1448 case Action::AssembleJobClass:
1449 T = new tools::hexagon::Assemble(*this); break;
1450 case Action::LinkJobClass:
1451 T = new tools::hexagon::Link(*this); break;
1453 assert(false && "Unsupported action for Hexagon target.");
1460 bool Hexagon_TC::IsUnwindTablesDefault() const {
1461 // FIXME: Gross; we should probably have some separate target
1462 // definition, possibly even reusing the one in clang.
1463 return getArchName() == "x86_64";
1466 const char *Hexagon_TC::GetDefaultRelocationModel() const {
1470 const char *Hexagon_TC::GetForcedPicModel() const {
1475 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
1476 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
1477 /// Currently does not support anything else but compilation.
1479 TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple)
1480 : ToolChain(D, Triple) {
1481 // Path mangling to find libexec
1482 std::string Path(getDriver().Dir);
1484 Path += "/../libexec";
1485 getProgramPaths().push_back(Path);
1488 TCEToolChain::~TCEToolChain() {
1489 for (llvm::DenseMap<unsigned, Tool*>::iterator
1490 it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
1494 bool TCEToolChain::IsMathErrnoDefault() const {
1498 bool TCEToolChain::IsUnwindTablesDefault() const {
1502 const char *TCEToolChain::GetDefaultRelocationModel() const {
1506 const char *TCEToolChain::GetForcedPicModel() const {
1510 Tool &TCEToolChain::SelectTool(const Compilation &C,
1511 const JobAction &JA,
1512 const ActionList &Inputs) const {
1513 Action::ActionClass Key;
1514 Key = Action::AnalyzeJobClass;
1516 Tool *&T = Tools[Key];
1519 case Action::PreprocessJobClass:
1520 T = new tools::gcc::Preprocess(*this); break;
1521 case Action::AnalyzeJobClass:
1522 T = new tools::Clang(*this); break;
1524 llvm_unreachable("Unsupported action for TCE target.");
1530 /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1532 OpenBSD::OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1533 : Generic_ELF(D, Triple, Args) {
1534 getFilePaths().push_back(getDriver().Dir + "/../lib");
1535 getFilePaths().push_back("/usr/lib");
1538 Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA,
1539 const ActionList &Inputs) const {
1540 Action::ActionClass Key;
1541 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1542 Key = Action::AnalyzeJobClass;
1546 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1547 options::OPT_no_integrated_as,
1548 IsIntegratedAssemblerDefault());
1550 Tool *&T = Tools[Key];
1553 case Action::AssembleJobClass: {
1554 if (UseIntegratedAs)
1555 T = new tools::ClangAs(*this);
1557 T = new tools::openbsd::Assemble(*this);
1560 case Action::LinkJobClass:
1561 T = new tools::openbsd::Link(*this); break;
1563 T = &Generic_GCC::SelectTool(C, JA, Inputs);
1570 /// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
1572 Bitrig::Bitrig(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1573 : Generic_ELF(D, Triple, Args) {
1574 getFilePaths().push_back(getDriver().Dir + "/../lib");
1575 getFilePaths().push_back("/usr/lib");
1578 Tool &Bitrig::SelectTool(const Compilation &C, const JobAction &JA,
1579 const ActionList &Inputs) const {
1580 Action::ActionClass Key;
1581 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1582 Key = Action::AnalyzeJobClass;
1586 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1587 options::OPT_no_integrated_as,
1588 IsIntegratedAssemblerDefault());
1590 Tool *&T = Tools[Key];
1593 case Action::AssembleJobClass: {
1594 if (UseIntegratedAs)
1595 T = new tools::ClangAs(*this);
1597 T = new tools::bitrig::Assemble(*this);
1600 case Action::LinkJobClass:
1601 T = new tools::bitrig::Link(*this); break;
1603 T = &Generic_GCC::SelectTool(C, JA, Inputs);
1610 void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1611 ArgStringList &CC1Args) const {
1612 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1613 DriverArgs.hasArg(options::OPT_nostdincxx))
1616 std::string Triple = getTriple().str();
1617 if (Triple.substr(0, 5) == "amd64")
1618 Triple.replace(0, 5, "x86_64");
1620 addSystemInclude(DriverArgs, CC1Args, "/usr/include/c++/4.6.2");
1621 addSystemInclude(DriverArgs, CC1Args, "/usr/include/c++/4.6.2/backward");
1622 addSystemInclude(DriverArgs, CC1Args, "/usr/include/c++/4.6.2/" + Triple);
1626 void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
1627 ArgStringList &CmdArgs) const {
1628 CmdArgs.push_back("-lstdc++");
1631 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1633 FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1634 : Generic_ELF(D, Triple, Args) {
1636 // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
1637 // back to '/usr/lib' if it doesn't exist.
1638 if ((Triple.getArch() == llvm::Triple::x86 ||
1639 Triple.getArch() == llvm::Triple::ppc) &&
1640 llvm::sys::fs::exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
1641 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
1643 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
1646 Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA,
1647 const ActionList &Inputs) const {
1648 Action::ActionClass Key;
1649 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1650 Key = Action::AnalyzeJobClass;
1654 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1655 options::OPT_no_integrated_as,
1656 IsIntegratedAssemblerDefault());
1658 Tool *&T = Tools[Key];
1661 case Action::AssembleJobClass:
1662 if (UseIntegratedAs)
1663 T = new tools::ClangAs(*this);
1665 T = new tools::freebsd::Assemble(*this);
1667 case Action::LinkJobClass:
1668 T = new tools::freebsd::Link(*this); break;
1670 T = &Generic_GCC::SelectTool(C, JA, Inputs);
1677 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
1679 NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1680 : Generic_ELF(D, Triple, Args) {
1682 if (getDriver().UseStdLib) {
1683 // When targeting a 32-bit platform, try the special directory used on
1684 // 64-bit hosts, and only fall back to the main library directory if that
1686 // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
1687 // what all logic is needed to emulate the '=' prefix here.
1688 if (Triple.getArch() == llvm::Triple::x86)
1689 getFilePaths().push_back("=/usr/lib/i386");
1691 getFilePaths().push_back("=/usr/lib");
1695 Tool &NetBSD::SelectTool(const Compilation &C, const JobAction &JA,
1696 const ActionList &Inputs) const {
1697 Action::ActionClass Key;
1698 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1699 Key = Action::AnalyzeJobClass;
1703 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
1704 options::OPT_no_integrated_as,
1705 IsIntegratedAssemblerDefault());
1707 Tool *&T = Tools[Key];
1710 case Action::AssembleJobClass:
1711 if (UseIntegratedAs)
1712 T = new tools::ClangAs(*this);
1714 T = new tools::netbsd::Assemble(*this);
1716 case Action::LinkJobClass:
1717 T = new tools::netbsd::Link(*this);
1720 T = &Generic_GCC::SelectTool(C, JA, Inputs);
1727 /// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1729 Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
1730 : Generic_ELF(D, Triple, Args) {
1731 getFilePaths().push_back(getDriver().Dir + "/../lib");
1732 getFilePaths().push_back("/usr/lib");
1735 Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA,
1736 const ActionList &Inputs) const {
1737 Action::ActionClass Key;
1738 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1739 Key = Action::AnalyzeJobClass;
1743 Tool *&T = Tools[Key];
1746 case Action::AssembleJobClass:
1747 T = new tools::minix::Assemble(*this); break;
1748 case Action::LinkJobClass:
1749 T = new tools::minix::Link(*this); break;
1751 T = &Generic_GCC::SelectTool(C, JA, Inputs);
1758 /// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1760 AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple,
1761 const ArgList &Args)
1762 : Generic_GCC(D, Triple, Args) {
1764 getProgramPaths().push_back(getDriver().getInstalledDir());
1765 if (getDriver().getInstalledDir() != getDriver().Dir)
1766 getProgramPaths().push_back(getDriver().Dir);
1768 getFilePaths().push_back(getDriver().Dir + "/../lib");
1769 getFilePaths().push_back("/usr/lib");
1770 getFilePaths().push_back("/usr/sfw/lib");
1771 getFilePaths().push_back("/opt/gcc4/lib");
1772 getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
1776 Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA,
1777 const ActionList &Inputs) const {
1778 Action::ActionClass Key;
1779 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1780 Key = Action::AnalyzeJobClass;
1784 Tool *&T = Tools[Key];
1787 case Action::AssembleJobClass:
1788 T = new tools::auroraux::Assemble(*this); break;
1789 case Action::LinkJobClass:
1790 T = new tools::auroraux::Link(*this); break;
1792 T = &Generic_GCC::SelectTool(C, JA, Inputs);
1799 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
1801 Solaris::Solaris(const Driver &D, const llvm::Triple& Triple,
1802 const ArgList &Args)
1803 : Generic_GCC(D, Triple, Args) {
1805 getProgramPaths().push_back(getDriver().getInstalledDir());
1806 if (getDriver().getInstalledDir() != getDriver().Dir)
1807 getProgramPaths().push_back(getDriver().Dir);
1809 getFilePaths().push_back(getDriver().Dir + "/../lib");
1810 getFilePaths().push_back("/usr/lib");
1813 Tool &Solaris::SelectTool(const Compilation &C, const JobAction &JA,
1814 const ActionList &Inputs) const {
1815 Action::ActionClass Key;
1816 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
1817 Key = Action::AnalyzeJobClass;
1821 Tool *&T = Tools[Key];
1824 case Action::AssembleJobClass:
1825 T = new tools::solaris::Assemble(*this); break;
1826 case Action::LinkJobClass:
1827 T = new tools::solaris::Link(*this); break;
1829 T = &Generic_GCC::SelectTool(C, JA, Inputs);
1836 /// Linux toolchain (very bare-bones at the moment).
1868 static bool IsRedhat(enum LinuxDistro Distro) {
1869 return (Distro >= Fedora13 && Distro <= FedoraRawhide) ||
1870 (Distro >= RHEL4 && Distro <= RHEL6);
1873 static bool IsOpenSuse(enum LinuxDistro Distro) {
1874 return Distro >= OpenSuse11_3 && Distro <= OpenSuse12_2;
1877 static bool IsDebian(enum LinuxDistro Distro) {
1878 return Distro >= DebianLenny && Distro <= DebianWheezy;
1881 static bool IsUbuntu(enum LinuxDistro Distro) {
1882 return Distro >= UbuntuHardy && Distro <= UbuntuPrecise;
1885 static LinuxDistro DetectLinuxDistro(llvm::Triple::ArchType Arch) {
1886 OwningPtr<llvm::MemoryBuffer> File;
1887 if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) {
1888 StringRef Data = File.get()->getBuffer();
1889 SmallVector<StringRef, 8> Lines;
1890 Data.split(Lines, "\n");
1891 LinuxDistro Version = UnknownDistro;
1892 for (unsigned i = 0, s = Lines.size(); i != s; ++i)
1893 if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME="))
1894 Version = llvm::StringSwitch<LinuxDistro>(Lines[i].substr(17))
1895 .Case("hardy", UbuntuHardy)
1896 .Case("intrepid", UbuntuIntrepid)
1897 .Case("jaunty", UbuntuJaunty)
1898 .Case("karmic", UbuntuKarmic)
1899 .Case("lucid", UbuntuLucid)
1900 .Case("maverick", UbuntuMaverick)
1901 .Case("natty", UbuntuNatty)
1902 .Case("oneiric", UbuntuOneiric)
1903 .Case("precise", UbuntuPrecise)
1904 .Default(UnknownDistro);
1908 if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) {
1909 StringRef Data = File.get()->getBuffer();
1910 if (Data.startswith("Fedora release 16"))
1912 else if (Data.startswith("Fedora release 15"))
1914 else if (Data.startswith("Fedora release 14"))
1916 else if (Data.startswith("Fedora release 13"))
1918 else if (Data.startswith("Fedora release") &&
1919 Data.find("Rawhide") != StringRef::npos)
1920 return FedoraRawhide;
1921 else if (Data.startswith("Red Hat Enterprise Linux") &&
1922 Data.find("release 6") != StringRef::npos)
1924 else if ((Data.startswith("Red Hat Enterprise Linux") ||
1925 Data.startswith("CentOS")) &&
1926 Data.find("release 5") != StringRef::npos)
1928 else if ((Data.startswith("Red Hat Enterprise Linux") ||
1929 Data.startswith("CentOS")) &&
1930 Data.find("release 4") != StringRef::npos)
1932 return UnknownDistro;
1935 if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) {
1936 StringRef Data = File.get()->getBuffer();
1939 else if (Data.startswith("squeeze/sid") || Data[0] == '6')
1940 return DebianSqueeze;
1941 else if (Data.startswith("wheezy/sid") || Data[0] == '7')
1942 return DebianWheezy;
1943 return UnknownDistro;
1946 if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File))
1947 return llvm::StringSwitch<LinuxDistro>(File.get()->getBuffer())
1948 .StartsWith("openSUSE 11.3", OpenSuse11_3)
1949 .StartsWith("openSUSE 11.4", OpenSuse11_4)
1950 .StartsWith("openSUSE 12.1", OpenSuse12_1)
1951 .StartsWith("openSUSE 12.2", OpenSuse12_2)
1952 .Default(UnknownDistro);
1955 if (!llvm::sys::fs::exists("/etc/exherbo-release", Exists) && Exists)
1958 if (!llvm::sys::fs::exists("/etc/arch-release", Exists) && Exists)
1961 return UnknownDistro;
1964 /// \brief Get our best guess at the multiarch triple for a target.
1966 /// Debian-based systems are starting to use a multiarch setup where they use
1967 /// a target-triple directory in the library and header search paths.
1968 /// Unfortunately, this triple does not align with the vanilla target triple,
1969 /// so we provide a rough mapping here.
1970 static std::string getMultiarchTriple(const llvm::Triple TargetTriple,
1971 StringRef SysRoot) {
1972 // For most architectures, just use whatever we have rather than trying to be
1974 switch (TargetTriple.getArch()) {
1976 return TargetTriple.str();
1978 // We use the existence of '/lib/<triple>' as a directory to detect some
1979 // common linux triples that don't quite match the Clang triple for both
1980 // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
1981 // regardless of what the actual target triple is.
1982 case llvm::Triple::arm:
1983 case llvm::Triple::thumb:
1984 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1985 if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabihf"))
1986 return "arm-linux-gnueabihf";
1988 if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabi"))
1989 return "arm-linux-gnueabi";
1991 return TargetTriple.str();
1992 case llvm::Triple::x86:
1993 if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
1994 return "i386-linux-gnu";
1995 return TargetTriple.str();
1996 case llvm::Triple::x86_64:
1997 if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
1998 return "x86_64-linux-gnu";
1999 return TargetTriple.str();
2000 case llvm::Triple::mips:
2001 if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu"))
2002 return "mips-linux-gnu";
2003 return TargetTriple.str();
2004 case llvm::Triple::mipsel:
2005 if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu"))
2006 return "mipsel-linux-gnu";
2007 return TargetTriple.str();
2008 case llvm::Triple::ppc:
2009 if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu"))
2010 return "powerpc-linux-gnu";
2011 return TargetTriple.str();
2012 case llvm::Triple::ppc64:
2013 if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu"))
2014 return "powerpc64-linux-gnu";
2015 return TargetTriple.str();
2019 static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) {
2020 if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str());
2023 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
2024 : Generic_ELF(D, Triple, Args) {
2025 llvm::Triple::ArchType Arch = Triple.getArch();
2026 const std::string &SysRoot = getDriver().SysRoot;
2028 // OpenSuse stores the linker with the compiler, add that to the search
2030 ToolChain::path_list &PPaths = getProgramPaths();
2031 PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
2032 GCCInstallation.getTriple().str() + "/bin").str());
2034 Linker = GetProgramPath("ld");
2036 LinuxDistro Distro = DetectLinuxDistro(Arch);
2038 if (IsOpenSuse(Distro) || IsUbuntu(Distro)) {
2039 ExtraOpts.push_back("-z");
2040 ExtraOpts.push_back("relro");
2043 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
2044 ExtraOpts.push_back("-X");
2046 const bool IsMips = Arch == llvm::Triple::mips ||
2047 Arch == llvm::Triple::mipsel ||
2048 Arch == llvm::Triple::mips64 ||
2049 Arch == llvm::Triple::mips64el;
2051 const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::ANDROIDEABI;
2053 // Do not use 'gnu' hash style for Mips targets because .gnu.hash
2054 // and the MIPS ABI require .dynsym to be sorted in different ways.
2055 // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
2056 // ABI requires a mapping between the GOT and the symbol table.
2057 // Android loader does not support .gnu.hash.
2058 if (!IsMips && !IsAndroid) {
2059 if (IsRedhat(Distro) || IsOpenSuse(Distro) ||
2060 (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
2061 ExtraOpts.push_back("--hash-style=gnu");
2063 if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid ||
2064 Distro == UbuntuJaunty || Distro == UbuntuKarmic)
2065 ExtraOpts.push_back("--hash-style=both");
2068 if (IsRedhat(Distro))
2069 ExtraOpts.push_back("--no-add-needed");
2071 if (Distro == DebianSqueeze || Distro == DebianWheezy ||
2072 IsOpenSuse(Distro) ||
2073 (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
2074 (IsUbuntu(Distro) && Distro >= UbuntuKarmic))
2075 ExtraOpts.push_back("--build-id");
2077 if (IsOpenSuse(Distro))
2078 ExtraOpts.push_back("--enable-new-dtags");
2080 // The selection of paths to try here is designed to match the patterns which
2081 // the GCC driver itself uses, as this is part of the GCC-compatible driver.
2082 // This was determined by running GCC in a fake filesystem, creating all
2083 // possible permutations of these directories, and seeing which ones it added
2084 // to the link paths.
2085 path_list &Paths = getFilePaths();
2087 const std::string Multilib = Triple.isArch32Bit() ? "lib32" : "lib64";
2088 const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot);
2090 // Add the multilib suffixed paths where they are available.
2091 if (GCCInstallation.isValid()) {
2092 const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2093 const std::string &LibPath = GCCInstallation.getParentLibPath();
2094 addPathIfExists((GCCInstallation.getInstallPath() +
2095 GCCInstallation.getMultiarchSuffix()),
2098 // If the GCC installation we found is inside of the sysroot, we want to
2099 // prefer libraries installed in the parent prefix of the GCC installation.
2100 // It is important to *not* use these paths when the GCC installation is
2101 // outside of the system root as that can pick up unintended libraries.
2102 // This usually happens when there is an external cross compiler on the
2103 // host system, and a more minimal sysroot available that is the target of
2105 if (StringRef(LibPath).startswith(SysRoot)) {
2106 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + Multilib,
2108 addPathIfExists(LibPath + "/" + MultiarchTriple, Paths);
2109 addPathIfExists(LibPath + "/../" + Multilib, Paths);
2112 addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths);
2113 addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths);
2114 addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
2115 addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths);
2117 // Try walking via the GCC triple path in case of multiarch GCC
2118 // installations with strange symlinks.
2119 if (GCCInstallation.isValid())
2120 addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
2121 "/../../" + Multilib, Paths);
2123 // Add the non-multilib suffixed paths (if potentially different).
2124 if (GCCInstallation.isValid()) {
2125 const std::string &LibPath = GCCInstallation.getParentLibPath();
2126 const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2127 if (!GCCInstallation.getMultiarchSuffix().empty())
2128 addPathIfExists(GCCInstallation.getInstallPath(), Paths);
2130 if (StringRef(LibPath).startswith(SysRoot)) {
2131 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths);
2132 addPathIfExists(LibPath, Paths);
2135 addPathIfExists(SysRoot + "/lib", Paths);
2136 addPathIfExists(SysRoot + "/usr/lib", Paths);
2139 bool Linux::HasNativeLLVMSupport() const {
2143 Tool &Linux::SelectTool(const Compilation &C, const JobAction &JA,
2144 const ActionList &Inputs) const {
2145 Action::ActionClass Key;
2146 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
2147 Key = Action::AnalyzeJobClass;
2151 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as,
2152 options::OPT_no_integrated_as,
2153 IsIntegratedAssemblerDefault());
2155 Tool *&T = Tools[Key];
2158 case Action::AssembleJobClass:
2159 if (UseIntegratedAs)
2160 T = new tools::ClangAs(*this);
2162 T = new tools::linuxtools::Assemble(*this);
2164 case Action::LinkJobClass:
2165 T = new tools::linuxtools::Link(*this); break;
2167 T = &Generic_GCC::SelectTool(C, JA, Inputs);
2174 void Linux::addClangTargetOptions(ArgStringList &CC1Args) const {
2175 const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2176 if (V >= Generic_GCC::GCCVersion::Parse("4.7.0"))
2177 CC1Args.push_back("-fuse-init-array");
2180 void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2181 ArgStringList &CC1Args) const {
2182 const Driver &D = getDriver();
2184 if (DriverArgs.hasArg(options::OPT_nostdinc))
2187 if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
2188 addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include");
2190 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2191 llvm::sys::Path P(D.ResourceDir);
2192 P.appendComponent("include");
2193 addSystemInclude(DriverArgs, CC1Args, P.str());
2196 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2199 // Check for configure-time C include directories.
2200 StringRef CIncludeDirs(C_INCLUDE_DIRS);
2201 if (CIncludeDirs != "") {
2202 SmallVector<StringRef, 5> dirs;
2203 CIncludeDirs.split(dirs, ":");
2204 for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();
2206 StringRef Prefix = llvm::sys::path::is_absolute(*I) ? D.SysRoot : "";
2207 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);
2212 // Lacking those, try to detect the correct set of system includes for the
2215 // Implement generic Debian multiarch support.
2216 const StringRef X86_64MultiarchIncludeDirs[] = {
2217 "/usr/include/x86_64-linux-gnu",
2219 // FIXME: These are older forms of multiarch. It's not clear that they're
2220 // in use in any released version of Debian, so we should consider
2222 "/usr/include/i686-linux-gnu/64",
2223 "/usr/include/i486-linux-gnu/64"
2225 const StringRef X86MultiarchIncludeDirs[] = {
2226 "/usr/include/i386-linux-gnu",
2228 // FIXME: These are older forms of multiarch. It's not clear that they're
2229 // in use in any released version of Debian, so we should consider
2231 "/usr/include/x86_64-linux-gnu/32",
2232 "/usr/include/i686-linux-gnu",
2233 "/usr/include/i486-linux-gnu"
2235 const StringRef ARMMultiarchIncludeDirs[] = {
2236 "/usr/include/arm-linux-gnueabi"
2238 const StringRef ARMHFMultiarchIncludeDirs[] = {
2239 "/usr/include/arm-linux-gnueabihf"
2241 const StringRef MIPSMultiarchIncludeDirs[] = {
2242 "/usr/include/mips-linux-gnu"
2244 const StringRef MIPSELMultiarchIncludeDirs[] = {
2245 "/usr/include/mipsel-linux-gnu"
2247 const StringRef PPCMultiarchIncludeDirs[] = {
2248 "/usr/include/powerpc-linux-gnu"
2250 const StringRef PPC64MultiarchIncludeDirs[] = {
2251 "/usr/include/powerpc64-linux-gnu"
2253 ArrayRef<StringRef> MultiarchIncludeDirs;
2254 if (getTriple().getArch() == llvm::Triple::x86_64) {
2255 MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
2256 } else if (getTriple().getArch() == llvm::Triple::x86) {
2257 MultiarchIncludeDirs = X86MultiarchIncludeDirs;
2258 } else if (getTriple().getArch() == llvm::Triple::arm) {
2259 if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
2260 MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
2262 MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
2263 } else if (getTriple().getArch() == llvm::Triple::mips) {
2264 MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
2265 } else if (getTriple().getArch() == llvm::Triple::mipsel) {
2266 MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
2267 } else if (getTriple().getArch() == llvm::Triple::ppc) {
2268 MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
2269 } else if (getTriple().getArch() == llvm::Triple::ppc64) {
2270 MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
2272 for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(),
2273 E = MultiarchIncludeDirs.end();
2275 if (llvm::sys::fs::exists(D.SysRoot + *I)) {
2276 addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + *I);
2281 if (getTriple().getOS() == llvm::Triple::RTEMS)
2284 // Add an include of '/include' directly. This isn't provided by default by
2285 // system GCCs, but is often used with cross-compiling GCCs, and harmless to
2286 // add even when Clang is acting as-if it were a system compiler.
2287 addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/include");
2289 addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include");
2292 /// \brief Helper to add the thre variant paths for a libstdc++ installation.
2293 /*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
2294 const ArgList &DriverArgs,
2295 ArgStringList &CC1Args) {
2296 if (!llvm::sys::fs::exists(Base))
2298 addSystemInclude(DriverArgs, CC1Args, Base);
2299 addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir);
2300 addSystemInclude(DriverArgs, CC1Args, Base + "/backward");
2304 void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2305 ArgStringList &CC1Args) const {
2306 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2307 DriverArgs.hasArg(options::OPT_nostdincxx))
2310 // Check if libc++ has been enabled and provide its include paths if so.
2311 if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
2312 // libc++ is always installed at a fixed path on Linux currently.
2313 addSystemInclude(DriverArgs, CC1Args,
2314 getDriver().SysRoot + "/usr/include/c++/v1");
2318 // We need a detected GCC installation on Linux to provide libstdc++'s
2319 // headers. We handled the libc++ case above.
2320 if (!GCCInstallation.isValid())
2323 // By default, look for the C++ headers in an include directory adjacent to
2324 // the lib directory of the GCC installation. Note that this is expect to be
2325 // equivalent to '/usr/include/c++/X.Y' in almost all cases.
2326 StringRef LibDir = GCCInstallation.getParentLibPath();
2327 StringRef InstallDir = GCCInstallation.getInstallPath();
2328 StringRef Version = GCCInstallation.getVersion().Text;
2329 if (!addLibStdCXXIncludePaths(LibDir + "/../include/c++/" + Version,
2330 (GCCInstallation.getTriple().str() +
2331 GCCInstallation.getMultiarchSuffix()),
2332 DriverArgs, CC1Args)) {
2333 // Gentoo is weird and places its headers inside the GCC install, so if the
2334 // first attempt to find the headers fails, try this pattern.
2335 addLibStdCXXIncludePaths(InstallDir + "/include/g++-v4",
2336 (GCCInstallation.getTriple().str() +
2337 GCCInstallation.getMultiarchSuffix()),
2338 DriverArgs, CC1Args);
2342 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
2344 DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
2345 : Generic_ELF(D, Triple, Args) {
2347 // Path mangling to find libexec
2348 getProgramPaths().push_back(getDriver().getInstalledDir());
2349 if (getDriver().getInstalledDir() != getDriver().Dir)
2350 getProgramPaths().push_back(getDriver().Dir);
2352 getFilePaths().push_back(getDriver().Dir + "/../lib");
2353 getFilePaths().push_back("/usr/lib");
2354 getFilePaths().push_back("/usr/lib/gcc41");
2357 Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA,
2358 const ActionList &Inputs) const {
2359 Action::ActionClass Key;
2360 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
2361 Key = Action::AnalyzeJobClass;
2365 Tool *&T = Tools[Key];
2368 case Action::AssembleJobClass:
2369 T = new tools::dragonfly::Assemble(*this); break;
2370 case Action::LinkJobClass:
2371 T = new tools::dragonfly::Link(*this); break;
2373 T = &Generic_GCC::SelectTool(C, JA, Inputs);