1 //===--- ToolChains.cpp - ToolChain Implementations -------------*- C++ -*-===//
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"
11 #include "clang/Basic/Cuda.h"
12 #include "clang/Basic/ObjCRuntime.h"
13 #include "clang/Basic/Version.h"
14 #include "clang/Basic/VirtualFileSystem.h"
15 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
16 #include "clang/Driver/Compilation.h"
17 #include "clang/Driver/Driver.h"
18 #include "clang/Driver/DriverDiagnostic.h"
19 #include "clang/Driver/Options.h"
20 #include "clang/Driver/SanitizerArgs.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/SmallString.h"
23 #include "llvm/ADT/StringExtras.h"
24 #include "llvm/ADT/StringSwitch.h"
25 #include "llvm/Option/Arg.h"
26 #include "llvm/Option/ArgList.h"
27 #include "llvm/Option/OptTable.h"
28 #include "llvm/Option/Option.h"
29 #include "llvm/ProfileData/InstrProf.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/FileSystem.h"
32 #include "llvm/Support/MemoryBuffer.h"
33 #include "llvm/Support/Path.h"
34 #include "llvm/Support/Program.h"
35 #include "llvm/Support/TargetParser.h"
36 #include "llvm/Support/raw_ostream.h"
37 #include <cstdlib> // ::getenv
38 #include <system_error>
40 using namespace clang::driver;
41 using namespace clang::driver::toolchains;
42 using namespace clang;
43 using namespace llvm::opt;
45 MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
46 : ToolChain(D, Triple, Args) {
47 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
48 getProgramPaths().push_back(getDriver().getInstalledDir());
49 if (getDriver().getInstalledDir() != getDriver().Dir)
50 getProgramPaths().push_back(getDriver().Dir);
53 /// Darwin - Darwin tool chain for i386 and x86_64.
54 Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
55 : MachO(D, Triple, Args), TargetInitialized(false) {}
57 types::ID MachO::LookupTypeForExtension(const char *Ext) const {
58 types::ID Ty = types::lookupTypeForExtension(Ext);
60 // Darwin always preprocesses assembly files (unless -x is used explicitly).
61 if (Ty == types::TY_PP_Asm)
67 bool MachO::HasNativeLLVMSupport() const { return true; }
69 ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const {
70 // Default to use libc++ on OS X 10.9+ and iOS 7+.
71 if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
72 (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
73 isTargetWatchOSBased())
74 return ToolChain::CST_Libcxx;
76 return ToolChain::CST_Libstdcxx;
79 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
80 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
81 if (isTargetWatchOSBased())
82 return ObjCRuntime(ObjCRuntime::WatchOS, TargetVersion);
83 if (isTargetIOSBased())
84 return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
86 return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
87 return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
90 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
91 bool Darwin::hasBlocksRuntime() const {
92 if (isTargetWatchOSBased())
94 else if (isTargetIOSBased())
95 return !isIPhoneOSVersionLT(3, 2);
97 assert(isTargetMacOS() && "unexpected darwin target");
98 return !isMacosxVersionLT(10, 6);
102 // This is just a MachO name translation routine and there's no
103 // way to join this into ARMTargetParser without breaking all
104 // other assumptions. Maybe MachO should consider standardising
105 // their nomenclature.
106 static const char *ArmMachOArchName(StringRef Arch) {
107 return llvm::StringSwitch<const char *>(Arch)
108 .Case("armv6k", "armv6")
109 .Case("armv6m", "armv6m")
110 .Case("armv5tej", "armv5")
111 .Case("xscale", "xscale")
112 .Case("armv4t", "armv4t")
113 .Case("armv7", "armv7")
114 .Cases("armv7a", "armv7-a", "armv7")
115 .Cases("armv7r", "armv7-r", "armv7")
116 .Cases("armv7em", "armv7e-m", "armv7em")
117 .Cases("armv7k", "armv7-k", "armv7k")
118 .Cases("armv7m", "armv7-m", "armv7m")
119 .Cases("armv7s", "armv7-s", "armv7s")
123 static const char *ArmMachOArchNameCPU(StringRef CPU) {
124 unsigned ArchKind = llvm::ARM::parseCPUArch(CPU);
125 if (ArchKind == llvm::ARM::AK_INVALID)
127 StringRef Arch = llvm::ARM::getArchName(ArchKind);
129 // FIXME: Make sure this MachO triple mangling is really necessary.
130 // ARMv5* normalises to ARMv5.
131 if (Arch.startswith("armv5"))
132 Arch = Arch.substr(0, 5);
133 // ARMv6*, except ARMv6M, normalises to ARMv6.
134 else if (Arch.startswith("armv6") && !Arch.endswith("6m"))
135 Arch = Arch.substr(0, 5);
136 // ARMv7A normalises to ARMv7.
137 else if (Arch.endswith("v7a"))
138 Arch = Arch.substr(0, 5);
142 static bool isSoftFloatABI(const ArgList &Args) {
143 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
144 options::OPT_mfloat_abi_EQ);
148 return A->getOption().matches(options::OPT_msoft_float) ||
149 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
150 A->getValue() == StringRef("soft"));
153 StringRef MachO::getMachOArchName(const ArgList &Args) const {
154 switch (getTriple().getArch()) {
156 return getDefaultUniversalArchName();
158 case llvm::Triple::aarch64:
161 case llvm::Triple::thumb:
162 case llvm::Triple::arm:
163 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
164 if (const char *Arch = ArmMachOArchName(A->getValue()))
167 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
168 if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
179 std::string MachO::ComputeEffectiveClangTriple(const ArgList &Args,
180 types::ID InputType) const {
181 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
183 return Triple.getTriple();
186 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
187 types::ID InputType) const {
188 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
190 // If the target isn't initialized (e.g., an unknown Darwin platform, return
191 // the default triple).
192 if (!isTargetInitialized())
193 return Triple.getTriple();
196 if (isTargetWatchOSBased())
198 else if (isTargetTvOSBased())
200 else if (isTargetIOSBased())
204 Str += getTargetVersion().getAsString();
205 Triple.setOSName(Str);
207 return Triple.getTriple();
210 void Generic_ELF::anchor() {}
212 Tool *MachO::getTool(Action::ActionClass AC) const {
214 case Action::LipoJobClass:
216 Lipo.reset(new tools::darwin::Lipo(*this));
218 case Action::DsymutilJobClass:
220 Dsymutil.reset(new tools::darwin::Dsymutil(*this));
221 return Dsymutil.get();
222 case Action::VerifyDebugInfoJobClass:
224 VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
225 return VerifyDebug.get();
227 return ToolChain::getTool(AC);
231 Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
233 Tool *MachO::buildAssembler() const {
234 return new tools::darwin::Assembler(*this);
237 DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple,
239 : Darwin(D, Triple, Args) {}
241 void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const {
242 // For modern targets, promote certain warnings to errors.
243 if (isTargetWatchOSBased() || getTriple().isArch64Bit()) {
244 // Always enable -Wdeprecated-objc-isa-usage and promote it
246 CC1Args.push_back("-Wdeprecated-objc-isa-usage");
247 CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
249 // For iOS and watchOS, also error about implicit function declarations,
250 // as that can impact calling conventions.
251 if (!isTargetMacOS())
252 CC1Args.push_back("-Werror=implicit-function-declaration");
256 /// \brief Determine whether Objective-C automated reference counting is
258 static bool isObjCAutoRefCount(const ArgList &Args) {
259 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
262 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
263 ArgStringList &CmdArgs) const {
264 // Avoid linking compatibility stubs on i386 mac.
265 if (isTargetMacOS() && getArch() == llvm::Triple::x86)
268 ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
270 if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) &&
271 runtime.hasSubscripting())
274 CmdArgs.push_back("-force_load");
275 SmallString<128> P(getDriver().ClangExecutable);
276 llvm::sys::path::remove_filename(P); // 'clang'
277 llvm::sys::path::remove_filename(P); // 'bin'
278 llvm::sys::path::append(P, "lib", "arc", "libarclite_");
279 // Mash in the platform.
280 if (isTargetWatchOSSimulator())
281 P += "watchsimulator";
282 else if (isTargetWatchOS())
284 else if (isTargetTvOSSimulator())
285 P += "appletvsimulator";
286 else if (isTargetTvOS())
288 else if (isTargetIOSSimulator())
289 P += "iphonesimulator";
290 else if (isTargetIPhoneOS())
296 CmdArgs.push_back(Args.MakeArgString(P));
299 void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
300 StringRef DarwinLibName, bool AlwaysLink,
301 bool IsEmbedded, bool AddRPath) const {
302 SmallString<128> Dir(getDriver().ResourceDir);
303 llvm::sys::path::append(Dir, "lib", IsEmbedded ? "macho_embedded" : "darwin");
305 SmallString<128> P(Dir);
306 llvm::sys::path::append(P, DarwinLibName);
308 // For now, allow missing resource libraries to support developers who may
309 // not have compiler-rt checked out or integrated into their build (unless
310 // we explicitly force linking with this library).
311 if (AlwaysLink || getVFS().exists(P))
312 CmdArgs.push_back(Args.MakeArgString(P));
314 // Adding the rpaths might negatively interact when other rpaths are involved,
315 // so we should make sure we add the rpaths last, after all user-specified
316 // rpaths. This is currently true from this place, but we need to be
317 // careful if this function is ever called before user's rpaths are emitted.
319 assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library");
321 // Add @executable_path to rpath to support having the dylib copied with
323 CmdArgs.push_back("-rpath");
324 CmdArgs.push_back("@executable_path");
326 // Add the path to the resource dir to rpath to support using the dylib
327 // from the default location without copying.
328 CmdArgs.push_back("-rpath");
329 CmdArgs.push_back(Args.MakeArgString(Dir));
333 StringRef Darwin::getPlatformFamily() const {
334 switch (TargetPlatform) {
335 case DarwinPlatformKind::MacOS:
337 case DarwinPlatformKind::IPhoneOS:
338 case DarwinPlatformKind::IPhoneOSSimulator:
340 case DarwinPlatformKind::TvOS:
341 case DarwinPlatformKind::TvOSSimulator:
343 case DarwinPlatformKind::WatchOS:
344 case DarwinPlatformKind::WatchOSSimulator:
347 llvm_unreachable("Unsupported platform");
350 StringRef Darwin::getSDKName(StringRef isysroot) {
351 // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
352 llvm::sys::path::const_iterator SDKDir;
353 auto BeginSDK = llvm::sys::path::begin(isysroot);
354 auto EndSDK = llvm::sys::path::end(isysroot);
355 for (auto IT = BeginSDK; IT != EndSDK; ++IT) {
357 if (SDK.endswith(".sdk"))
358 return SDK.slice(0, SDK.size() - 4);
363 StringRef Darwin::getOSLibraryNameSuffix() const {
364 switch(TargetPlatform) {
365 case DarwinPlatformKind::MacOS:
367 case DarwinPlatformKind::IPhoneOS:
369 case DarwinPlatformKind::IPhoneOSSimulator:
371 case DarwinPlatformKind::TvOS:
373 case DarwinPlatformKind::TvOSSimulator:
375 case DarwinPlatformKind::WatchOS:
377 case DarwinPlatformKind::WatchOSSimulator:
380 llvm_unreachable("Unsupported platform");
383 void Darwin::addProfileRTLibs(const ArgList &Args,
384 ArgStringList &CmdArgs) const {
385 if (!needsProfileRT(Args)) return;
387 AddLinkRuntimeLib(Args, CmdArgs, (Twine("libclang_rt.profile_") +
388 getOSLibraryNameSuffix() + ".a").str(),
389 /*AlwaysLink*/ true);
392 void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
393 ArgStringList &CmdArgs,
394 StringRef Sanitizer) const {
397 (Twine("libclang_rt.") + Sanitizer + "_" +
398 getOSLibraryNameSuffix() + "_dynamic.dylib").str(),
399 /*AlwaysLink*/ true, /*IsEmbedded*/ false,
403 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
404 ArgStringList &CmdArgs) const {
405 // Darwin only supports the compiler-rt based runtime libraries.
406 switch (GetRuntimeLibType(Args)) {
407 case ToolChain::RLT_CompilerRT:
410 getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
411 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "darwin";
415 // Darwin doesn't support real static executables, don't link any runtime
416 // libraries with -static.
417 if (Args.hasArg(options::OPT_static) ||
418 Args.hasArg(options::OPT_fapple_kext) ||
419 Args.hasArg(options::OPT_mkernel))
422 // Reject -static-libgcc for now, we can deal with this when and if someone
423 // cares. This is useful in situations where someone wants to statically link
424 // something like libstdc++, and needs its runtime support routines.
425 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
426 getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
430 const SanitizerArgs &Sanitize = getSanitizerArgs();
431 if (Sanitize.needsAsanRt())
432 AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
433 if (Sanitize.needsUbsanRt())
434 AddLinkSanitizerLibArgs(Args, CmdArgs, "ubsan");
435 if (Sanitize.needsTsanRt())
436 AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan");
437 if (Sanitize.needsStatsRt()) {
438 StringRef OS = isTargetMacOS() ? "osx" : "iossim";
439 AddLinkRuntimeLib(Args, CmdArgs,
440 (Twine("libclang_rt.stats_client_") + OS + ".a").str(),
441 /*AlwaysLink=*/true);
442 AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
444 if (Sanitize.needsEsanRt())
445 AddLinkSanitizerLibArgs(Args, CmdArgs, "esan");
447 // Otherwise link libSystem, then the dynamic runtime library, and finally any
448 // target specific static runtime library.
449 CmdArgs.push_back("-lSystem");
451 // Select the dynamic runtime library and the target specific static library.
452 if (isTargetWatchOSBased()) {
453 // We currently always need a static runtime library for watchOS.
454 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.watchos.a");
455 } else if (isTargetTvOSBased()) {
456 // We currently always need a static runtime library for tvOS.
457 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.tvos.a");
458 } else if (isTargetIOSBased()) {
459 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
460 // it never went into the SDK.
461 // Linking against libgcc_s.1 isn't needed for iOS 5.0+
462 if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
463 getTriple().getArch() != llvm::Triple::aarch64)
464 CmdArgs.push_back("-lgcc_s.1");
466 // We currently always need a static runtime library for iOS.
467 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
469 assert(isTargetMacOS() && "unexpected non MacOS platform");
470 // The dynamic runtime library was merged with libSystem for 10.6 and
471 // beyond; only 10.4 and 10.5 need an additional runtime library.
472 if (isMacosxVersionLT(10, 5))
473 CmdArgs.push_back("-lgcc_s.10.4");
474 else if (isMacosxVersionLT(10, 6))
475 CmdArgs.push_back("-lgcc_s.10.5");
477 // Originally for OS X, we thought we would only need a static runtime
478 // library when targeting 10.4, to provide versions of the static functions
479 // which were omitted from 10.4.dylib. This led to the creation of the 10.4
482 // Unfortunately, that turned out to not be true, because Darwin system
483 // headers can still use eprintf on i386, and it is not exported from
484 // libSystem. Therefore, we still must provide a runtime library just for
485 // the tiny tiny handful of projects that *might* use that symbol.
487 // Then over time, we figured out it was useful to add more things to the
488 // runtime so we created libclang_rt.osx.a to provide new functions when
489 // deploying to old OS builds, and for a long time we had both eprintf and
490 // osx builtin libraries. Which just seems excessive. So with PR 28855, we
491 // are removing the eprintf library and expecting eprintf to be provided by
492 // the OS X builtins library.
493 if (isMacosxVersionLT(10, 5))
494 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
496 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
500 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
501 const OptTable &Opts = getDriver().getOpts();
503 // Support allowing the SDKROOT environment variable used by xcrun and other
504 // Xcode tools to define the default sysroot, by making it the default for
506 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
507 // Warn if the path does not exist.
508 if (!getVFS().exists(A->getValue()))
509 getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
511 if (char *env = ::getenv("SDKROOT")) {
512 // We only use this value as the default if it is an absolute path,
513 // exists, and it is not the root path.
514 if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
515 StringRef(env) != "/") {
516 Args.append(Args.MakeSeparateArg(
517 nullptr, Opts.getOption(options::OPT_isysroot), env));
522 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
523 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
524 Arg *TvOSVersion = Args.getLastArg(options::OPT_mtvos_version_min_EQ);
525 Arg *WatchOSVersion = Args.getLastArg(options::OPT_mwatchos_version_min_EQ);
527 if (OSXVersion && (iOSVersion || TvOSVersion || WatchOSVersion)) {
528 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
529 << OSXVersion->getAsString(Args)
530 << (iOSVersion ? iOSVersion :
531 TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
532 iOSVersion = TvOSVersion = WatchOSVersion = nullptr;
533 } else if (iOSVersion && (TvOSVersion || WatchOSVersion)) {
534 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
535 << iOSVersion->getAsString(Args)
536 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
537 TvOSVersion = WatchOSVersion = nullptr;
538 } else if (TvOSVersion && WatchOSVersion) {
539 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
540 << TvOSVersion->getAsString(Args)
541 << WatchOSVersion->getAsString(Args);
542 WatchOSVersion = nullptr;
543 } else if (!OSXVersion && !iOSVersion && !TvOSVersion && !WatchOSVersion) {
544 // If no deployment target was specified on the command line, check for
545 // environment defines.
546 std::string OSXTarget;
547 std::string iOSTarget;
548 std::string TvOSTarget;
549 std::string WatchOSTarget;
551 if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
553 if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
555 if (char *env = ::getenv("TVOS_DEPLOYMENT_TARGET"))
557 if (char *env = ::getenv("WATCHOS_DEPLOYMENT_TARGET"))
560 // If there is no command-line argument to specify the Target version and
561 // no environment variable defined, see if we can set the default based
563 if (OSXTarget.empty() && iOSTarget.empty() && WatchOSTarget.empty() &&
564 TvOSTarget.empty() && Args.hasArg(options::OPT_isysroot)) {
565 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
566 StringRef isysroot = A->getValue();
567 StringRef SDK = getSDKName(isysroot);
568 if (SDK.size() > 0) {
569 // Slice the version number out.
570 // Version number is between the first and the last number.
571 size_t StartVer = SDK.find_first_of("0123456789");
572 size_t EndVer = SDK.find_last_of("0123456789");
573 if (StartVer != StringRef::npos && EndVer > StartVer) {
574 StringRef Version = SDK.slice(StartVer, EndVer + 1);
575 if (SDK.startswith("iPhoneOS") ||
576 SDK.startswith("iPhoneSimulator"))
578 else if (SDK.startswith("MacOSX"))
580 else if (SDK.startswith("WatchOS") ||
581 SDK.startswith("WatchSimulator"))
582 WatchOSTarget = Version;
583 else if (SDK.startswith("AppleTVOS") ||
584 SDK.startswith("AppleTVSimulator"))
585 TvOSTarget = Version;
591 // If no OSX or iOS target has been specified, try to guess platform
592 // from arch name and compute the version from the triple.
593 if (OSXTarget.empty() && iOSTarget.empty() && TvOSTarget.empty() &&
594 WatchOSTarget.empty()) {
595 StringRef MachOArchName = getMachOArchName(Args);
596 unsigned Major, Minor, Micro;
597 if (MachOArchName == "armv7" || MachOArchName == "armv7s" ||
598 MachOArchName == "arm64") {
599 getTriple().getiOSVersion(Major, Minor, Micro);
600 llvm::raw_string_ostream(iOSTarget) << Major << '.' << Minor << '.'
602 } else if (MachOArchName == "armv7k") {
603 getTriple().getWatchOSVersion(Major, Minor, Micro);
604 llvm::raw_string_ostream(WatchOSTarget) << Major << '.' << Minor << '.'
606 } else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
607 MachOArchName != "armv7em") {
608 if (!getTriple().getMacOSXVersion(Major, Minor, Micro)) {
609 getDriver().Diag(diag::err_drv_invalid_darwin_version)
610 << getTriple().getOSName();
612 llvm::raw_string_ostream(OSXTarget) << Major << '.' << Minor << '.'
617 // Do not allow conflicts with the watchOS target.
618 if (!WatchOSTarget.empty() && (!iOSTarget.empty() || !TvOSTarget.empty())) {
619 getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
620 << "WATCHOS_DEPLOYMENT_TARGET"
621 << (!iOSTarget.empty() ? "IPHONEOS_DEPLOYMENT_TARGET" :
622 "TVOS_DEPLOYMENT_TARGET");
625 // Do not allow conflicts with the tvOS target.
626 if (!TvOSTarget.empty() && !iOSTarget.empty()) {
627 getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
628 << "TVOS_DEPLOYMENT_TARGET"
629 << "IPHONEOS_DEPLOYMENT_TARGET";
632 // Allow conflicts among OSX and iOS for historical reasons, but choose the
634 if (!OSXTarget.empty() && (!iOSTarget.empty() ||
635 !WatchOSTarget.empty() ||
636 !TvOSTarget.empty())) {
637 if (getTriple().getArch() == llvm::Triple::arm ||
638 getTriple().getArch() == llvm::Triple::aarch64 ||
639 getTriple().getArch() == llvm::Triple::thumb)
642 iOSTarget = WatchOSTarget = TvOSTarget = "";
645 if (!OSXTarget.empty()) {
646 const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
647 OSXVersion = Args.MakeJoinedArg(nullptr, O, OSXTarget);
648 Args.append(OSXVersion);
649 } else if (!iOSTarget.empty()) {
650 const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
651 iOSVersion = Args.MakeJoinedArg(nullptr, O, iOSTarget);
652 Args.append(iOSVersion);
653 } else if (!TvOSTarget.empty()) {
654 const Option O = Opts.getOption(options::OPT_mtvos_version_min_EQ);
655 TvOSVersion = Args.MakeJoinedArg(nullptr, O, TvOSTarget);
656 Args.append(TvOSVersion);
657 } else if (!WatchOSTarget.empty()) {
658 const Option O = Opts.getOption(options::OPT_mwatchos_version_min_EQ);
659 WatchOSVersion = Args.MakeJoinedArg(nullptr, O, WatchOSTarget);
660 Args.append(WatchOSVersion);
664 DarwinPlatformKind Platform;
669 else if (TvOSVersion)
671 else if (WatchOSVersion)
674 llvm_unreachable("Unable to infer Darwin variant");
676 // Set the tool chain target information.
677 unsigned Major, Minor, Micro;
679 if (Platform == MacOS) {
680 assert((!iOSVersion && !TvOSVersion && !WatchOSVersion) &&
681 "Unknown target platform!");
682 if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor, Micro,
684 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
685 getDriver().Diag(diag::err_drv_invalid_version_number)
686 << OSXVersion->getAsString(Args);
687 } else if (Platform == IPhoneOS) {
688 assert(iOSVersion && "Unknown target platform!");
689 if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, Micro,
691 HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
692 getDriver().Diag(diag::err_drv_invalid_version_number)
693 << iOSVersion->getAsString(Args);
694 } else if (Platform == TvOS) {
695 if (!Driver::GetReleaseVersion(TvOSVersion->getValue(), Major, Minor,
696 Micro, HadExtra) || HadExtra ||
697 Major >= 10 || Minor >= 100 || Micro >= 100)
698 getDriver().Diag(diag::err_drv_invalid_version_number)
699 << TvOSVersion->getAsString(Args);
700 } else if (Platform == WatchOS) {
701 if (!Driver::GetReleaseVersion(WatchOSVersion->getValue(), Major, Minor,
702 Micro, HadExtra) || HadExtra ||
703 Major >= 10 || Minor >= 100 || Micro >= 100)
704 getDriver().Diag(diag::err_drv_invalid_version_number)
705 << WatchOSVersion->getAsString(Args);
707 llvm_unreachable("unknown kind of Darwin platform");
709 // Recognize iOS targets with an x86 architecture as the iOS simulator.
710 if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
711 getTriple().getArch() == llvm::Triple::x86_64))
712 Platform = IPhoneOSSimulator;
713 if (TvOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
714 getTriple().getArch() == llvm::Triple::x86_64))
715 Platform = TvOSSimulator;
716 if (WatchOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
717 getTriple().getArch() == llvm::Triple::x86_64))
718 Platform = WatchOSSimulator;
720 setTarget(Platform, Major, Minor, Micro);
722 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
723 StringRef SDK = getSDKName(A->getValue());
724 if (SDK.size() > 0) {
725 size_t StartVer = SDK.find_first_of("0123456789");
726 StringRef SDKName = SDK.slice(0, StartVer);
727 if (!SDKName.startswith(getPlatformFamily()))
728 getDriver().Diag(diag::warn_incompatible_sysroot)
729 << SDKName << getPlatformFamily();
734 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
735 ArgStringList &CmdArgs) const {
736 CXXStdlibType Type = GetCXXStdlibType(Args);
739 case ToolChain::CST_Libcxx:
740 CmdArgs.push_back("-lc++");
743 case ToolChain::CST_Libstdcxx:
744 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
745 // it was previously found in the gcc lib dir. However, for all the Darwin
746 // platforms we care about it was -lstdc++.6, so we search for that
747 // explicitly if we can't see an obvious -lstdc++ candidate.
749 // Check in the sysroot first.
750 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
751 SmallString<128> P(A->getValue());
752 llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
754 if (!getVFS().exists(P)) {
755 llvm::sys::path::remove_filename(P);
756 llvm::sys::path::append(P, "libstdc++.6.dylib");
757 if (getVFS().exists(P)) {
758 CmdArgs.push_back(Args.MakeArgString(P));
764 // Otherwise, look in the root.
765 // FIXME: This should be removed someday when we don't have to care about
766 // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
767 if (!getVFS().exists("/usr/lib/libstdc++.dylib") &&
768 getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
769 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
773 // Otherwise, let the linker search.
774 CmdArgs.push_back("-lstdc++");
779 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
780 ArgStringList &CmdArgs) const {
781 // For Darwin platforms, use the compiler-rt-based support library
782 // instead of the gcc-provided one (which is also incidentally
783 // only present in the gcc lib dir, which makes it hard to find).
785 SmallString<128> P(getDriver().ResourceDir);
786 llvm::sys::path::append(P, "lib", "darwin");
788 // Use the newer cc_kext for iOS ARM after 6.0.
789 if (isTargetWatchOS()) {
790 llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
791 } else if (isTargetTvOS()) {
792 llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
793 } else if (isTargetIPhoneOS()) {
794 llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
796 llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
799 // For now, allow missing resource libraries to support developers who may
800 // not have compiler-rt checked out or integrated into their build.
801 if (getVFS().exists(P))
802 CmdArgs.push_back(Args.MakeArgString(P));
805 DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,
806 const char *BoundArch) const {
807 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
808 const OptTable &Opts = getDriver().getOpts();
810 // FIXME: We really want to get out of the tool chain level argument
811 // translation business, as it makes the driver functionality much
812 // more opaque. For now, we follow gcc closely solely for the
813 // purpose of easily achieving feature parity & testability. Once we
814 // have something that works, we should reevaluate each translation
815 // and try to push it down into tool specific logic.
817 for (Arg *A : Args) {
818 if (A->getOption().matches(options::OPT_Xarch__)) {
819 // Skip this argument unless the architecture matches either the toolchain
820 // triple arch, or the arch being bound.
821 llvm::Triple::ArchType XarchArch =
822 tools::darwin::getArchTypeForMachOArchName(A->getValue(0));
823 if (!(XarchArch == getArch() ||
826 tools::darwin::getArchTypeForMachOArchName(BoundArch))))
829 Arg *OriginalArg = A;
830 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
831 unsigned Prev = Index;
832 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
834 // If the argument parsing failed or more than one argument was
835 // consumed, the -Xarch_ argument's parameter tried to consume
836 // extra arguments. Emit an error and ignore.
838 // We also want to disallow any options which would alter the
839 // driver behavior; that isn't going to work in our model. We
840 // use isDriverOption() as an approximation, although things
841 // like -O4 are going to slip through.
842 if (!XarchArg || Index > Prev + 1) {
843 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
844 << A->getAsString(Args);
846 } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
847 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
848 << A->getAsString(Args);
852 XarchArg->setBaseArg(A);
854 A = XarchArg.release();
855 DAL->AddSynthesizedArg(A);
857 // Linker input arguments require custom handling. The problem is that we
858 // have already constructed the phase actions, so we can not treat them as
859 // "input arguments".
860 if (A->getOption().hasFlag(options::LinkerInput)) {
861 // Convert the argument into individual Zlinker_input_args.
862 for (const char *Value : A->getValues()) {
864 OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
870 // Sob. These is strictly gcc compatible for the time being. Apple
871 // gcc translates options twice, which means that self-expanding
872 // options add duplicates.
873 switch ((options::ID)A->getOption().getID()) {
878 case options::OPT_mkernel:
879 case options::OPT_fapple_kext:
881 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
884 case options::OPT_dependency_file:
885 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
888 case options::OPT_gfull:
889 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
891 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
894 case options::OPT_gused:
895 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
897 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
900 case options::OPT_shared:
901 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
904 case options::OPT_fconstant_cfstrings:
905 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
908 case options::OPT_fno_constant_cfstrings:
909 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
912 case options::OPT_Wnonportable_cfstrings:
914 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
917 case options::OPT_Wno_nonportable_cfstrings:
919 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
922 case options::OPT_fpascal_strings:
923 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
926 case options::OPT_fno_pascal_strings:
927 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
932 if (getTriple().getArch() == llvm::Triple::x86 ||
933 getTriple().getArch() == llvm::Triple::x86_64)
934 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
935 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mtune_EQ),
938 // Add the arch options based on the particular spelling of -arch, to match
939 // how the driver driver works.
941 StringRef Name = BoundArch;
942 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
943 const Option MArch = Opts.getOption(options::OPT_march_EQ);
945 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
946 // which defines the list of which architectures we accept.
949 else if (Name == "ppc601")
950 DAL->AddJoinedArg(nullptr, MCpu, "601");
951 else if (Name == "ppc603")
952 DAL->AddJoinedArg(nullptr, MCpu, "603");
953 else if (Name == "ppc604")
954 DAL->AddJoinedArg(nullptr, MCpu, "604");
955 else if (Name == "ppc604e")
956 DAL->AddJoinedArg(nullptr, MCpu, "604e");
957 else if (Name == "ppc750")
958 DAL->AddJoinedArg(nullptr, MCpu, "750");
959 else if (Name == "ppc7400")
960 DAL->AddJoinedArg(nullptr, MCpu, "7400");
961 else if (Name == "ppc7450")
962 DAL->AddJoinedArg(nullptr, MCpu, "7450");
963 else if (Name == "ppc970")
964 DAL->AddJoinedArg(nullptr, MCpu, "970");
966 else if (Name == "ppc64" || Name == "ppc64le")
967 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
969 else if (Name == "i386")
971 else if (Name == "i486")
972 DAL->AddJoinedArg(nullptr, MArch, "i486");
973 else if (Name == "i586")
974 DAL->AddJoinedArg(nullptr, MArch, "i586");
975 else if (Name == "i686")
976 DAL->AddJoinedArg(nullptr, MArch, "i686");
977 else if (Name == "pentium")
978 DAL->AddJoinedArg(nullptr, MArch, "pentium");
979 else if (Name == "pentium2")
980 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
981 else if (Name == "pentpro")
982 DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
983 else if (Name == "pentIIm3")
984 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
986 else if (Name == "x86_64")
987 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
988 else if (Name == "x86_64h") {
989 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
990 DAL->AddJoinedArg(nullptr, MArch, "x86_64h");
993 else if (Name == "arm")
994 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
995 else if (Name == "armv4t")
996 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
997 else if (Name == "armv5")
998 DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
999 else if (Name == "xscale")
1000 DAL->AddJoinedArg(nullptr, MArch, "xscale");
1001 else if (Name == "armv6")
1002 DAL->AddJoinedArg(nullptr, MArch, "armv6k");
1003 else if (Name == "armv6m")
1004 DAL->AddJoinedArg(nullptr, MArch, "armv6m");
1005 else if (Name == "armv7")
1006 DAL->AddJoinedArg(nullptr, MArch, "armv7a");
1007 else if (Name == "armv7em")
1008 DAL->AddJoinedArg(nullptr, MArch, "armv7em");
1009 else if (Name == "armv7k")
1010 DAL->AddJoinedArg(nullptr, MArch, "armv7k");
1011 else if (Name == "armv7m")
1012 DAL->AddJoinedArg(nullptr, MArch, "armv7m");
1013 else if (Name == "armv7s")
1014 DAL->AddJoinedArg(nullptr, MArch, "armv7s");
1020 void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
1021 ArgStringList &CmdArgs) const {
1022 // Embedded targets are simple at the moment, not supporting sanitizers and
1023 // with different libraries for each member of the product { static, PIC } x
1024 // { hard-float, soft-float }
1025 llvm::SmallString<32> CompilerRT = StringRef("libclang_rt.");
1027 (tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard)
1030 CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a";
1032 AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, false, true);
1035 DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
1036 const char *BoundArch) const {
1037 // First get the generic Apple args, before moving onto Darwin-specific ones.
1038 DerivedArgList *DAL = MachO::TranslateArgs(Args, BoundArch);
1039 const OptTable &Opts = getDriver().getOpts();
1041 // If no architecture is bound, none of the translations here are relevant.
1045 // Add an explicit version min argument for the deployment target. We do this
1046 // after argument translation because -Xarch_ arguments may add a version min
1048 AddDeploymentTarget(*DAL);
1050 // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
1051 // FIXME: It would be far better to avoid inserting those -static arguments,
1052 // but we can't check the deployment target in the translation code until
1054 if (isTargetWatchOSBased() ||
1055 (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) {
1056 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
1059 if (A->getOption().getID() != options::OPT_mkernel &&
1060 A->getOption().getID() != options::OPT_fapple_kext)
1062 assert(it != ie && "unexpected argument translation");
1064 assert(A->getOption().getID() == options::OPT_static &&
1065 "missing expected -static argument");
1066 it = DAL->getArgs().erase(it);
1070 if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
1071 GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
1072 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ),
1075 // Validate the C++ standard library choice.
1076 CXXStdlibType Type = GetCXXStdlibType(*DAL);
1077 if (Type == ToolChain::CST_Libcxx) {
1078 // Check whether the target provides libc++.
1081 // Complain about targeting iOS < 5.0 in any way.
1082 if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0))
1085 if (where != StringRef()) {
1086 getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
1093 bool MachO::IsUnwindTablesDefault() const {
1094 return getArch() == llvm::Triple::x86_64;
1097 bool MachO::UseDwarfDebugFlags() const {
1098 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
1099 return S[0] != '\0';
1103 bool Darwin::UseSjLjExceptions(const ArgList &Args) const {
1104 // Darwin uses SjLj exceptions on ARM.
1105 if (getTriple().getArch() != llvm::Triple::arm &&
1106 getTriple().getArch() != llvm::Triple::thumb)
1109 // Only watchOS uses the new DWARF/Compact unwinding method.
1110 llvm::Triple Triple(ComputeLLVMTriple(Args));
1111 return !Triple.isWatchABI();
1114 bool Darwin::SupportsEmbeddedBitcode() const {
1115 assert(TargetInitialized && "Target not initialized!");
1116 if (isTargetIPhoneOS() && isIPhoneOSVersionLT(6, 0))
1121 bool MachO::isPICDefault() const { return true; }
1123 bool MachO::isPIEDefault() const { return false; }
1125 bool MachO::isPICDefaultForced() const {
1126 return (getArch() == llvm::Triple::x86_64 ||
1127 getArch() == llvm::Triple::aarch64);
1130 bool MachO::SupportsProfiling() const {
1131 // Profiling instrumentation is only supported on x86.
1132 return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
1135 void Darwin::addMinVersionArgs(const ArgList &Args,
1136 ArgStringList &CmdArgs) const {
1137 VersionTuple TargetVersion = getTargetVersion();
1139 if (isTargetWatchOS())
1140 CmdArgs.push_back("-watchos_version_min");
1141 else if (isTargetWatchOSSimulator())
1142 CmdArgs.push_back("-watchos_simulator_version_min");
1143 else if (isTargetTvOS())
1144 CmdArgs.push_back("-tvos_version_min");
1145 else if (isTargetTvOSSimulator())
1146 CmdArgs.push_back("-tvos_simulator_version_min");
1147 else if (isTargetIOSSimulator())
1148 CmdArgs.push_back("-ios_simulator_version_min");
1149 else if (isTargetIOSBased())
1150 CmdArgs.push_back("-iphoneos_version_min");
1152 assert(isTargetMacOS() && "unexpected target");
1153 CmdArgs.push_back("-macosx_version_min");
1156 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
1159 void Darwin::addStartObjectFileArgs(const ArgList &Args,
1160 ArgStringList &CmdArgs) const {
1161 // Derived from startfile spec.
1162 if (Args.hasArg(options::OPT_dynamiclib)) {
1163 // Derived from darwin_dylib1 spec.
1164 if (isTargetWatchOSBased()) {
1165 ; // watchOS does not need dylib1.o.
1166 } else if (isTargetIOSSimulator()) {
1167 ; // iOS simulator does not need dylib1.o.
1168 } else if (isTargetIPhoneOS()) {
1169 if (isIPhoneOSVersionLT(3, 1))
1170 CmdArgs.push_back("-ldylib1.o");
1172 if (isMacosxVersionLT(10, 5))
1173 CmdArgs.push_back("-ldylib1.o");
1174 else if (isMacosxVersionLT(10, 6))
1175 CmdArgs.push_back("-ldylib1.10.5.o");
1178 if (Args.hasArg(options::OPT_bundle)) {
1179 if (!Args.hasArg(options::OPT_static)) {
1180 // Derived from darwin_bundle1 spec.
1181 if (isTargetWatchOSBased()) {
1182 ; // watchOS does not need bundle1.o.
1183 } else if (isTargetIOSSimulator()) {
1184 ; // iOS simulator does not need bundle1.o.
1185 } else if (isTargetIPhoneOS()) {
1186 if (isIPhoneOSVersionLT(3, 1))
1187 CmdArgs.push_back("-lbundle1.o");
1189 if (isMacosxVersionLT(10, 6))
1190 CmdArgs.push_back("-lbundle1.o");
1194 if (Args.hasArg(options::OPT_pg) && SupportsProfiling()) {
1195 if (Args.hasArg(options::OPT_static) ||
1196 Args.hasArg(options::OPT_object) ||
1197 Args.hasArg(options::OPT_preload)) {
1198 CmdArgs.push_back("-lgcrt0.o");
1200 CmdArgs.push_back("-lgcrt1.o");
1202 // darwin_crt2 spec is empty.
1204 // By default on OS X 10.8 and later, we don't link with a crt1.o
1205 // file and the linker knows to use _main as the entry point. But,
1206 // when compiling with -pg, we need to link with the gcrt1.o file,
1207 // so pass the -no_new_main option to tell the linker to use the
1208 // "start" symbol as the entry point.
1209 if (isTargetMacOS() && !isMacosxVersionLT(10, 8))
1210 CmdArgs.push_back("-no_new_main");
1212 if (Args.hasArg(options::OPT_static) ||
1213 Args.hasArg(options::OPT_object) ||
1214 Args.hasArg(options::OPT_preload)) {
1215 CmdArgs.push_back("-lcrt0.o");
1217 // Derived from darwin_crt1 spec.
1218 if (isTargetWatchOSBased()) {
1219 ; // watchOS does not need crt1.o.
1220 } else if (isTargetIOSSimulator()) {
1221 ; // iOS simulator does not need crt1.o.
1222 } else if (isTargetIPhoneOS()) {
1223 if (getArch() == llvm::Triple::aarch64)
1224 ; // iOS does not need any crt1 files for arm64
1225 else if (isIPhoneOSVersionLT(3, 1))
1226 CmdArgs.push_back("-lcrt1.o");
1227 else if (isIPhoneOSVersionLT(6, 0))
1228 CmdArgs.push_back("-lcrt1.3.1.o");
1230 if (isMacosxVersionLT(10, 5))
1231 CmdArgs.push_back("-lcrt1.o");
1232 else if (isMacosxVersionLT(10, 6))
1233 CmdArgs.push_back("-lcrt1.10.5.o");
1234 else if (isMacosxVersionLT(10, 8))
1235 CmdArgs.push_back("-lcrt1.10.6.o");
1237 // darwin_crt2 spec is empty.
1244 if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) &&
1245 !isTargetWatchOS() &&
1246 isMacosxVersionLT(10, 5)) {
1247 const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
1248 CmdArgs.push_back(Str);
1252 bool Darwin::SupportsObjCGC() const { return isTargetMacOS(); }
1254 void Darwin::CheckObjCARC() const {
1255 if (isTargetIOSBased() || isTargetWatchOSBased() ||
1256 (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
1258 getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
1261 SanitizerMask Darwin::getSupportedSanitizers() const {
1262 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
1263 SanitizerMask Res = ToolChain::getSupportedSanitizers();
1264 Res |= SanitizerKind::Address;
1265 if (isTargetMacOS()) {
1266 if (!isMacosxVersionLT(10, 9))
1267 Res |= SanitizerKind::Vptr;
1268 Res |= SanitizerKind::SafeStack;
1270 Res |= SanitizerKind::Thread;
1271 } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) {
1273 Res |= SanitizerKind::Thread;
1278 /// Generic_GCC - A tool chain using the 'gcc' command to perform
1279 /// all subcommands; this relies on gcc translating the majority of
1280 /// command line options.
1282 /// \brief Parse a GCCVersion object out of a string of text.
1284 /// This is the primary means of forming GCCVersion objects.
1286 Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) {
1287 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1288 std::pair<StringRef, StringRef> First = VersionText.split('.');
1289 std::pair<StringRef, StringRef> Second = First.second.split('.');
1291 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1292 if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
1294 GoodVersion.MajorStr = First.first.str();
1295 if (First.second.empty())
1297 if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
1299 GoodVersion.MinorStr = Second.first.str();
1301 // First look for a number prefix and parse that if present. Otherwise just
1302 // stash the entire patch string in the suffix, and leave the number
1303 // unspecified. This covers versions strings such as:
1304 // 5 (handled above)
1310 // And retains any patch number it finds.
1311 StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
1312 if (!PatchText.empty()) {
1313 if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
1314 // Try to parse the number and any suffix.
1315 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1316 GoodVersion.Patch < 0)
1318 GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
1325 /// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering.
1326 bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor,
1328 StringRef RHSPatchSuffix) const {
1329 if (Major != RHSMajor)
1330 return Major < RHSMajor;
1331 if (Minor != RHSMinor)
1332 return Minor < RHSMinor;
1333 if (Patch != RHSPatch) {
1334 // Note that versions without a specified patch sort higher than those with
1341 // Otherwise just sort on the patch itself.
1342 return Patch < RHSPatch;
1344 if (PatchSuffix != RHSPatchSuffix) {
1345 // Sort empty suffixes higher.
1346 if (RHSPatchSuffix.empty())
1348 if (PatchSuffix.empty())
1351 // Provide a lexicographic sort to make this a total ordering.
1352 return PatchSuffix < RHSPatchSuffix;
1355 // The versions are equal.
1359 static llvm::StringRef getGCCToolchainDir(const ArgList &Args) {
1360 const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
1362 return A->getValue();
1363 return GCC_INSTALL_PREFIX;
1366 /// \brief Initialize a GCCInstallationDetector from the driver.
1368 /// This performs all of the autodetection and sets up the various paths.
1369 /// Once constructed, a GCCInstallationDetector is essentially immutable.
1371 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
1372 /// should instead pull the target out of the driver. This is currently
1373 /// necessary because the driver doesn't store the final version of the target
1375 void Generic_GCC::GCCInstallationDetector::init(
1376 const llvm::Triple &TargetTriple, const ArgList &Args,
1377 ArrayRef<std::string> ExtraTripleAliases) {
1378 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1379 ? TargetTriple.get64BitArchVariant()
1380 : TargetTriple.get32BitArchVariant();
1381 // The library directories which may contain GCC installations.
1382 SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
1383 // The compatible GCC triples for this particular architecture.
1384 SmallVector<StringRef, 16> CandidateTripleAliases;
1385 SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
1386 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1387 CandidateTripleAliases, CandidateBiarchLibDirs,
1388 CandidateBiarchTripleAliases);
1390 // Compute the set of prefixes for our search.
1391 SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1392 D.PrefixDirs.end());
1394 StringRef GCCToolchainDir = getGCCToolchainDir(Args);
1395 if (GCCToolchainDir != "") {
1396 if (GCCToolchainDir.back() == '/')
1397 GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1399 Prefixes.push_back(GCCToolchainDir);
1401 // If we have a SysRoot, try that first.
1402 if (!D.SysRoot.empty()) {
1403 Prefixes.push_back(D.SysRoot);
1404 Prefixes.push_back(D.SysRoot + "/usr");
1407 // Then look for gcc installed alongside clang.
1408 Prefixes.push_back(D.InstalledDir + "/..");
1410 // Then look for distribution supplied gcc installations.
1411 if (D.SysRoot.empty()) {
1412 // Look for RHEL devtoolsets.
1413 Prefixes.push_back("/opt/rh/devtoolset-4/root/usr");
1414 Prefixes.push_back("/opt/rh/devtoolset-3/root/usr");
1415 Prefixes.push_back("/opt/rh/devtoolset-2/root/usr");
1416 Prefixes.push_back("/opt/rh/devtoolset-1.1/root/usr");
1417 Prefixes.push_back("/opt/rh/devtoolset-1.0/root/usr");
1418 // And finally in /usr.
1419 Prefixes.push_back("/usr");
1423 // Loop over the various components which exist and select the best GCC
1424 // installation available. GCC installs are ranked by version number.
1425 Version = GCCVersion::Parse("0.0.0");
1426 for (const std::string &Prefix : Prefixes) {
1427 if (!D.getVFS().exists(Prefix))
1429 for (StringRef Suffix : CandidateLibDirs) {
1430 const std::string LibDir = Prefix + Suffix.str();
1431 if (!D.getVFS().exists(LibDir))
1433 for (StringRef Candidate : ExtraTripleAliases) // Try these first.
1434 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1435 for (StringRef Candidate : CandidateTripleAliases)
1436 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1438 for (StringRef Suffix : CandidateBiarchLibDirs) {
1439 const std::string LibDir = Prefix + Suffix.str();
1440 if (!D.getVFS().exists(LibDir))
1442 for (StringRef Candidate : CandidateBiarchTripleAliases)
1443 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1444 /*NeedsBiarchSuffix=*/ true);
1449 void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
1450 for (const auto &InstallPath : CandidateGCCInstallPaths)
1451 OS << "Found candidate GCC installation: " << InstallPath << "\n";
1453 if (!GCCInstallPath.empty())
1454 OS << "Selected GCC installation: " << GCCInstallPath << "\n";
1456 for (const auto &Multilib : Multilibs)
1457 OS << "Candidate multilib: " << Multilib << "\n";
1459 if (Multilibs.size() != 0 || !SelectedMultilib.isDefault())
1460 OS << "Selected multilib: " << SelectedMultilib << "\n";
1463 bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
1464 if (BiarchSibling.hasValue()) {
1465 M = BiarchSibling.getValue();
1471 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1472 const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
1473 SmallVectorImpl<StringRef> &LibDirs,
1474 SmallVectorImpl<StringRef> &TripleAliases,
1475 SmallVectorImpl<StringRef> &BiarchLibDirs,
1476 SmallVectorImpl<StringRef> &BiarchTripleAliases) {
1477 // Declare a bunch of static data sets that we'll select between below. These
1478 // are specifically designed to always refer to string literals to avoid any
1479 // lifetime or initialization issues.
1480 static const char *const AArch64LibDirs[] = {"/lib64", "/lib"};
1481 static const char *const AArch64Triples[] = {
1482 "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-linux-android",
1483 "aarch64-redhat-linux"};
1484 static const char *const AArch64beLibDirs[] = {"/lib"};
1485 static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu",
1486 "aarch64_be-linux-gnu"};
1488 static const char *const ARMLibDirs[] = {"/lib"};
1489 static const char *const ARMTriples[] = {"arm-linux-gnueabi",
1490 "arm-linux-androideabi"};
1491 static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf",
1492 "armv7hl-redhat-linux-gnueabi"};
1493 static const char *const ARMebLibDirs[] = {"/lib"};
1494 static const char *const ARMebTriples[] = {"armeb-linux-gnueabi",
1495 "armeb-linux-androideabi"};
1496 static const char *const ARMebHFTriples[] = {
1497 "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"};
1499 static const char *const X86_64LibDirs[] = {"/lib64", "/lib"};
1500 static const char *const X86_64Triples[] = {
1501 "x86_64-linux-gnu", "x86_64-unknown-linux-gnu",
1502 "x86_64-pc-linux-gnu", "x86_64-redhat-linux6E",
1503 "x86_64-redhat-linux", "x86_64-suse-linux",
1504 "x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
1505 "x86_64-slackware-linux", "x86_64-linux-android",
1506 "x86_64-unknown-linux"};
1507 static const char *const X32LibDirs[] = {"/libx32"};
1508 static const char *const X86LibDirs[] = {"/lib32", "/lib"};
1509 static const char *const X86Triples[] = {
1510 "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu",
1511 "i386-linux-gnu", "i386-redhat-linux6E", "i686-redhat-linux",
1512 "i586-redhat-linux", "i386-redhat-linux", "i586-suse-linux",
1513 "i486-slackware-linux", "i686-montavista-linux", "i686-linux-android",
1516 static const char *const MIPSLibDirs[] = {"/lib"};
1517 static const char *const MIPSTriples[] = {"mips-linux-gnu", "mips-mti-linux",
1518 "mips-mti-linux-gnu",
1519 "mips-img-linux-gnu"};
1520 static const char *const MIPSELLibDirs[] = {"/lib"};
1521 static const char *const MIPSELTriples[] = {
1522 "mipsel-linux-gnu", "mipsel-linux-android", "mips-img-linux-gnu"};
1524 static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"};
1525 static const char *const MIPS64Triples[] = {
1526 "mips64-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu",
1527 "mips64-linux-gnuabi64"};
1528 static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"};
1529 static const char *const MIPS64ELTriples[] = {
1530 "mips64el-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu",
1531 "mips64el-linux-android", "mips64el-linux-gnuabi64"};
1533 static const char *const PPCLibDirs[] = {"/lib32", "/lib"};
1534 static const char *const PPCTriples[] = {
1535 "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
1536 "powerpc-suse-linux", "powerpc-montavista-linuxspe"};
1537 static const char *const PPC64LibDirs[] = {"/lib64", "/lib"};
1538 static const char *const PPC64Triples[] = {
1539 "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu",
1540 "powerpc64-suse-linux", "ppc64-redhat-linux"};
1541 static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"};
1542 static const char *const PPC64LETriples[] = {
1543 "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu",
1544 "powerpc64le-suse-linux", "ppc64le-redhat-linux"};
1546 static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"};
1547 static const char *const SPARCv8Triples[] = {"sparc-linux-gnu",
1548 "sparcv8-linux-gnu"};
1549 static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"};
1550 static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",
1551 "sparcv9-linux-gnu"};
1553 static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};
1554 static const char *const SystemZTriples[] = {
1555 "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
1556 "s390x-suse-linux", "s390x-redhat-linux"};
1559 static const char *const SolarisSPARCLibDirs[] = {"/gcc"};
1560 static const char *const SolarisSPARCTriples[] = {"sparc-sun-solaris2.11",
1561 "i386-pc-solaris2.11"};
1566 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1567 LibDirs.append(begin(SolarisSPARCLibDirs), end(SolarisSPARCLibDirs));
1568 TripleAliases.append(begin(SolarisSPARCTriples), end(SolarisSPARCTriples));
1572 switch (TargetTriple.getArch()) {
1573 case llvm::Triple::aarch64:
1574 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1575 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1576 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1577 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1579 case llvm::Triple::aarch64_be:
1580 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1581 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1582 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1583 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1585 case llvm::Triple::arm:
1586 case llvm::Triple::thumb:
1587 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
1588 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1589 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
1591 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
1594 case llvm::Triple::armeb:
1595 case llvm::Triple::thumbeb:
1596 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
1597 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1598 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
1600 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
1603 case llvm::Triple::x86_64:
1604 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1605 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1606 // x32 is always available when x86_64 is available, so adding it as
1607 // secondary arch with x86_64 triples
1608 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
1609 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
1610 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1612 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1613 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
1616 case llvm::Triple::x86:
1617 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1618 // MCU toolchain is 32 bit only and its triple alias is TargetTriple
1619 // itself, which will be appended below.
1620 if (!TargetTriple.isOSIAMCU()) {
1621 TripleAliases.append(begin(X86Triples), end(X86Triples));
1622 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1623 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1626 case llvm::Triple::mips:
1627 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1628 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1629 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1630 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1632 case llvm::Triple::mipsel:
1633 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1634 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1635 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1636 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1637 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1639 case llvm::Triple::mips64:
1640 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1641 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1642 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1643 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1645 case llvm::Triple::mips64el:
1646 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1647 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1648 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1649 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1650 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1652 case llvm::Triple::ppc:
1653 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1654 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
1655 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1656 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1658 case llvm::Triple::ppc64:
1659 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1660 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1661 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1662 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
1664 case llvm::Triple::ppc64le:
1665 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
1666 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
1668 case llvm::Triple::sparc:
1669 case llvm::Triple::sparcel:
1670 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1671 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1672 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1673 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1675 case llvm::Triple::sparcv9:
1676 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1677 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1678 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1679 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1681 case llvm::Triple::systemz:
1682 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
1683 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
1686 // By default, just rely on the standard lib directories and the original
1691 // Always append the drivers target triple to the end, in case it doesn't
1692 // match any of our aliases.
1693 TripleAliases.push_back(TargetTriple.str());
1695 // Also include the multiarch variant if it's different.
1696 if (TargetTriple.str() != BiarchTriple.str())
1697 BiarchTripleAliases.push_back(BiarchTriple.str());
1700 // Parses the contents of version.txt in an CUDA installation. It should
1701 // contain one line of the from e.g. "CUDA Version 7.5.2".
1702 static CudaVersion ParseCudaVersionFile(llvm::StringRef V) {
1703 if (!V.startswith("CUDA Version "))
1704 return CudaVersion::UNKNOWN;
1705 V = V.substr(strlen("CUDA Version "));
1706 int Major = -1, Minor = -1;
1707 auto First = V.split('.');
1708 auto Second = First.second.split('.');
1709 if (!First.first.getAsInteger(10, Major) ||
1710 !Second.first.getAsInteger(10, Minor))
1711 return CudaVersion::UNKNOWN;
1713 if (Major == 7 && Minor == 0) {
1714 // This doesn't appear to ever happen -- version.txt doesn't exist in the
1715 // CUDA 7 installs I've seen. But no harm in checking.
1716 return CudaVersion::CUDA_70;
1718 if (Major == 7 && Minor == 5)
1719 return CudaVersion::CUDA_75;
1720 if (Major == 8 && Minor == 0)
1721 return CudaVersion::CUDA_80;
1722 return CudaVersion::UNKNOWN;
1725 // \brief -- try common CUDA installation paths looking for files we need for
1726 // CUDA compilation.
1727 void Generic_GCC::CudaInstallationDetector::init(
1728 const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args) {
1729 SmallVector<std::string, 4> CudaPathCandidates;
1731 if (Args.hasArg(options::OPT_cuda_path_EQ))
1732 CudaPathCandidates.push_back(
1733 Args.getLastArgValue(options::OPT_cuda_path_EQ));
1735 CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda");
1736 // FIXME: Uncomment this once we can compile the cuda 8 headers.
1737 // CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-8.0");
1738 CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-7.5");
1739 CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-7.0");
1742 for (const auto &CudaPath : CudaPathCandidates) {
1743 if (CudaPath.empty() || !D.getVFS().exists(CudaPath))
1746 InstallPath = CudaPath;
1747 BinPath = CudaPath + "/bin";
1748 IncludePath = InstallPath + "/include";
1749 LibDevicePath = InstallPath + "/nvvm/libdevice";
1750 LibPath = InstallPath + (TargetTriple.isArch64Bit() ? "/lib64" : "/lib");
1752 auto &FS = D.getVFS();
1753 if (!(FS.exists(IncludePath) && FS.exists(BinPath) && FS.exists(LibPath) &&
1754 FS.exists(LibDevicePath)))
1758 for (llvm::sys::fs::directory_iterator LI(LibDevicePath, EC), LE;
1759 !EC && LI != LE; LI = LI.increment(EC)) {
1760 StringRef FilePath = LI->path();
1761 StringRef FileName = llvm::sys::path::filename(FilePath);
1762 // Process all bitcode filenames that look like libdevice.compute_XX.YY.bc
1763 const StringRef LibDeviceName = "libdevice.";
1764 if (!(FileName.startswith(LibDeviceName) && FileName.endswith(".bc")))
1766 StringRef GpuArch = FileName.slice(
1767 LibDeviceName.size(), FileName.find('.', LibDeviceName.size()));
1768 LibDeviceMap[GpuArch] = FilePath.str();
1769 // Insert map entries for specifc devices with this compute capability.
1770 if (GpuArch == "compute_20") {
1771 LibDeviceMap["sm_20"] = FilePath;
1772 LibDeviceMap["sm_21"] = FilePath;
1773 } else if (GpuArch == "compute_30") {
1774 LibDeviceMap["sm_30"] = FilePath;
1775 LibDeviceMap["sm_32"] = FilePath;
1776 } else if (GpuArch == "compute_35") {
1777 LibDeviceMap["sm_35"] = FilePath;
1778 LibDeviceMap["sm_37"] = FilePath;
1779 } else if (GpuArch == "compute_50") {
1780 LibDeviceMap["sm_50"] = FilePath;
1781 LibDeviceMap["sm_52"] = FilePath;
1782 LibDeviceMap["sm_53"] = FilePath;
1783 LibDeviceMap["sm_60"] = FilePath;
1784 LibDeviceMap["sm_61"] = FilePath;
1785 LibDeviceMap["sm_62"] = FilePath;
1789 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> VersionFile =
1790 FS.getBufferForFile(InstallPath + "/version.txt");
1792 // CUDA 7.0 doesn't have a version.txt, so guess that's our version if
1793 // version.txt isn't present.
1794 Version = CudaVersion::CUDA_70;
1796 Version = ParseCudaVersionFile((*VersionFile)->getBuffer());
1804 void Generic_GCC::CudaInstallationDetector::CheckCudaVersionSupportsArch(
1805 CudaArch Arch) const {
1806 if (Arch == CudaArch::UNKNOWN || Version == CudaVersion::UNKNOWN ||
1807 ArchsWithVersionTooLowErrors.count(Arch) > 0)
1810 auto RequiredVersion = MinVersionForCudaArch(Arch);
1811 if (Version < RequiredVersion) {
1812 ArchsWithVersionTooLowErrors.insert(Arch);
1813 D.Diag(diag::err_drv_cuda_version_too_low)
1814 << InstallPath << CudaArchToString(Arch) << CudaVersionToString(Version)
1815 << CudaVersionToString(RequiredVersion);
1819 void Generic_GCC::CudaInstallationDetector::print(raw_ostream &OS) const {
1821 OS << "Found CUDA installation: " << InstallPath << ", version "
1822 << CudaVersionToString(Version) << "\n";
1826 // Filter to remove Multilibs that don't exist as a suffix to Path
1827 class FilterNonExistent {
1828 StringRef Base, File;
1829 vfs::FileSystem &VFS;
1832 FilterNonExistent(StringRef Base, StringRef File, vfs::FileSystem &VFS)
1833 : Base(Base), File(File), VFS(VFS) {}
1834 bool operator()(const Multilib &M) {
1835 return !VFS.exists(Base + M.gccSuffix() + File);
1838 } // end anonymous namespace
1840 static void addMultilibFlag(bool Enabled, const char *const Flag,
1841 std::vector<std::string> &Flags) {
1843 Flags.push_back(std::string("+") + Flag);
1845 Flags.push_back(std::string("-") + Flag);
1848 static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) {
1849 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
1852 static bool isMipsArch(llvm::Triple::ArchType Arch) {
1853 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
1854 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1857 static bool isMips32(llvm::Triple::ArchType Arch) {
1858 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel;
1861 static bool isMips64(llvm::Triple::ArchType Arch) {
1862 return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1865 static bool isMipsEL(llvm::Triple::ArchType Arch) {
1866 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1869 static bool isMips16(const ArgList &Args) {
1870 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
1871 return A && A->getOption().matches(options::OPT_mips16);
1874 static bool isMicroMips(const ArgList &Args) {
1875 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
1876 return A && A->getOption().matches(options::OPT_mmicromips);
1880 struct DetectedMultilibs {
1881 /// The set of multilibs that the detected installation supports.
1882 MultilibSet Multilibs;
1884 /// The primary multilib appropriate for the given flags.
1885 Multilib SelectedMultilib;
1887 /// On Biarch systems, this corresponds to the default multilib when
1888 /// targeting the non-default multilib. Otherwise, it is empty.
1889 llvm::Optional<Multilib> BiarchSibling;
1891 } // end anonymous namespace
1893 static Multilib makeMultilib(StringRef commonSuffix) {
1894 return Multilib(commonSuffix, commonSuffix, commonSuffix);
1897 static bool findMipsCsMultilibs(const Multilib::flags_list &Flags,
1898 FilterNonExistent &NonExistent,
1899 DetectedMultilibs &Result) {
1900 // Check for Code Sourcery toolchain multilibs
1901 MultilibSet CSMipsMultilibs;
1903 auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16");
1905 auto MArchMicroMips =
1906 makeMultilib("/micromips").flag("+m32").flag("+mmicromips");
1908 auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips");
1910 auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
1912 auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float");
1914 auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
1917 makeMultilib("").flag("-msoft-float").flag("-mnan=2008");
1919 auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
1921 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1923 // Note that this one's osSuffix is ""
1924 auto MAbi64 = makeMultilib("")
1926 .includeSuffix("/64")
1933 .Either(MArchMips16, MArchMicroMips, MArchDefault)
1935 .Either(SoftFloat, Nan2008, DefaultFloat)
1936 .FilterOut("/micromips/nan2008")
1937 .FilterOut("/mips16/nan2008")
1938 .Either(BigEndian, LittleEndian)
1940 .FilterOut("/mips16.*/64")
1941 .FilterOut("/micromips.*/64")
1942 .FilterOut(NonExistent)
1943 .setIncludeDirsCallback([](const Multilib &M) {
1944 std::vector<std::string> Dirs({"/include"});
1945 if (StringRef(M.includeSuffix()).startswith("/uclibc"))
1947 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1949 Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include");
1954 MultilibSet DebianMipsMultilibs;
1957 Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32");
1959 Multilib M64 = Multilib()
1961 .includeSuffix("/64")
1966 Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32");
1968 DebianMipsMultilibs =
1969 MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent);
1972 // Sort candidates. Toolchain that best meets the directories tree goes first.
1973 // Then select the first toolchains matches command line flags.
1974 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1975 if (CSMipsMultilibs.size() < DebianMipsMultilibs.size())
1976 std::iter_swap(Candidates, Candidates + 1);
1977 for (const MultilibSet *Candidate : Candidates) {
1978 if (Candidate->select(Flags, Result.SelectedMultilib)) {
1979 if (Candidate == &DebianMipsMultilibs)
1980 Result.BiarchSibling = Multilib();
1981 Result.Multilibs = *Candidate;
1988 static bool findMipsAndroidMultilibs(const Multilib::flags_list &Flags,
1989 FilterNonExistent &NonExistent,
1990 DetectedMultilibs &Result) {
1992 MultilibSet AndroidMipsMultilibs =
1994 .Maybe(Multilib("/mips-r2").flag("+march=mips32r2"))
1995 .Maybe(Multilib("/mips-r6").flag("+march=mips32r6"))
1996 .FilterOut(NonExistent);
1998 if (AndroidMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
1999 Result.Multilibs = AndroidMipsMultilibs;
2005 static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags,
2006 FilterNonExistent &NonExistent,
2007 DetectedMultilibs &Result) {
2008 // Musl toolchain multilibs
2009 MultilibSet MuslMipsMultilibs;
2011 auto MArchMipsR2 = makeMultilib("")
2012 .osSuffix("/mips-r2-hard-musl")
2015 .flag("+march=mips32r2");
2017 auto MArchMipselR2 = makeMultilib("/mipsel-r2-hard-musl")
2020 .flag("+march=mips32r2");
2022 MuslMipsMultilibs = MultilibSet().Either(MArchMipsR2, MArchMipselR2);
2024 // Specify the callback that computes the include directories.
2025 MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) {
2026 return std::vector<std::string>(
2027 {"/../sysroot" + M.osSuffix() + "/usr/include"});
2030 if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
2031 Result.Multilibs = MuslMipsMultilibs;
2037 static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags,
2038 FilterNonExistent &NonExistent,
2039 DetectedMultilibs &Result) {
2040 // CodeScape MTI toolchain v1.2 and early.
2041 MultilibSet MtiMipsMultilibsV1;
2043 auto MArchMips32 = makeMultilib("/mips32")
2046 .flag("-mmicromips")
2047 .flag("+march=mips32");
2049 auto MArchMicroMips = makeMultilib("/micromips")
2052 .flag("+mmicromips");
2054 auto MArchMips64r2 = makeMultilib("/mips64r2")
2057 .flag("+march=mips64r2");
2059 auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag(
2062 auto MArchDefault = makeMultilib("")
2065 .flag("-mmicromips")
2066 .flag("+march=mips32r2");
2068 auto Mips16 = makeMultilib("/mips16").flag("+mips16");
2070 auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
2073 makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
2075 auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
2077 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
2079 auto SoftFloat = makeMultilib("/sof").flag("+msoft-float");
2081 auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
2083 MtiMipsMultilibsV1 =
2085 .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
2089 .FilterOut("/mips64/mips16")
2090 .FilterOut("/mips64r2/mips16")
2091 .FilterOut("/micromips/mips16")
2093 .FilterOut("/micromips/64")
2094 .FilterOut("/mips32/64")
2096 .FilterOut("/mips16/64")
2097 .Either(BigEndian, LittleEndian)
2100 .FilterOut(".*sof/nan2008")
2101 .FilterOut(NonExistent)
2102 .setIncludeDirsCallback([](const Multilib &M) {
2103 std::vector<std::string> Dirs({"/include"});
2104 if (StringRef(M.includeSuffix()).startswith("/uclibc"))
2105 Dirs.push_back("/../../../../sysroot/uclibc/usr/include");
2107 Dirs.push_back("/../../../../sysroot/usr/include");
2112 // CodeScape IMG toolchain starting from v1.3.
2113 MultilibSet MtiMipsMultilibsV2;
2115 auto BeHard = makeMultilib("/mips-r2-hard")
2117 .flag("-msoft-float")
2120 auto BeSoft = makeMultilib("/mips-r2-soft")
2122 .flag("+msoft-float")
2123 .flag("-mnan=2008");
2124 auto ElHard = makeMultilib("/mipsel-r2-hard")
2126 .flag("-msoft-float")
2129 auto ElSoft = makeMultilib("/mipsel-r2-soft")
2131 .flag("+msoft-float")
2133 .flag("-mmicromips");
2134 auto BeHardNan = makeMultilib("/mips-r2-hard-nan2008")
2136 .flag("-msoft-float")
2139 auto ElHardNan = makeMultilib("/mipsel-r2-hard-nan2008")
2141 .flag("-msoft-float")
2144 .flag("-mmicromips");
2145 auto BeHardNanUclibc = makeMultilib("/mips-r2-hard-nan2008-uclibc")
2147 .flag("-msoft-float")
2150 auto ElHardNanUclibc = makeMultilib("/mipsel-r2-hard-nan2008-uclibc")
2152 .flag("-msoft-float")
2155 auto BeHardUclibc = makeMultilib("/mips-r2-hard-uclibc")
2157 .flag("-msoft-float")
2160 auto ElHardUclibc = makeMultilib("/mipsel-r2-hard-uclibc")
2162 .flag("-msoft-float")
2165 auto ElMicroHardNan = makeMultilib("/micromipsel-r2-hard-nan2008")
2167 .flag("-msoft-float")
2169 .flag("+mmicromips");
2170 auto ElMicroSoft = makeMultilib("/micromipsel-r2-soft")
2172 .flag("+msoft-float")
2174 .flag("+mmicromips");
2177 makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
2179 makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
2181 makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
2183 MtiMipsMultilibsV2 =
2185 .Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
2186 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
2187 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
2188 .Either(O32, N32, N64)
2189 .FilterOut(NonExistent)
2190 .setIncludeDirsCallback([](const Multilib &M) {
2191 return std::vector<std::string>({"/../../../../sysroot" +
2193 "/../usr/include"});
2195 .setFilePathsCallback([](const Multilib &M) {
2196 return std::vector<std::string>(
2197 {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()});
2200 for (auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
2201 if (Candidate->select(Flags, Result.SelectedMultilib)) {
2202 Result.Multilibs = *Candidate;
2209 static bool findMipsImgMultilibs(const Multilib::flags_list &Flags,
2210 FilterNonExistent &NonExistent,
2211 DetectedMultilibs &Result) {
2212 // CodeScape IMG toolchain v1.2 and early.
2213 MultilibSet ImgMultilibsV1;
2215 auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32");
2217 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
2220 makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
2226 .Maybe(LittleEndian)
2227 .FilterOut(NonExistent)
2228 .setIncludeDirsCallback([](const Multilib &M) {
2229 return std::vector<std::string>(
2230 {"/include", "/../../../../sysroot/usr/include"});
2234 // CodeScape IMG toolchain starting from v1.3.
2235 MultilibSet ImgMultilibsV2;
2237 auto BeHard = makeMultilib("/mips-r6-hard")
2239 .flag("-msoft-float")
2240 .flag("-mmicromips");
2241 auto BeSoft = makeMultilib("/mips-r6-soft")
2243 .flag("+msoft-float")
2244 .flag("-mmicromips");
2245 auto ElHard = makeMultilib("/mipsel-r6-hard")
2247 .flag("-msoft-float")
2248 .flag("-mmicromips");
2249 auto ElSoft = makeMultilib("/mipsel-r6-soft")
2251 .flag("+msoft-float")
2252 .flag("-mmicromips");
2253 auto BeMicroHard = makeMultilib("/micromips-r6-hard")
2255 .flag("-msoft-float")
2256 .flag("+mmicromips");
2257 auto BeMicroSoft = makeMultilib("/micromips-r6-soft")
2259 .flag("+msoft-float")
2260 .flag("+mmicromips");
2261 auto ElMicroHard = makeMultilib("/micromipsel-r6-hard")
2263 .flag("-msoft-float")
2264 .flag("+mmicromips");
2265 auto ElMicroSoft = makeMultilib("/micromipsel-r6-soft")
2267 .flag("+msoft-float")
2268 .flag("+mmicromips");
2271 makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
2273 makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
2275 makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
2279 .Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
2280 ElMicroHard, ElMicroSoft})
2281 .Either(O32, N32, N64)
2282 .FilterOut(NonExistent)
2283 .setIncludeDirsCallback([](const Multilib &M) {
2284 return std::vector<std::string>({"/../../../../sysroot" +
2286 "/../usr/include"});
2288 .setFilePathsCallback([](const Multilib &M) {
2289 return std::vector<std::string>(
2290 {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()});
2293 for (auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
2294 if (Candidate->select(Flags, Result.SelectedMultilib)) {
2295 Result.Multilibs = *Candidate;
2302 static bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
2303 StringRef Path, const ArgList &Args,
2304 DetectedMultilibs &Result) {
2305 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
2309 tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName);
2311 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2313 Multilib::flags_list Flags;
2314 addMultilibFlag(isMips32(TargetArch), "m32", Flags);
2315 addMultilibFlag(isMips64(TargetArch), "m64", Flags);
2316 addMultilibFlag(isMips16(Args), "mips16", Flags);
2317 addMultilibFlag(CPUName == "mips32", "march=mips32", Flags);
2318 addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" ||
2319 CPUName == "mips32r5" || CPUName == "p5600",
2320 "march=mips32r2", Flags);
2321 addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags);
2322 addMultilibFlag(CPUName == "mips64", "march=mips64", Flags);
2323 addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" ||
2324 CPUName == "mips64r5" || CPUName == "octeon",
2325 "march=mips64r2", Flags);
2326 addMultilibFlag(isMicroMips(Args), "mmicromips", Flags);
2327 addMultilibFlag(tools::mips::isUCLibc(Args), "muclibc", Flags);
2328 addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple), "mnan=2008",
2330 addMultilibFlag(ABIName == "n32", "mabi=n32", Flags);
2331 addMultilibFlag(ABIName == "n64", "mabi=n64", Flags);
2332 addMultilibFlag(isSoftFloatABI(Args), "msoft-float", Flags);
2333 addMultilibFlag(!isSoftFloatABI(Args), "mhard-float", Flags);
2334 addMultilibFlag(isMipsEL(TargetArch), "EL", Flags);
2335 addMultilibFlag(!isMipsEL(TargetArch), "EB", Flags);
2337 if (TargetTriple.isAndroid())
2338 return findMipsAndroidMultilibs(Flags, NonExistent, Result);
2340 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
2341 TargetTriple.getOS() == llvm::Triple::Linux &&
2342 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
2343 return findMipsMuslMultilibs(Flags, NonExistent, Result);
2345 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
2346 TargetTriple.getOS() == llvm::Triple::Linux &&
2347 TargetTriple.getEnvironment() == llvm::Triple::GNU)
2348 return findMipsMtiMultilibs(Flags, NonExistent, Result);
2350 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
2351 TargetTriple.getOS() == llvm::Triple::Linux &&
2352 TargetTriple.getEnvironment() == llvm::Triple::GNU)
2353 return findMipsImgMultilibs(Flags, NonExistent, Result);
2355 if (findMipsCsMultilibs(Flags, NonExistent, Result))
2358 // Fallback to the regular toolchain-tree structure.
2360 Result.Multilibs.push_back(Default);
2361 Result.Multilibs.FilterOut(NonExistent);
2363 if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
2364 Result.BiarchSibling = Multilib();
2371 static void findAndroidArmMultilibs(const Driver &D,
2372 const llvm::Triple &TargetTriple,
2373 StringRef Path, const ArgList &Args,
2374 DetectedMultilibs &Result) {
2375 // Find multilibs with subdirectories like armv7-a, thumb, armv7-a/thumb.
2376 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
2377 Multilib ArmV7Multilib = makeMultilib("/armv7-a")
2380 Multilib ThumbMultilib = makeMultilib("/thumb")
2383 Multilib ArmV7ThumbMultilib = makeMultilib("/armv7-a/thumb")
2386 Multilib DefaultMultilib = makeMultilib("")
2389 MultilibSet AndroidArmMultilibs =
2391 .Either(ThumbMultilib, ArmV7Multilib,
2392 ArmV7ThumbMultilib, DefaultMultilib)
2393 .FilterOut(NonExistent);
2395 Multilib::flags_list Flags;
2396 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
2397 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
2398 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
2399 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
2400 bool IsThumbMode = IsThumbArch ||
2401 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) ||
2402 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::IK_THUMB);
2403 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
2404 (llvm::ARM::parseArchVersion(Arch) == 7 ||
2405 (IsArmArch && Arch == "" && IsV7SubArch));
2406 addMultilibFlag(IsArmV7Mode, "armv7", Flags);
2407 addMultilibFlag(IsThumbMode, "thumb", Flags);
2409 if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib))
2410 Result.Multilibs = AndroidArmMultilibs;
2413 static bool findBiarchMultilibs(const Driver &D,
2414 const llvm::Triple &TargetTriple,
2415 StringRef Path, const ArgList &Args,
2416 bool NeedsBiarchSuffix,
2417 DetectedMultilibs &Result) {
2418 // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
2419 // in what would normally be GCCInstallPath and put the 64-bit
2420 // libs in a subdirectory named 64. The simple logic we follow is that
2421 // *if* there is a subdirectory of the right name with crtbegin.o in it,
2422 // we use that. If not, and if not a biarch triple alias, we look for
2423 // crtbegin.o without the subdirectory.
2426 Multilib Alt64 = Multilib()
2428 .includeSuffix("/64")
2432 Multilib Alt32 = Multilib()
2434 .includeSuffix("/32")
2438 Multilib Altx32 = Multilib()
2440 .includeSuffix("/x32")
2445 // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a.
2446 FilterNonExistent NonExistent(
2447 Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS());
2449 // Determine default multilib from: 32, 64, x32
2450 // Also handle cases such as 64 on 32, 32 on 64, etc.
2451 enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
2452 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
2453 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
2455 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
2457 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
2460 if (TargetTriple.isArch32Bit())
2461 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
2463 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
2465 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
2469 Default.flag("+m32").flag("-m64").flag("-mx32");
2470 else if (Want == WANT64)
2471 Default.flag("-m32").flag("+m64").flag("-mx32");
2472 else if (Want == WANTX32)
2473 Default.flag("-m32").flag("-m64").flag("+mx32");
2477 Result.Multilibs.push_back(Default);
2478 Result.Multilibs.push_back(Alt64);
2479 Result.Multilibs.push_back(Alt32);
2480 Result.Multilibs.push_back(Altx32);
2482 Result.Multilibs.FilterOut(NonExistent);
2484 Multilib::flags_list Flags;
2485 addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "m64", Flags);
2486 addMultilibFlag(TargetTriple.isArch32Bit(), "m32", Flags);
2487 addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "mx32", Flags);
2489 if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
2492 if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
2493 Result.SelectedMultilib == Altx32)
2494 Result.BiarchSibling = Default;
2499 void Generic_GCC::GCCInstallationDetector::scanLibDirForGCCTripleSolaris(
2500 const llvm::Triple &TargetArch, const llvm::opt::ArgList &Args,
2501 const std::string &LibDir, StringRef CandidateTriple,
2502 bool NeedsBiarchSuffix) {
2503 // Solaris is a special case. The GCC installation is under
2504 // /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/, so we
2505 // need to iterate twice.
2507 for (vfs::directory_iterator LI = D.getVFS().dir_begin(LibDir, EC), LE;
2508 !EC && LI != LE; LI = LI.increment(EC)) {
2509 StringRef VersionText = llvm::sys::path::filename(LI->getName());
2510 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2512 if (CandidateVersion.Major != -1) // Filter obviously bad entries.
2513 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2514 continue; // Saw this path before; no need to look at it again.
2515 if (CandidateVersion.isOlderThan(4, 1, 1))
2517 if (CandidateVersion <= Version)
2521 LibDir + "/" + VersionText.str() + "/lib/gcc/" + CandidateTriple.str();
2522 if (!D.getVFS().exists(GCCInstallPath))
2525 // If we make it here there has to be at least one GCC version, let's just
2526 // use the latest one.
2527 std::error_code EEC;
2528 for (vfs::directory_iterator
2529 LLI = D.getVFS().dir_begin(GCCInstallPath, EEC),
2531 !EEC && LLI != LLE; LLI = LLI.increment(EEC)) {
2533 StringRef SubVersionText = llvm::sys::path::filename(LLI->getName());
2534 GCCVersion CandidateSubVersion = GCCVersion::Parse(SubVersionText);
2536 if (CandidateSubVersion > Version)
2537 Version = CandidateSubVersion;
2540 GCCTriple.setTriple(CandidateTriple);
2542 GCCInstallPath += "/" + Version.Text;
2543 GCCParentLibPath = GCCInstallPath + "/../../../../";
2549 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2550 const llvm::Triple &TargetTriple, const ArgList &Args,
2551 const std::string &LibDir, StringRef CandidateTriple,
2552 bool NeedsBiarchSuffix) {
2553 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2554 // There are various different suffixes involving the triple we
2555 // check for. We also record what is necessary to walk from each back
2556 // up to the lib directory. Specifically, the number of "up" steps
2557 // in the second half of each row is 1 + the number of path separators
2558 // in the first half.
2559 const std::string LibAndInstallSuffixes[][2] = {
2560 {"/gcc/" + CandidateTriple.str(), "/../../.."},
2562 // Debian puts cross-compilers in gcc-cross
2563 {"/gcc-cross/" + CandidateTriple.str(), "/../../.."},
2565 {"/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(),
2568 // The Freescale PPC SDK has the gcc libraries in
2569 // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well.
2570 {"/" + CandidateTriple.str(), "/../.."},
2572 // Ubuntu has a strange mis-matched pair of triples that this happens to
2574 // FIXME: It may be worthwhile to generalize this and look for a second
2576 {"/i386-linux-gnu/gcc/" + CandidateTriple.str(), "/../../../.."}};
2578 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2579 scanLibDirForGCCTripleSolaris(TargetTriple, Args, LibDir, CandidateTriple,
2584 // Only look at the final, weird Ubuntu suffix for i386-linux-gnu.
2585 const unsigned NumLibSuffixes = (llvm::array_lengthof(LibAndInstallSuffixes) -
2586 (TargetArch != llvm::Triple::x86));
2587 for (unsigned i = 0; i < NumLibSuffixes; ++i) {
2588 StringRef LibSuffix = LibAndInstallSuffixes[i][0];
2590 for (vfs::directory_iterator
2591 LI = D.getVFS().dir_begin(LibDir + LibSuffix, EC),
2593 !EC && LI != LE; LI = LI.increment(EC)) {
2594 StringRef VersionText = llvm::sys::path::filename(LI->getName());
2595 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2596 if (CandidateVersion.Major != -1) // Filter obviously bad entries.
2597 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2598 continue; // Saw this path before; no need to look at it again.
2599 if (CandidateVersion.isOlderThan(4, 1, 1))
2601 if (CandidateVersion <= Version)
2604 DetectedMultilibs Detected;
2606 // Android standalone toolchain could have multilibs for ARM and Thumb.
2607 // Debian mips multilibs behave more like the rest of the biarch ones,
2608 // so handle them there
2609 if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) {
2610 // It should also work without multilibs in a simplified toolchain.
2611 findAndroidArmMultilibs(D, TargetTriple, LI->getName(), Args, Detected);
2612 } else if (isMipsArch(TargetArch)) {
2613 if (!findMIPSMultilibs(D, TargetTriple, LI->getName(), Args, Detected))
2615 } else if (!findBiarchMultilibs(D, TargetTriple, LI->getName(), Args,
2616 NeedsBiarchSuffix, Detected)) {
2620 Multilibs = Detected.Multilibs;
2621 SelectedMultilib = Detected.SelectedMultilib;
2622 BiarchSibling = Detected.BiarchSibling;
2623 Version = CandidateVersion;
2624 GCCTriple.setTriple(CandidateTriple);
2625 // FIXME: We hack together the directory name here instead of
2626 // using LI to ensure stable path separators across Windows and
2629 LibDir + LibAndInstallSuffixes[i][0] + "/" + VersionText.str();
2630 GCCParentLibPath = GCCInstallPath + LibAndInstallSuffixes[i][1];
2636 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
2637 const ArgList &Args)
2638 : ToolChain(D, Triple, Args), GCCInstallation(D), CudaInstallation(D) {
2639 getProgramPaths().push_back(getDriver().getInstalledDir());
2640 if (getDriver().getInstalledDir() != getDriver().Dir)
2641 getProgramPaths().push_back(getDriver().Dir);
2644 Generic_GCC::~Generic_GCC() {}
2646 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
2648 case Action::PreprocessJobClass:
2650 Preprocess.reset(new tools::gcc::Preprocessor(*this));
2651 return Preprocess.get();
2652 case Action::CompileJobClass:
2654 Compile.reset(new tools::gcc::Compiler(*this));
2655 return Compile.get();
2657 return ToolChain::getTool(AC);
2661 Tool *Generic_GCC::buildAssembler() const {
2662 return new tools::gnutools::Assembler(*this);
2665 Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); }
2667 void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
2668 // Print the information about how we detected the GCC installation.
2669 GCCInstallation.print(OS);
2670 CudaInstallation.print(OS);
2673 bool Generic_GCC::IsUnwindTablesDefault() const {
2674 return getArch() == llvm::Triple::x86_64;
2677 bool Generic_GCC::isPICDefault() const {
2678 return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2681 bool Generic_GCC::isPIEDefault() const { return false; }
2683 bool Generic_GCC::isPICDefaultForced() const {
2684 return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2687 bool Generic_GCC::IsIntegratedAssemblerDefault() const {
2688 switch (getTriple().getArch()) {
2689 case llvm::Triple::x86:
2690 case llvm::Triple::x86_64:
2691 case llvm::Triple::aarch64:
2692 case llvm::Triple::aarch64_be:
2693 case llvm::Triple::arm:
2694 case llvm::Triple::armeb:
2695 case llvm::Triple::bpfel:
2696 case llvm::Triple::bpfeb:
2697 case llvm::Triple::thumb:
2698 case llvm::Triple::thumbeb:
2699 case llvm::Triple::ppc:
2700 case llvm::Triple::ppc64:
2701 case llvm::Triple::ppc64le:
2702 case llvm::Triple::systemz:
2703 case llvm::Triple::mips:
2704 case llvm::Triple::mipsel:
2711 /// \brief Helper to add the variant paths of a libstdc++ installation.
2712 bool Generic_GCC::addLibStdCXXIncludePaths(
2713 Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2714 StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2715 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2716 if (!getVFS().exists(Base + Suffix))
2719 addSystemInclude(DriverArgs, CC1Args, Base + Suffix);
2721 // The vanilla GCC layout of libstdc++ headers uses a triple subdirectory. If
2722 // that path exists or we have neither a GCC nor target multiarch triple, use
2723 // this vanilla search path.
2724 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2725 getVFS().exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) {
2726 addSystemInclude(DriverArgs, CC1Args,
2727 Base + Suffix + "/" + GCCTriple + IncludeSuffix);
2729 // Otherwise try to use multiarch naming schemes which have normalized the
2730 // triples and put the triple before the suffix.
2732 // GCC surprisingly uses *both* the GCC triple with a multilib suffix and
2733 // the target triple, so we support that here.
2734 addSystemInclude(DriverArgs, CC1Args,
2735 Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2736 addSystemInclude(DriverArgs, CC1Args,
2737 Base + "/" + TargetMultiarchTriple + Suffix);
2740 addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward");
2744 void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs,
2745 ArgStringList &CC1Args) const {
2746 const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2747 bool UseInitArrayDefault =
2748 getTriple().getArch() == llvm::Triple::aarch64 ||
2749 getTriple().getArch() == llvm::Triple::aarch64_be ||
2750 (getTriple().getOS() == llvm::Triple::Linux &&
2751 (!V.isOlderThan(4, 7, 0) || getTriple().isAndroid())) ||
2752 getTriple().getOS() == llvm::Triple::NaCl ||
2753 (getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2754 !getTriple().hasEnvironment());
2756 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2757 options::OPT_fno_use_init_array, UseInitArrayDefault))
2758 CC1Args.push_back("-fuse-init-array");
2762 MipsLLVMToolChain::MipsLLVMToolChain(const Driver &D,
2763 const llvm::Triple &Triple,
2764 const ArgList &Args)
2765 : Linux(D, Triple, Args) {
2766 // Select the correct multilib according to the given arguments.
2767 DetectedMultilibs Result;
2768 findMIPSMultilibs(D, Triple, "", Args, Result);
2769 Multilibs = Result.Multilibs;
2770 SelectedMultilib = Result.SelectedMultilib;
2772 // Find out the library suffix based on the ABI.
2773 LibSuffix = tools::mips::getMipsABILibSuffix(Args, Triple);
2774 getFilePaths().clear();
2775 getFilePaths().push_back(computeSysRoot() + "/usr/lib" + LibSuffix);
2777 // Use LLD by default.
2778 DefaultLinker = "lld";
2781 void MipsLLVMToolChain::AddClangSystemIncludeArgs(
2782 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2783 if (DriverArgs.hasArg(options::OPT_nostdinc))
2786 const Driver &D = getDriver();
2788 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2789 SmallString<128> P(D.ResourceDir);
2790 llvm::sys::path::append(P, "include");
2791 addSystemInclude(DriverArgs, CC1Args, P);
2794 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2797 const auto &Callback = Multilibs.includeDirsCallback();
2799 for (const auto &Path : Callback(SelectedMultilib))
2800 addExternCSystemIncludeIfExists(DriverArgs, CC1Args,
2801 D.getInstalledDir() + Path);
2805 Tool *MipsLLVMToolChain::buildLinker() const {
2806 return new tools::gnutools::Linker(*this);
2809 std::string MipsLLVMToolChain::computeSysRoot() const {
2810 if (!getDriver().SysRoot.empty())
2811 return getDriver().SysRoot + SelectedMultilib.osSuffix();
2813 const std::string InstalledDir(getDriver().getInstalledDir());
2814 std::string SysRootPath =
2815 InstalledDir + "/../sysroot" + SelectedMultilib.osSuffix();
2816 if (llvm::sys::fs::exists(SysRootPath))
2819 return std::string();
2822 ToolChain::CXXStdlibType
2823 MipsLLVMToolChain::GetCXXStdlibType(const ArgList &Args) const {
2824 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
2826 StringRef Value = A->getValue();
2827 if (Value != "libc++")
2828 getDriver().Diag(diag::err_drv_invalid_stdlib_name)
2829 << A->getAsString(Args);
2832 return ToolChain::CST_Libcxx;
2835 void MipsLLVMToolChain::AddClangCXXStdlibIncludeArgs(
2836 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2837 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2838 DriverArgs.hasArg(options::OPT_nostdincxx))
2841 assert((GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) &&
2842 "Only -lc++ (aka libcxx) is suported in this toolchain.");
2844 const auto &Callback = Multilibs.includeDirsCallback();
2846 for (std::string Path : Callback(SelectedMultilib)) {
2847 Path = getDriver().getInstalledDir() + Path + "/c++/v1";
2848 if (llvm::sys::fs::exists(Path)) {
2849 addSystemInclude(DriverArgs, CC1Args, Path);
2856 void MipsLLVMToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
2857 ArgStringList &CmdArgs) const {
2858 assert((GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) &&
2859 "Only -lc++ (aka libxx) is suported in this toolchain.");
2861 CmdArgs.push_back("-lc++");
2862 CmdArgs.push_back("-lc++abi");
2863 CmdArgs.push_back("-lunwind");
2866 std::string MipsLLVMToolChain::getCompilerRT(const ArgList &Args,
2867 StringRef Component,
2868 bool Shared) const {
2869 SmallString<128> Path(getDriver().ResourceDir);
2870 llvm::sys::path::append(Path, SelectedMultilib.osSuffix(), "lib" + LibSuffix,
2872 llvm::sys::path::append(Path, Twine("libclang_rt." + Component + "-" +
2873 "mips" + (Shared ? ".so" : ".a")));
2877 /// Hexagon Toolchain
2879 std::string HexagonToolChain::getHexagonTargetDir(
2880 const std::string &InstalledDir,
2881 const SmallVectorImpl<std::string> &PrefixDirs) const {
2882 std::string InstallRelDir;
2883 const Driver &D = getDriver();
2885 // Locate the rest of the toolchain ...
2886 for (auto &I : PrefixDirs)
2887 if (D.getVFS().exists(I))
2890 if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))
2891 return InstallRelDir;
2893 return InstallRelDir;
2896 Optional<unsigned> HexagonToolChain::getSmallDataThreshold(
2897 const ArgList &Args) {
2899 if (Arg *A = Args.getLastArg(options::OPT_G, options::OPT_G_EQ,
2900 options::OPT_msmall_data_threshold_EQ)) {
2902 } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2903 options::OPT_fPIC)) {
2908 if (!Gn.getAsInteger(10, G))
2914 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
2915 ToolChain::path_list &LibPaths) const {
2916 const Driver &D = getDriver();
2918 //----------------------------------------------------------------------------
2920 //----------------------------------------------------------------------------
2921 for (Arg *A : Args.filtered(options::OPT_L))
2922 for (const char *Value : A->getValues())
2923 LibPaths.push_back(Value);
2925 //----------------------------------------------------------------------------
2926 // Other standard paths
2927 //----------------------------------------------------------------------------
2928 std::vector<std::string> RootDirs;
2929 std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
2930 std::back_inserter(RootDirs));
2932 std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
2934 if (std::find(RootDirs.begin(), RootDirs.end(), TargetDir) == RootDirs.end())
2935 RootDirs.push_back(TargetDir);
2937 bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
2938 // Assume G0 with -shared.
2939 bool HasG0 = Args.hasArg(options::OPT_shared);
2940 if (auto G = getSmallDataThreshold(Args))
2941 HasG0 = G.getValue() == 0;
2943 const std::string CpuVer = GetTargetCPUVersion(Args).str();
2944 for (auto &Dir : RootDirs) {
2945 std::string LibDir = Dir + "/hexagon/lib";
2946 std::string LibDirCpu = LibDir + '/' + CpuVer;
2949 LibPaths.push_back(LibDirCpu + "/G0/pic");
2950 LibPaths.push_back(LibDirCpu + "/G0");
2952 LibPaths.push_back(LibDirCpu);
2953 LibPaths.push_back(LibDir);
2957 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
2958 const llvm::opt::ArgList &Args)
2959 : Linux(D, Triple, Args) {
2960 const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
2963 // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
2965 const std::string BinDir(TargetDir + "/bin");
2966 if (D.getVFS().exists(BinDir))
2967 getProgramPaths().push_back(BinDir);
2969 ToolChain::path_list &LibPaths = getFilePaths();
2971 // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
2972 // 'elf' OS type, so the Linux paths are not appropriate. When we actually
2973 // support 'linux' we'll need to fix this up
2975 getHexagonLibraryPaths(Args, LibPaths);
2978 HexagonToolChain::~HexagonToolChain() {}
2980 Tool *HexagonToolChain::buildAssembler() const {
2981 return new tools::hexagon::Assembler(*this);
2984 Tool *HexagonToolChain::buildLinker() const {
2985 return new tools::hexagon::Linker(*this);
2988 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
2989 ArgStringList &CC1Args) const {
2990 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2991 DriverArgs.hasArg(options::OPT_nostdlibinc))
2994 const Driver &D = getDriver();
2995 std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
2997 addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include");
3000 void HexagonToolChain::AddClangCXXStdlibIncludeArgs(
3001 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
3002 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3003 DriverArgs.hasArg(options::OPT_nostdincxx))
3006 const Driver &D = getDriver();
3007 std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
3008 addSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include/c++");
3011 ToolChain::CXXStdlibType
3012 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
3013 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
3015 return ToolChain::CST_Libstdcxx;
3017 StringRef Value = A->getValue();
3018 if (Value != "libstdc++")
3019 getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3021 return ToolChain::CST_Libstdcxx;
3025 // Returns the default CPU for Hexagon. This is the default compilation target
3026 // if no Hexagon processor is selected at the command-line.
3028 const StringRef HexagonToolChain::GetDefaultCPU() {
3029 return "hexagonv60";
3032 const StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
3033 Arg *CpuArg = nullptr;
3034 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ, options::OPT_march_EQ))
3037 StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
3038 if (CPU.startswith("hexagon"))
3039 return CPU.substr(sizeof("hexagon") - 1);
3044 /// AMDGPU Toolchain
3045 AMDGPUToolChain::AMDGPUToolChain(const Driver &D, const llvm::Triple &Triple,
3046 const ArgList &Args)
3047 : Generic_ELF(D, Triple, Args) { }
3049 Tool *AMDGPUToolChain::buildLinker() const {
3050 return new tools::amdgpu::Linker(*this);
3055 NaClToolChain::NaClToolChain(const Driver &D, const llvm::Triple &Triple,
3056 const ArgList &Args)
3057 : Generic_ELF(D, Triple, Args) {
3059 // Remove paths added by Generic_GCC. NaCl Toolchain cannot use the
3060 // default paths, and must instead only use the paths provided
3061 // with this toolchain based on architecture.
3062 path_list &file_paths = getFilePaths();
3063 path_list &prog_paths = getProgramPaths();
3068 // Path for library files (libc.a, ...)
3069 std::string FilePath(getDriver().Dir + "/../");
3071 // Path for tools (clang, ld, etc..)
3072 std::string ProgPath(getDriver().Dir + "/../");
3074 // Path for toolchain libraries (libgcc.a, ...)
3075 std::string ToolPath(getDriver().ResourceDir + "/lib/");
3077 switch (Triple.getArch()) {
3078 case llvm::Triple::x86:
3079 file_paths.push_back(FilePath + "x86_64-nacl/lib32");
3080 file_paths.push_back(FilePath + "i686-nacl/usr/lib");
3081 prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
3082 file_paths.push_back(ToolPath + "i686-nacl");
3084 case llvm::Triple::x86_64:
3085 file_paths.push_back(FilePath + "x86_64-nacl/lib");
3086 file_paths.push_back(FilePath + "x86_64-nacl/usr/lib");
3087 prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
3088 file_paths.push_back(ToolPath + "x86_64-nacl");
3090 case llvm::Triple::arm:
3091 file_paths.push_back(FilePath + "arm-nacl/lib");
3092 file_paths.push_back(FilePath + "arm-nacl/usr/lib");
3093 prog_paths.push_back(ProgPath + "arm-nacl/bin");
3094 file_paths.push_back(ToolPath + "arm-nacl");
3096 case llvm::Triple::mipsel:
3097 file_paths.push_back(FilePath + "mipsel-nacl/lib");
3098 file_paths.push_back(FilePath + "mipsel-nacl/usr/lib");
3099 prog_paths.push_back(ProgPath + "bin");
3100 file_paths.push_back(ToolPath + "mipsel-nacl");
3106 NaClArmMacrosPath = GetFilePath("nacl-arm-macros.s");
3109 void NaClToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
3110 ArgStringList &CC1Args) const {
3111 const Driver &D = getDriver();
3112 if (DriverArgs.hasArg(options::OPT_nostdinc))
3115 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
3116 SmallString<128> P(D.ResourceDir);
3117 llvm::sys::path::append(P, "include");
3118 addSystemInclude(DriverArgs, CC1Args, P.str());
3121 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
3124 SmallString<128> P(D.Dir + "/../");
3125 switch (getTriple().getArch()) {
3126 case llvm::Triple::x86:
3127 // x86 is special because multilib style uses x86_64-nacl/include for libc
3128 // headers but the SDK wants i686-nacl/usr/include. The other architectures
3129 // have the same substring.
3130 llvm::sys::path::append(P, "i686-nacl/usr/include");
3131 addSystemInclude(DriverArgs, CC1Args, P.str());
3132 llvm::sys::path::remove_filename(P);
3133 llvm::sys::path::remove_filename(P);
3134 llvm::sys::path::remove_filename(P);
3135 llvm::sys::path::append(P, "x86_64-nacl/include");
3136 addSystemInclude(DriverArgs, CC1Args, P.str());
3138 case llvm::Triple::arm:
3139 llvm::sys::path::append(P, "arm-nacl/usr/include");
3141 case llvm::Triple::x86_64:
3142 llvm::sys::path::append(P, "x86_64-nacl/usr/include");
3144 case llvm::Triple::mipsel:
3145 llvm::sys::path::append(P, "mipsel-nacl/usr/include");
3151 addSystemInclude(DriverArgs, CC1Args, P.str());
3152 llvm::sys::path::remove_filename(P);
3153 llvm::sys::path::remove_filename(P);
3154 llvm::sys::path::append(P, "include");
3155 addSystemInclude(DriverArgs, CC1Args, P.str());
3158 void NaClToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
3159 ArgStringList &CmdArgs) const {
3160 // Check for -stdlib= flags. We only support libc++ but this consumes the arg
3161 // if the value is libc++, and emits an error for other values.
3162 GetCXXStdlibType(Args);
3163 CmdArgs.push_back("-lc++");
3166 void NaClToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3167 ArgStringList &CC1Args) const {
3168 const Driver &D = getDriver();
3169 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3170 DriverArgs.hasArg(options::OPT_nostdincxx))
3173 // Check for -stdlib= flags. We only support libc++ but this consumes the arg
3174 // if the value is libc++, and emits an error for other values.
3175 GetCXXStdlibType(DriverArgs);
3177 SmallString<128> P(D.Dir + "/../");
3178 switch (getTriple().getArch()) {
3179 case llvm::Triple::arm:
3180 llvm::sys::path::append(P, "arm-nacl/include/c++/v1");
3181 addSystemInclude(DriverArgs, CC1Args, P.str());
3183 case llvm::Triple::x86:
3184 llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
3185 addSystemInclude(DriverArgs, CC1Args, P.str());
3187 case llvm::Triple::x86_64:
3188 llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
3189 addSystemInclude(DriverArgs, CC1Args, P.str());
3191 case llvm::Triple::mipsel:
3192 llvm::sys::path::append(P, "mipsel-nacl/include/c++/v1");
3193 addSystemInclude(DriverArgs, CC1Args, P.str());
3200 ToolChain::CXXStdlibType
3201 NaClToolChain::GetCXXStdlibType(const ArgList &Args) const {
3202 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
3203 StringRef Value = A->getValue();
3204 if (Value == "libc++")
3205 return ToolChain::CST_Libcxx;
3206 getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3209 return ToolChain::CST_Libcxx;
3213 NaClToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
3214 types::ID InputType) const {
3215 llvm::Triple TheTriple(ComputeLLVMTriple(Args, InputType));
3216 if (TheTriple.getArch() == llvm::Triple::arm &&
3217 TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
3218 TheTriple.setEnvironment(llvm::Triple::GNUEABIHF);
3219 return TheTriple.getTriple();
3222 Tool *NaClToolChain::buildLinker() const {
3223 return new tools::nacltools::Linker(*this);
3226 Tool *NaClToolChain::buildAssembler() const {
3227 if (getTriple().getArch() == llvm::Triple::arm)
3228 return new tools::nacltools::AssemblerARM(*this);
3229 return new tools::gnutools::Assembler(*this);
3233 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
3234 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
3235 /// Currently does not support anything else but compilation.
3237 TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple &Triple,
3238 const ArgList &Args)
3239 : ToolChain(D, Triple, Args) {
3240 // Path mangling to find libexec
3241 std::string Path(getDriver().Dir);
3243 Path += "/../libexec";
3244 getProgramPaths().push_back(Path);
3247 TCEToolChain::~TCEToolChain() {}
3249 bool TCEToolChain::IsMathErrnoDefault() const { return true; }
3251 bool TCEToolChain::isPICDefault() const { return false; }
3253 bool TCEToolChain::isPIEDefault() const { return false; }
3255 bool TCEToolChain::isPICDefaultForced() const { return false; }
3257 // CloudABI - CloudABI tool chain which can call ld(1) directly.
3259 CloudABI::CloudABI(const Driver &D, const llvm::Triple &Triple,
3260 const ArgList &Args)
3261 : Generic_ELF(D, Triple, Args) {
3262 SmallString<128> P(getDriver().Dir);
3263 llvm::sys::path::append(P, "..", getTriple().str(), "lib");
3264 getFilePaths().push_back(P.str());
3267 void CloudABI::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3268 ArgStringList &CC1Args) const {
3269 if (DriverArgs.hasArg(options::OPT_nostdlibinc) &&
3270 DriverArgs.hasArg(options::OPT_nostdincxx))
3273 SmallString<128> P(getDriver().Dir);
3274 llvm::sys::path::append(P, "..", getTriple().str(), "include/c++/v1");
3275 addSystemInclude(DriverArgs, CC1Args, P.str());
3278 void CloudABI::AddCXXStdlibLibArgs(const ArgList &Args,
3279 ArgStringList &CmdArgs) const {
3280 CmdArgs.push_back("-lc++");
3281 CmdArgs.push_back("-lc++abi");
3282 CmdArgs.push_back("-lunwind");
3285 Tool *CloudABI::buildLinker() const {
3286 return new tools::cloudabi::Linker(*this);
3289 bool CloudABI::isPIEDefault() const {
3290 // Only enable PIE on architectures that support PC-relative
3291 // addressing. PC-relative addressing is required, as the process
3292 // startup code must be able to relocate itself.
3293 switch (getTriple().getArch()) {
3294 case llvm::Triple::aarch64:
3295 case llvm::Triple::x86_64:
3302 SanitizerMask CloudABI::getSupportedSanitizers() const {
3303 SanitizerMask Res = ToolChain::getSupportedSanitizers();
3304 Res |= SanitizerKind::SafeStack;
3308 SanitizerMask CloudABI::getDefaultSanitizers() const {
3309 return SanitizerKind::SafeStack;
3312 /// Haiku - Haiku tool chain which can call as(1) and ld(1) directly.
3314 Haiku::Haiku(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
3315 : Generic_ELF(D, Triple, Args) {
3319 void Haiku::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3320 ArgStringList &CC1Args) const {
3321 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3322 DriverArgs.hasArg(options::OPT_nostdincxx))
3325 switch (GetCXXStdlibType(DriverArgs)) {
3326 case ToolChain::CST_Libcxx:
3327 addSystemInclude(DriverArgs, CC1Args,
3328 getDriver().SysRoot + "/system/develop/headers/c++/v1");
3330 case ToolChain::CST_Libstdcxx:
3331 addSystemInclude(DriverArgs, CC1Args,
3332 getDriver().SysRoot + "/system/develop/headers/c++");
3333 addSystemInclude(DriverArgs, CC1Args,
3334 getDriver().SysRoot + "/system/develop/headers/c++/backward");
3336 StringRef Triple = getTriple().str();
3337 addSystemInclude(DriverArgs, CC1Args,
3338 getDriver().SysRoot + "/system/develop/headers/c++/" +
3344 /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
3346 OpenBSD::OpenBSD(const Driver &D, const llvm::Triple &Triple,
3347 const ArgList &Args)
3348 : Generic_ELF(D, Triple, Args) {
3349 getFilePaths().push_back(getDriver().Dir + "/../lib");
3350 getFilePaths().push_back("/usr/lib");
3353 Tool *OpenBSD::buildAssembler() const {
3354 return new tools::openbsd::Assembler(*this);
3357 Tool *OpenBSD::buildLinker() const { return new tools::openbsd::Linker(*this); }
3359 /// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly.
3361 Bitrig::Bitrig(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3362 : Generic_ELF(D, Triple, Args) {
3363 getFilePaths().push_back(getDriver().Dir + "/../lib");
3364 getFilePaths().push_back("/usr/lib");
3367 Tool *Bitrig::buildAssembler() const {
3368 return new tools::bitrig::Assembler(*this);
3371 Tool *Bitrig::buildLinker() const { return new tools::bitrig::Linker(*this); }
3373 ToolChain::CXXStdlibType Bitrig::GetDefaultCXXStdlibType() const {
3374 return ToolChain::CST_Libcxx;
3377 void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3378 ArgStringList &CC1Args) const {
3379 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3380 DriverArgs.hasArg(options::OPT_nostdincxx))
3383 switch (GetCXXStdlibType(DriverArgs)) {
3384 case ToolChain::CST_Libcxx:
3385 addSystemInclude(DriverArgs, CC1Args,
3386 getDriver().SysRoot + "/usr/include/c++/v1");
3388 case ToolChain::CST_Libstdcxx:
3389 addSystemInclude(DriverArgs, CC1Args,
3390 getDriver().SysRoot + "/usr/include/c++/stdc++");
3391 addSystemInclude(DriverArgs, CC1Args,
3392 getDriver().SysRoot + "/usr/include/c++/stdc++/backward");
3394 StringRef Triple = getTriple().str();
3395 if (Triple.startswith("amd64"))
3396 addSystemInclude(DriverArgs, CC1Args,
3397 getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" +
3400 addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot +
3401 "/usr/include/c++/stdc++/" +
3407 void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args,
3408 ArgStringList &CmdArgs) const {
3409 switch (GetCXXStdlibType(Args)) {
3410 case ToolChain::CST_Libcxx:
3411 CmdArgs.push_back("-lc++");
3412 CmdArgs.push_back("-lc++abi");
3413 CmdArgs.push_back("-lpthread");
3415 case ToolChain::CST_Libstdcxx:
3416 CmdArgs.push_back("-lstdc++");
3421 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
3423 FreeBSD::FreeBSD(const Driver &D, const llvm::Triple &Triple,
3424 const ArgList &Args)
3425 : Generic_ELF(D, Triple, Args) {
3427 // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall
3428 // back to '/usr/lib' if it doesn't exist.
3429 if ((Triple.getArch() == llvm::Triple::x86 ||
3430 Triple.getArch() == llvm::Triple::ppc) &&
3431 D.getVFS().exists(getDriver().SysRoot + "/usr/lib32/crt1.o"))
3432 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32");
3434 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib");
3437 ToolChain::CXXStdlibType FreeBSD::GetDefaultCXXStdlibType() const {
3438 if (getTriple().getOSMajorVersion() >= 10)
3439 return ToolChain::CST_Libcxx;
3440 return ToolChain::CST_Libstdcxx;
3443 void FreeBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3444 ArgStringList &CC1Args) const {
3445 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3446 DriverArgs.hasArg(options::OPT_nostdincxx))
3449 switch (GetCXXStdlibType(DriverArgs)) {
3450 case ToolChain::CST_Libcxx:
3451 addSystemInclude(DriverArgs, CC1Args,
3452 getDriver().SysRoot + "/usr/include/c++/v1");
3454 case ToolChain::CST_Libstdcxx:
3455 addSystemInclude(DriverArgs, CC1Args,
3456 getDriver().SysRoot + "/usr/include/c++/4.2");
3457 addSystemInclude(DriverArgs, CC1Args,
3458 getDriver().SysRoot + "/usr/include/c++/4.2/backward");
3463 void FreeBSD::AddCXXStdlibLibArgs(const ArgList &Args,
3464 ArgStringList &CmdArgs) const {
3465 CXXStdlibType Type = GetCXXStdlibType(Args);
3466 bool Profiling = Args.hasArg(options::OPT_pg);
3469 case ToolChain::CST_Libcxx:
3470 CmdArgs.push_back(Profiling ? "-lc++_p" : "-lc++");
3473 case ToolChain::CST_Libstdcxx:
3474 CmdArgs.push_back(Profiling ? "-lstdc++_p" : "-lstdc++");
3479 Tool *FreeBSD::buildAssembler() const {
3480 return new tools::freebsd::Assembler(*this);
3483 Tool *FreeBSD::buildLinker() const { return new tools::freebsd::Linker(*this); }
3485 bool FreeBSD::UseSjLjExceptions(const ArgList &Args) const {
3486 // FreeBSD uses SjLj exceptions on ARM oabi.
3487 switch (getTriple().getEnvironment()) {
3488 case llvm::Triple::GNUEABIHF:
3489 case llvm::Triple::GNUEABI:
3490 case llvm::Triple::EABI:
3494 return (getTriple().getArch() == llvm::Triple::arm ||
3495 getTriple().getArch() == llvm::Triple::thumb);
3499 bool FreeBSD::HasNativeLLVMSupport() const { return true; }
3501 bool FreeBSD::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); }
3503 SanitizerMask FreeBSD::getSupportedSanitizers() const {
3504 const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
3505 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
3506 const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 ||
3507 getTriple().getArch() == llvm::Triple::mips64el;
3508 SanitizerMask Res = ToolChain::getSupportedSanitizers();
3509 Res |= SanitizerKind::Address;
3510 Res |= SanitizerKind::Vptr;
3511 if (IsX86_64 || IsMIPS64) {
3512 Res |= SanitizerKind::Leak;
3513 Res |= SanitizerKind::Thread;
3515 if (IsX86 || IsX86_64) {
3516 Res |= SanitizerKind::SafeStack;
3521 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
3523 NetBSD::NetBSD(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3524 : Generic_ELF(D, Triple, Args) {
3525 if (getDriver().UseStdLib) {
3526 // When targeting a 32-bit platform, try the special directory used on
3527 // 64-bit hosts, and only fall back to the main library directory if that
3529 // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
3530 // what all logic is needed to emulate the '=' prefix here.
3531 switch (Triple.getArch()) {
3532 case llvm::Triple::x86:
3533 getFilePaths().push_back("=/usr/lib/i386");
3535 case llvm::Triple::arm:
3536 case llvm::Triple::armeb:
3537 case llvm::Triple::thumb:
3538 case llvm::Triple::thumbeb:
3539 switch (Triple.getEnvironment()) {
3540 case llvm::Triple::EABI:
3541 case llvm::Triple::GNUEABI:
3542 getFilePaths().push_back("=/usr/lib/eabi");
3544 case llvm::Triple::EABIHF:
3545 case llvm::Triple::GNUEABIHF:
3546 getFilePaths().push_back("=/usr/lib/eabihf");
3549 getFilePaths().push_back("=/usr/lib/oabi");
3553 case llvm::Triple::mips64:
3554 case llvm::Triple::mips64el:
3555 if (tools::mips::hasMipsAbiArg(Args, "o32"))
3556 getFilePaths().push_back("=/usr/lib/o32");
3557 else if (tools::mips::hasMipsAbiArg(Args, "64"))
3558 getFilePaths().push_back("=/usr/lib/64");
3560 case llvm::Triple::ppc:
3561 getFilePaths().push_back("=/usr/lib/powerpc");
3563 case llvm::Triple::sparc:
3564 getFilePaths().push_back("=/usr/lib/sparc");
3570 getFilePaths().push_back("=/usr/lib");
3574 Tool *NetBSD::buildAssembler() const {
3575 return new tools::netbsd::Assembler(*this);
3578 Tool *NetBSD::buildLinker() const { return new tools::netbsd::Linker(*this); }
3580 ToolChain::CXXStdlibType NetBSD::GetDefaultCXXStdlibType() const {
3581 unsigned Major, Minor, Micro;
3582 getTriple().getOSVersion(Major, Minor, Micro);
3583 if (Major >= 7 || Major == 0) {
3584 switch (getArch()) {
3585 case llvm::Triple::aarch64:
3586 case llvm::Triple::arm:
3587 case llvm::Triple::armeb:
3588 case llvm::Triple::thumb:
3589 case llvm::Triple::thumbeb:
3590 case llvm::Triple::ppc:
3591 case llvm::Triple::ppc64:
3592 case llvm::Triple::ppc64le:
3593 case llvm::Triple::sparc:
3594 case llvm::Triple::sparcv9:
3595 case llvm::Triple::x86:
3596 case llvm::Triple::x86_64:
3597 return ToolChain::CST_Libcxx;
3602 return ToolChain::CST_Libstdcxx;
3605 void NetBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3606 ArgStringList &CC1Args) const {
3607 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3608 DriverArgs.hasArg(options::OPT_nostdincxx))
3611 switch (GetCXXStdlibType(DriverArgs)) {
3612 case ToolChain::CST_Libcxx:
3613 addSystemInclude(DriverArgs, CC1Args,
3614 getDriver().SysRoot + "/usr/include/c++/");
3616 case ToolChain::CST_Libstdcxx:
3617 addSystemInclude(DriverArgs, CC1Args,
3618 getDriver().SysRoot + "/usr/include/g++");
3619 addSystemInclude(DriverArgs, CC1Args,
3620 getDriver().SysRoot + "/usr/include/g++/backward");
3625 /// Minix - Minix tool chain which can call as(1) and ld(1) directly.
3627 Minix::Minix(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3628 : Generic_ELF(D, Triple, Args) {
3629 getFilePaths().push_back(getDriver().Dir + "/../lib");
3630 getFilePaths().push_back("/usr/lib");
3633 Tool *Minix::buildAssembler() const {
3634 return new tools::minix::Assembler(*this);
3637 Tool *Minix::buildLinker() const { return new tools::minix::Linker(*this); }
3639 static void addPathIfExists(const Driver &D, const Twine &Path,
3640 ToolChain::path_list &Paths) {
3641 if (D.getVFS().exists(Path))
3642 Paths.push_back(Path.str());
3645 /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
3647 Solaris::Solaris(const Driver &D, const llvm::Triple &Triple,
3648 const ArgList &Args)
3649 : Generic_GCC(D, Triple, Args) {
3651 GCCInstallation.init(Triple, Args);
3653 path_list &Paths = getFilePaths();
3654 if (GCCInstallation.isValid())
3655 addPathIfExists(D, GCCInstallation.getInstallPath(), Paths);
3657 addPathIfExists(D, getDriver().getInstalledDir(), Paths);
3658 if (getDriver().getInstalledDir() != getDriver().Dir)
3659 addPathIfExists(D, getDriver().Dir, Paths);
3661 addPathIfExists(D, getDriver().SysRoot + getDriver().Dir + "/../lib", Paths);
3663 std::string LibPath = "/usr/lib/";
3664 switch (Triple.getArch()) {
3665 case llvm::Triple::x86:
3666 case llvm::Triple::sparc:
3668 case llvm::Triple::x86_64:
3669 LibPath += "amd64/";
3671 case llvm::Triple::sparcv9:
3672 LibPath += "sparcv9/";
3675 llvm_unreachable("Unsupported architecture");
3678 addPathIfExists(D, getDriver().SysRoot + LibPath, Paths);
3681 Tool *Solaris::buildAssembler() const {
3682 return new tools::solaris::Assembler(*this);
3685 Tool *Solaris::buildLinker() const { return new tools::solaris::Linker(*this); }
3687 void Solaris::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3688 ArgStringList &CC1Args) const {
3689 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3690 DriverArgs.hasArg(options::OPT_nostdincxx))
3693 // Include the support directory for things like xlocale and fudged system
3695 addSystemInclude(DriverArgs, CC1Args, "/usr/include/c++/v1/support/solaris");
3697 if (GCCInstallation.isValid()) {
3698 GCCVersion Version = GCCInstallation.getVersion();
3699 addSystemInclude(DriverArgs, CC1Args,
3700 getDriver().SysRoot + "/usr/gcc/" +
3701 Version.MajorStr + "." +
3703 "/include/c++/" + Version.Text);
3704 addSystemInclude(DriverArgs, CC1Args,
3705 getDriver().SysRoot + "/usr/gcc/" + Version.MajorStr +
3706 "." + Version.MinorStr + "/include/c++/" +
3707 Version.Text + "/" +
3708 GCCInstallation.getTriple().str());
3712 /// Distribution (very bare-bones at the moment).
3715 // NB: Releases of a particular Linux distro should be kept together
3716 // in this enum, because some tests are done by integer comparison against
3717 // the first and last known member in the family, e.g. IsRedHat().
3750 static bool IsRedhat(enum Distro Distro) {
3751 return Distro == Fedora || (Distro >= RHEL5 && Distro <= RHEL7);
3754 static bool IsOpenSUSE(enum Distro Distro) { return Distro == OpenSUSE; }
3756 static bool IsDebian(enum Distro Distro) {
3757 return Distro >= DebianLenny && Distro <= DebianStretch;
3760 static bool IsUbuntu(enum Distro Distro) {
3761 return Distro >= UbuntuHardy && Distro <= UbuntuXenial;
3764 static Distro DetectDistro(const Driver &D, llvm::Triple::ArchType Arch) {
3765 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
3766 llvm::MemoryBuffer::getFile("/etc/lsb-release");
3768 StringRef Data = File.get()->getBuffer();
3769 SmallVector<StringRef, 16> Lines;
3770 Data.split(Lines, "\n");
3771 Distro Version = UnknownDistro;
3772 for (StringRef Line : Lines)
3773 if (Version == UnknownDistro && Line.startswith("DISTRIB_CODENAME="))
3774 Version = llvm::StringSwitch<Distro>(Line.substr(17))
3775 .Case("hardy", UbuntuHardy)
3776 .Case("intrepid", UbuntuIntrepid)
3777 .Case("jaunty", UbuntuJaunty)
3778 .Case("karmic", UbuntuKarmic)
3779 .Case("lucid", UbuntuLucid)
3780 .Case("maverick", UbuntuMaverick)
3781 .Case("natty", UbuntuNatty)
3782 .Case("oneiric", UbuntuOneiric)
3783 .Case("precise", UbuntuPrecise)
3784 .Case("quantal", UbuntuQuantal)
3785 .Case("raring", UbuntuRaring)
3786 .Case("saucy", UbuntuSaucy)
3787 .Case("trusty", UbuntuTrusty)
3788 .Case("utopic", UbuntuUtopic)
3789 .Case("vivid", UbuntuVivid)
3790 .Case("wily", UbuntuWily)
3791 .Case("xenial", UbuntuXenial)
3792 .Default(UnknownDistro);
3793 if (Version != UnknownDistro)
3797 File = llvm::MemoryBuffer::getFile("/etc/redhat-release");
3799 StringRef Data = File.get()->getBuffer();
3800 if (Data.startswith("Fedora release"))
3802 if (Data.startswith("Red Hat Enterprise Linux") ||
3803 Data.startswith("CentOS") ||
3804 Data.startswith("Scientific Linux")) {
3805 if (Data.find("release 7") != StringRef::npos)
3807 else if (Data.find("release 6") != StringRef::npos)
3809 else if (Data.find("release 5") != StringRef::npos)
3812 return UnknownDistro;
3815 File = llvm::MemoryBuffer::getFile("/etc/debian_version");
3817 StringRef Data = File.get()->getBuffer();
3820 else if (Data.startswith("squeeze/sid") || Data[0] == '6')
3821 return DebianSqueeze;
3822 else if (Data.startswith("wheezy/sid") || Data[0] == '7')
3823 return DebianWheezy;
3824 else if (Data.startswith("jessie/sid") || Data[0] == '8')
3825 return DebianJessie;
3826 else if (Data.startswith("stretch/sid") || Data[0] == '9')
3827 return DebianStretch;
3828 return UnknownDistro;
3831 if (D.getVFS().exists("/etc/SuSE-release"))
3834 if (D.getVFS().exists("/etc/exherbo-release"))
3837 if (D.getVFS().exists("/etc/arch-release"))
3840 return UnknownDistro;
3843 /// \brief Get our best guess at the multiarch triple for a target.
3845 /// Debian-based systems are starting to use a multiarch setup where they use
3846 /// a target-triple directory in the library and header search paths.
3847 /// Unfortunately, this triple does not align with the vanilla target triple,
3848 /// so we provide a rough mapping here.
3849 static std::string getMultiarchTriple(const Driver &D,
3850 const llvm::Triple &TargetTriple,
3851 StringRef SysRoot) {
3852 llvm::Triple::EnvironmentType TargetEnvironment =
3853 TargetTriple.getEnvironment();
3855 // For most architectures, just use whatever we have rather than trying to be
3857 switch (TargetTriple.getArch()) {
3861 // We use the existence of '/lib/<triple>' as a directory to detect some
3862 // common linux triples that don't quite match the Clang triple for both
3863 // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
3864 // regardless of what the actual target triple is.
3865 case llvm::Triple::arm:
3866 case llvm::Triple::thumb:
3867 if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
3868 if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabihf"))
3869 return "arm-linux-gnueabihf";
3871 if (D.getVFS().exists(SysRoot + "/lib/arm-linux-gnueabi"))
3872 return "arm-linux-gnueabi";
3875 case llvm::Triple::armeb:
3876 case llvm::Triple::thumbeb:
3877 if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
3878 if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabihf"))
3879 return "armeb-linux-gnueabihf";
3881 if (D.getVFS().exists(SysRoot + "/lib/armeb-linux-gnueabi"))
3882 return "armeb-linux-gnueabi";
3885 case llvm::Triple::x86:
3886 if (D.getVFS().exists(SysRoot + "/lib/i386-linux-gnu"))
3887 return "i386-linux-gnu";
3889 case llvm::Triple::x86_64:
3890 // We don't want this for x32, otherwise it will match x86_64 libs
3891 if (TargetEnvironment != llvm::Triple::GNUX32 &&
3892 D.getVFS().exists(SysRoot + "/lib/x86_64-linux-gnu"))
3893 return "x86_64-linux-gnu";
3895 case llvm::Triple::aarch64:
3896 if (D.getVFS().exists(SysRoot + "/lib/aarch64-linux-gnu"))
3897 return "aarch64-linux-gnu";
3899 case llvm::Triple::aarch64_be:
3900 if (D.getVFS().exists(SysRoot + "/lib/aarch64_be-linux-gnu"))
3901 return "aarch64_be-linux-gnu";
3903 case llvm::Triple::mips:
3904 if (D.getVFS().exists(SysRoot + "/lib/mips-linux-gnu"))
3905 return "mips-linux-gnu";
3907 case llvm::Triple::mipsel:
3908 if (D.getVFS().exists(SysRoot + "/lib/mipsel-linux-gnu"))
3909 return "mipsel-linux-gnu";
3911 case llvm::Triple::mips64:
3912 if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnu"))
3913 return "mips64-linux-gnu";
3914 if (D.getVFS().exists(SysRoot + "/lib/mips64-linux-gnuabi64"))
3915 return "mips64-linux-gnuabi64";
3917 case llvm::Triple::mips64el:
3918 if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnu"))
3919 return "mips64el-linux-gnu";
3920 if (D.getVFS().exists(SysRoot + "/lib/mips64el-linux-gnuabi64"))
3921 return "mips64el-linux-gnuabi64";
3923 case llvm::Triple::ppc:
3924 if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnuspe"))
3925 return "powerpc-linux-gnuspe";
3926 if (D.getVFS().exists(SysRoot + "/lib/powerpc-linux-gnu"))
3927 return "powerpc-linux-gnu";
3929 case llvm::Triple::ppc64:
3930 if (D.getVFS().exists(SysRoot + "/lib/powerpc64-linux-gnu"))
3931 return "powerpc64-linux-gnu";
3933 case llvm::Triple::ppc64le:
3934 if (D.getVFS().exists(SysRoot + "/lib/powerpc64le-linux-gnu"))
3935 return "powerpc64le-linux-gnu";
3937 case llvm::Triple::sparc:
3938 if (D.getVFS().exists(SysRoot + "/lib/sparc-linux-gnu"))
3939 return "sparc-linux-gnu";
3941 case llvm::Triple::sparcv9:
3942 if (D.getVFS().exists(SysRoot + "/lib/sparc64-linux-gnu"))
3943 return "sparc64-linux-gnu";
3945 case llvm::Triple::systemz:
3946 if (D.getVFS().exists(SysRoot + "/lib/s390x-linux-gnu"))
3947 return "s390x-linux-gnu";
3950 return TargetTriple.str();
3953 static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
3954 if (isMipsArch(Triple.getArch())) {
3955 // lib32 directory has a special meaning on MIPS targets.
3956 // It contains N32 ABI binaries. Use this folder if produce
3957 // code for N32 ABI only.
3958 if (tools::mips::hasMipsAbiArg(Args, "n32"))
3960 return Triple.isArch32Bit() ? "lib" : "lib64";
3963 // It happens that only x86 and PPC use the 'lib32' variant of oslibdir, and
3964 // using that variant while targeting other architectures causes problems
3965 // because the libraries are laid out in shared system roots that can't cope
3966 // with a 'lib32' library search path being considered. So we only enable
3967 // them when we know we may need it.
3969 // FIXME: This is a bit of a hack. We should really unify this code for
3970 // reasoning about oslibdir spellings with the lib dir spellings in the
3971 // GCCInstallationDetector, but that is a more significant refactoring.
3972 if (Triple.getArch() == llvm::Triple::x86 ||
3973 Triple.getArch() == llvm::Triple::ppc)
3976 if (Triple.getArch() == llvm::Triple::x86_64 &&
3977 Triple.getEnvironment() == llvm::Triple::GNUX32)
3980 return Triple.isArch32Bit() ? "lib" : "lib64";
3983 static void addMultilibsFilePaths(const Driver &D, const MultilibSet &Multilibs,
3984 const Multilib &Multilib,
3985 StringRef InstallPath,
3986 ToolChain::path_list &Paths) {
3987 if (const auto &PathsCallback = Multilibs.filePathsCallback())
3988 for (const auto &Path : PathsCallback(Multilib))
3989 addPathIfExists(D, InstallPath + Path, Paths);
3992 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
3993 : Generic_ELF(D, Triple, Args) {
3994 GCCInstallation.init(Triple, Args);
3995 CudaInstallation.init(Triple, Args);
3996 Multilibs = GCCInstallation.getMultilibs();
3997 llvm::Triple::ArchType Arch = Triple.getArch();
3998 std::string SysRoot = computeSysRoot();
4000 // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
4001 // least) put various tools in a triple-prefixed directory off of the parent
4002 // of the GCC installation. We use the GCC triple here to ensure that we end
4003 // up with tools that support the same amount of cross compiling as the
4004 // detected GCC installation. For example, if we find a GCC installation
4005 // targeting x86_64, but it is a bi-arch GCC installation, it can also be
4006 // used to target i386.
4007 // FIXME: This seems unlikely to be Linux-specific.
4008 ToolChain::path_list &PPaths = getProgramPaths();
4009 PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
4010 GCCInstallation.getTriple().str() + "/bin")
4013 Distro Distro = DetectDistro(D, Arch);
4015 if (IsOpenSUSE(Distro) || IsUbuntu(Distro)) {
4016 ExtraOpts.push_back("-z");
4017 ExtraOpts.push_back("relro");
4020 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
4021 ExtraOpts.push_back("-X");
4023 const bool IsAndroid = Triple.isAndroid();
4024 const bool IsMips = isMipsArch(Arch);
4026 if (IsMips && !SysRoot.empty())
4027 ExtraOpts.push_back("--sysroot=" + SysRoot);
4029 // Do not use 'gnu' hash style for Mips targets because .gnu.hash
4030 // and the MIPS ABI require .dynsym to be sorted in different ways.
4031 // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS
4032 // ABI requires a mapping between the GOT and the symbol table.
4033 // Android loader does not support .gnu.hash.
4034 if (!IsMips && !IsAndroid) {
4035 if (IsRedhat(Distro) || IsOpenSUSE(Distro) ||
4036 (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
4037 ExtraOpts.push_back("--hash-style=gnu");
4039 if (IsDebian(Distro) || IsOpenSUSE(Distro) || Distro == UbuntuLucid ||
4040 Distro == UbuntuJaunty || Distro == UbuntuKarmic)
4041 ExtraOpts.push_back("--hash-style=both");
4044 if (IsRedhat(Distro) && Distro != RHEL5 && Distro != RHEL6)
4045 ExtraOpts.push_back("--no-add-needed");
4047 #ifdef ENABLE_LINKER_BUILD_ID
4048 ExtraOpts.push_back("--build-id");
4051 if (IsOpenSUSE(Distro))
4052 ExtraOpts.push_back("--enable-new-dtags");
4054 // The selection of paths to try here is designed to match the patterns which
4055 // the GCC driver itself uses, as this is part of the GCC-compatible driver.
4056 // This was determined by running GCC in a fake filesystem, creating all
4057 // possible permutations of these directories, and seeing which ones it added
4058 // to the link paths.
4059 path_list &Paths = getFilePaths();
4061 const std::string OSLibDir = getOSLibDir(Triple, Args);
4062 const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);
4064 // Add the multilib suffixed paths where they are available.
4065 if (GCCInstallation.isValid()) {
4066 const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
4067 const std::string &LibPath = GCCInstallation.getParentLibPath();
4068 const Multilib &Multilib = GCCInstallation.getMultilib();
4069 const MultilibSet &Multilibs = GCCInstallation.getMultilibs();
4071 // Add toolchain / multilib specific file paths.
4072 addMultilibsFilePaths(D, Multilibs, Multilib,
4073 GCCInstallation.getInstallPath(), Paths);
4075 // Sourcery CodeBench MIPS toolchain holds some libraries under
4076 // a biarch-like suffix of the GCC installation.
4077 addPathIfExists(D, GCCInstallation.getInstallPath() + Multilib.gccSuffix(),
4080 // GCC cross compiling toolchains will install target libraries which ship
4081 // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
4082 // any part of the GCC installation in
4083 // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
4084 // debatable, but is the reality today. We need to search this tree even
4085 // when we have a sysroot somewhere else. It is the responsibility of
4086 // whomever is doing the cross build targeting a sysroot using a GCC
4087 // installation that is *not* within the system root to ensure two things:
4089 // 1) Any DSOs that are linked in from this tree or from the install path
4090 // above must be present on the system root and found via an
4091 // appropriate rpath.
4092 // 2) There must not be libraries installed into
4093 // <prefix>/<triple>/<libdir> unless they should be preferred over
4094 // those within the system root.
4096 // Note that this matches the GCC behavior. See the below comment for where
4097 // Clang diverges from GCC's behavior.
4098 addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib/../" +
4099 OSLibDir + Multilib.osSuffix(),
4102 // If the GCC installation we found is inside of the sysroot, we want to
4103 // prefer libraries installed in the parent prefix of the GCC installation.
4104 // It is important to *not* use these paths when the GCC installation is
4105 // outside of the system root as that can pick up unintended libraries.
4106 // This usually happens when there is an external cross compiler on the
4107 // host system, and a more minimal sysroot available that is the target of
4108 // the cross. Note that GCC does include some of these directories in some
4109 // configurations but this seems somewhere between questionable and simply
4111 if (StringRef(LibPath).startswith(SysRoot)) {
4112 addPathIfExists(D, LibPath + "/" + MultiarchTriple, Paths);
4113 addPathIfExists(D, LibPath + "/../" + OSLibDir, Paths);
4117 // Similar to the logic for GCC above, if we currently running Clang inside
4118 // of the requested system root, add its parent library paths to
4120 // FIXME: It's not clear whether we should use the driver's installed
4121 // directory ('Dir' below) or the ResourceDir.
4122 if (StringRef(D.Dir).startswith(SysRoot)) {
4123 addPathIfExists(D, D.Dir + "/../lib/" + MultiarchTriple, Paths);
4124 addPathIfExists(D, D.Dir + "/../" + OSLibDir, Paths);
4127 addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths);
4128 addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths);
4129 addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
4130 addPathIfExists(D, SysRoot + "/usr/lib/../" + OSLibDir, Paths);
4132 // Try walking via the GCC triple path in case of biarch or multiarch GCC
4133 // installations with strange symlinks.
4134 if (GCCInstallation.isValid()) {
4136 SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
4137 "/../../" + OSLibDir,
4140 // Add the 'other' biarch variant path
4141 Multilib BiarchSibling;
4142 if (GCCInstallation.getBiarchSibling(BiarchSibling)) {
4143 addPathIfExists(D, GCCInstallation.getInstallPath() +
4144 BiarchSibling.gccSuffix(),
4148 // See comments above on the multilib variant for details of why this is
4149 // included even from outside the sysroot.
4150 const std::string &LibPath = GCCInstallation.getParentLibPath();
4151 const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
4152 const Multilib &Multilib = GCCInstallation.getMultilib();
4153 addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib" +
4154 Multilib.osSuffix(),
4157 // See comments above on the multilib variant for details of why this is
4158 // only included from within the sysroot.
4159 if (StringRef(LibPath).startswith(SysRoot))
4160 addPathIfExists(D, LibPath, Paths);
4163 // Similar to the logic for GCC above, if we are currently running Clang
4164 // inside of the requested system root, add its parent library path to those
4166 // FIXME: It's not clear whether we should use the driver's installed
4167 // directory ('Dir' below) or the ResourceDir.
4168 if (StringRef(D.Dir).startswith(SysRoot))
4169 addPathIfExists(D, D.Dir + "/../lib", Paths);
4171 addPathIfExists(D, SysRoot + "/lib", Paths);
4172 addPathIfExists(D, SysRoot + "/usr/lib", Paths);
4175 bool Linux::HasNativeLLVMSupport() const { return true; }
4177 Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }
4179 Tool *Linux::buildAssembler() const {
4180 return new tools::gnutools::Assembler(*this);
4183 std::string Linux::computeSysRoot() const {
4184 if (!getDriver().SysRoot.empty())
4185 return getDriver().SysRoot;
4187 if (!GCCInstallation.isValid() || !isMipsArch(getTriple().getArch()))
4188 return std::string();
4190 // Standalone MIPS toolchains use different names for sysroot folder
4191 // and put it into different places. Here we try to check some known
4194 const StringRef InstallDir = GCCInstallation.getInstallPath();
4195 const StringRef TripleStr = GCCInstallation.getTriple().str();
4196 const Multilib &Multilib = GCCInstallation.getMultilib();
4199 (InstallDir + "/../../../../" + TripleStr + "/libc" + Multilib.osSuffix())
4202 if (getVFS().exists(Path))
4205 Path = (InstallDir + "/../../../../sysroot" + Multilib.osSuffix()).str();
4207 if (getVFS().exists(Path))
4210 return std::string();
4213 std::string Linux::getDynamicLinker(const ArgList &Args) const {
4214 const llvm::Triple::ArchType Arch = getArch();
4215 const llvm::Triple &Triple = getTriple();
4217 const enum Distro Distro = DetectDistro(getDriver(), Arch);
4219 if (Triple.isAndroid())
4220 return Triple.isArch64Bit() ? "/system/bin/linker64" : "/system/bin/linker";
4221 else if (Triple.isMusl()) {
4222 std::string ArchName;
4224 case llvm::Triple::thumb:
4227 case llvm::Triple::thumbeb:
4231 ArchName = Triple.getArchName().str();
4233 if (Triple.getEnvironment() == llvm::Triple::MuslEABIHF)
4236 return "/lib/ld-musl-" + ArchName + ".so.1";
4244 llvm_unreachable("unsupported architecture");
4246 case llvm::Triple::aarch64:
4248 Loader = "ld-linux-aarch64.so.1";
4250 case llvm::Triple::aarch64_be:
4252 Loader = "ld-linux-aarch64_be.so.1";
4254 case llvm::Triple::arm:
4255 case llvm::Triple::thumb:
4256 case llvm::Triple::armeb:
4257 case llvm::Triple::thumbeb: {
4259 Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
4260 tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard;
4263 Loader = HF ? "ld-linux-armhf.so.3" : "ld-linux.so.3";
4266 case llvm::Triple::mips:
4267 case llvm::Triple::mipsel:
4268 case llvm::Triple::mips64:
4269 case llvm::Triple::mips64el: {
4270 bool LE = (Triple.getArch() == llvm::Triple::mipsel) ||
4271 (Triple.getArch() == llvm::Triple::mips64el);
4272 bool IsNaN2008 = tools::mips::isNaN2008(Args, Triple);
4274 LibDir = "lib" + tools::mips::getMipsABILibSuffix(Args, Triple);
4276 if (tools::mips::isUCLibc(Args))
4277 Loader = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
4278 else if (!Triple.hasEnvironment() &&
4279 Triple.getVendor() == llvm::Triple::VendorType::MipsTechnologies)
4280 Loader = LE ? "ld-musl-mipsel.so.1" : "ld-musl-mips.so.1";
4282 Loader = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
4286 case llvm::Triple::ppc:
4290 case llvm::Triple::ppc64:
4293 (tools::ppc::hasPPCAbiArg(Args, "elfv2")) ? "ld64.so.2" : "ld64.so.1";
4295 case llvm::Triple::ppc64le:
4298 (tools::ppc::hasPPCAbiArg(Args, "elfv1")) ? "ld64.so.1" : "ld64.so.2";
4300 case llvm::Triple::sparc:
4301 case llvm::Triple::sparcel:
4303 Loader = "ld-linux.so.2";
4305 case llvm::Triple::sparcv9:
4307 Loader = "ld-linux.so.2";
4309 case llvm::Triple::systemz:
4311 Loader = "ld64.so.1";
4313 case llvm::Triple::x86:
4315 Loader = "ld-linux.so.2";
4317 case llvm::Triple::x86_64: {
4318 bool X32 = Triple.getEnvironment() == llvm::Triple::GNUX32;
4320 LibDir = X32 ? "libx32" : "lib64";
4321 Loader = X32 ? "ld-linux-x32.so.2" : "ld-linux-x86-64.so.2";
4326 if (Distro == Exherbo && (Triple.getVendor() == llvm::Triple::UnknownVendor ||
4327 Triple.getVendor() == llvm::Triple::PC))
4328 return "/usr/" + Triple.str() + "/lib/" + Loader;
4329 return "/" + LibDir + "/" + Loader;
4332 void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
4333 ArgStringList &CC1Args) const {
4334 const Driver &D = getDriver();
4335 std::string SysRoot = computeSysRoot();
4337 if (DriverArgs.hasArg(options::OPT_nostdinc))
4340 if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
4341 addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
4343 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
4344 SmallString<128> P(D.ResourceDir);
4345 llvm::sys::path::append(P, "include");
4346 addSystemInclude(DriverArgs, CC1Args, P);
4349 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
4352 // Check for configure-time C include directories.
4353 StringRef CIncludeDirs(C_INCLUDE_DIRS);
4354 if (CIncludeDirs != "") {
4355 SmallVector<StringRef, 5> dirs;
4356 CIncludeDirs.split(dirs, ":");
4357 for (StringRef dir : dirs) {
4359 llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) : "";
4360 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
4365 // Lacking those, try to detect the correct set of system includes for the
4368 // Add include directories specific to the selected multilib set and multilib.
4369 if (GCCInstallation.isValid()) {
4370 const auto &Callback = Multilibs.includeDirsCallback();
4372 for (const auto &Path : Callback(GCCInstallation.getMultilib()))
4373 addExternCSystemIncludeIfExists(
4374 DriverArgs, CC1Args, GCCInstallation.getInstallPath() + Path);
4378 // Implement generic Debian multiarch support.
4379 const StringRef X86_64MultiarchIncludeDirs[] = {
4380 "/usr/include/x86_64-linux-gnu",
4382 // FIXME: These are older forms of multiarch. It's not clear that they're
4383 // in use in any released version of Debian, so we should consider
4385 "/usr/include/i686-linux-gnu/64", "/usr/include/i486-linux-gnu/64"};
4386 const StringRef X86MultiarchIncludeDirs[] = {
4387 "/usr/include/i386-linux-gnu",
4389 // FIXME: These are older forms of multiarch. It's not clear that they're
4390 // in use in any released version of Debian, so we should consider
4392 "/usr/include/x86_64-linux-gnu/32", "/usr/include/i686-linux-gnu",
4393 "/usr/include/i486-linux-gnu"};
4394 const StringRef AArch64MultiarchIncludeDirs[] = {
4395 "/usr/include/aarch64-linux-gnu"};
4396 const StringRef ARMMultiarchIncludeDirs[] = {
4397 "/usr/include/arm-linux-gnueabi"};
4398 const StringRef ARMHFMultiarchIncludeDirs[] = {
4399 "/usr/include/arm-linux-gnueabihf"};
4400 const StringRef ARMEBMultiarchIncludeDirs[] = {
4401 "/usr/include/armeb-linux-gnueabi"};
4402 const StringRef ARMEBHFMultiarchIncludeDirs[] = {
4403 "/usr/include/armeb-linux-gnueabihf"};
4404 const StringRef MIPSMultiarchIncludeDirs[] = {"/usr/include/mips-linux-gnu"};
4405 const StringRef MIPSELMultiarchIncludeDirs[] = {
4406 "/usr/include/mipsel-linux-gnu"};
4407 const StringRef MIPS64MultiarchIncludeDirs[] = {
4408 "/usr/include/mips64-linux-gnu", "/usr/include/mips64-linux-gnuabi64"};
4409 const StringRef MIPS64ELMultiarchIncludeDirs[] = {
4410 "/usr/include/mips64el-linux-gnu",
4411 "/usr/include/mips64el-linux-gnuabi64"};
4412 const StringRef PPCMultiarchIncludeDirs[] = {
4413 "/usr/include/powerpc-linux-gnu"};
4414 const StringRef PPC64MultiarchIncludeDirs[] = {
4415 "/usr/include/powerpc64-linux-gnu"};
4416 const StringRef PPC64LEMultiarchIncludeDirs[] = {
4417 "/usr/include/powerpc64le-linux-gnu"};
4418 const StringRef SparcMultiarchIncludeDirs[] = {
4419 "/usr/include/sparc-linux-gnu"};
4420 const StringRef Sparc64MultiarchIncludeDirs[] = {
4421 "/usr/include/sparc64-linux-gnu"};
4422 const StringRef SYSTEMZMultiarchIncludeDirs[] = {
4423 "/usr/include/s390x-linux-gnu"};
4424 ArrayRef<StringRef> MultiarchIncludeDirs;
4425 switch (getTriple().getArch()) {
4426 case llvm::Triple::x86_64:
4427 MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
4429 case llvm::Triple::x86:
4430 MultiarchIncludeDirs = X86MultiarchIncludeDirs;
4432 case llvm::Triple::aarch64:
4433 case llvm::Triple::aarch64_be:
4434 MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
4436 case llvm::Triple::arm:
4437 case llvm::Triple::thumb:
4438 if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
4439 MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
4441 MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
4443 case llvm::Triple::armeb:
4444 case llvm::Triple::thumbeb:
4445 if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
4446 MultiarchIncludeDirs = ARMEBHFMultiarchIncludeDirs;
4448 MultiarchIncludeDirs = ARMEBMultiarchIncludeDirs;
4450 case llvm::Triple::mips:
4451 MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
4453 case llvm::Triple::mipsel:
4454 MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
4456 case llvm::Triple::mips64:
4457 MultiarchIncludeDirs = MIPS64MultiarchIncludeDirs;
4459 case llvm::Triple::mips64el:
4460 MultiarchIncludeDirs = MIPS64ELMultiarchIncludeDirs;
4462 case llvm::Triple::ppc:
4463 MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
4465 case llvm::Triple::ppc64:
4466 MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
4468 case llvm::Triple::ppc64le:
4469 MultiarchIncludeDirs = PPC64LEMultiarchIncludeDirs;
4471 case llvm::Triple::sparc:
4472 MultiarchIncludeDirs = SparcMultiarchIncludeDirs;
4474 case llvm::Triple::sparcv9:
4475 MultiarchIncludeDirs = Sparc64MultiarchIncludeDirs;
4477 case llvm::Triple::systemz:
4478 MultiarchIncludeDirs = SYSTEMZMultiarchIncludeDirs;
4483 for (StringRef Dir : MultiarchIncludeDirs) {
4484 if (D.getVFS().exists(SysRoot + Dir)) {
4485 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + Dir);
4490 if (getTriple().getOS() == llvm::Triple::RTEMS)
4493 // Add an include of '/include' directly. This isn't provided by default by
4494 // system GCCs, but is often used with cross-compiling GCCs, and harmless to
4495 // add even when Clang is acting as-if it were a system compiler.
4496 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
4498 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
4501 static std::string DetectLibcxxIncludePath(StringRef base) {
4504 std::string MaxVersionString = "";
4505 for (llvm::sys::fs::directory_iterator LI(base, EC), LE; !EC && LI != LE;
4506 LI = LI.increment(EC)) {
4507 StringRef VersionText = llvm::sys::path::filename(LI->path());
4509 if (VersionText[0] == 'v' &&
4510 !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
4511 if (Version > MaxVersion) {
4512 MaxVersion = Version;
4513 MaxVersionString = VersionText;
4517 return MaxVersion ? (base + "/" + MaxVersionString).str() : "";
4520 void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
4521 ArgStringList &CC1Args) const {
4522 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4523 DriverArgs.hasArg(options::OPT_nostdincxx))
4526 // Check if libc++ has been enabled and provide its include paths if so.
4527 if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
4528 const std::string LibCXXIncludePathCandidates[] = {
4529 DetectLibcxxIncludePath(getDriver().Dir + "/../include/c++"),
4530 // If this is a development, non-installed, clang, libcxx will
4531 // not be found at ../include/c++ but it likely to be found at
4532 // one of the following two locations:
4533 DetectLibcxxIncludePath(getDriver().SysRoot + "/usr/local/include/c++"),
4534 DetectLibcxxIncludePath(getDriver().SysRoot + "/usr/include/c++") };
4535 for (const auto &IncludePath : LibCXXIncludePathCandidates) {
4536 if (IncludePath.empty() || !getVFS().exists(IncludePath))
4538 // Add the first candidate that exists.
4539 addSystemInclude(DriverArgs, CC1Args, IncludePath);
4545 // We need a detected GCC installation on Linux to provide libstdc++'s
4546 // headers. We handled the libc++ case above.
4547 if (!GCCInstallation.isValid())
4550 // By default, look for the C++ headers in an include directory adjacent to
4551 // the lib directory of the GCC installation. Note that this is expect to be
4552 // equivalent to '/usr/include/c++/X.Y' in almost all cases.
4553 StringRef LibDir = GCCInstallation.getParentLibPath();
4554 StringRef InstallDir = GCCInstallation.getInstallPath();
4555 StringRef TripleStr = GCCInstallation.getTriple().str();
4556 const Multilib &Multilib = GCCInstallation.getMultilib();
4557 const std::string GCCMultiarchTriple = getMultiarchTriple(
4558 getDriver(), GCCInstallation.getTriple(), getDriver().SysRoot);
4559 const std::string TargetMultiarchTriple =
4560 getMultiarchTriple(getDriver(), getTriple(), getDriver().SysRoot);
4561 const GCCVersion &Version = GCCInstallation.getVersion();
4563 // The primary search for libstdc++ supports multiarch variants.
4564 if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
4565 "/c++/" + Version.Text, TripleStr,
4566 GCCMultiarchTriple, TargetMultiarchTriple,
4567 Multilib.includeSuffix(), DriverArgs, CC1Args))
4570 // Otherwise, fall back on a bunch of options which don't use multiarch
4571 // layouts for simplicity.
4572 const std::string LibStdCXXIncludePathCandidates[] = {
4573 // Gentoo is weird and places its headers inside the GCC install,
4574 // so if the first attempt to find the headers fails, try these patterns.
4575 InstallDir.str() + "/include/g++-v" + Version.Text,
4576 InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
4578 InstallDir.str() + "/include/g++-v" + Version.MajorStr,
4579 // Android standalone toolchain has C++ headers in yet another place.
4580 LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
4581 // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++,
4582 // without a subdirectory corresponding to the gcc version.
4583 LibDir.str() + "/../include/c++",
4586 for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {
4587 if (addLibStdCXXIncludePaths(IncludePath, /*Suffix*/ "", TripleStr,
4588 /*GCCMultiarchTriple*/ "",
4589 /*TargetMultiarchTriple*/ "",
4590 Multilib.includeSuffix(), DriverArgs, CC1Args))
4595 void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,
4596 ArgStringList &CC1Args) const {
4597 if (DriverArgs.hasArg(options::OPT_nocudainc))
4600 if (!CudaInstallation.isValid()) {
4601 getDriver().Diag(diag::err_drv_no_cuda_installation);
4605 addSystemInclude(DriverArgs, CC1Args, CudaInstallation.getIncludePath());
4606 CC1Args.push_back("-include");
4607 CC1Args.push_back("__clang_cuda_runtime_wrapper.h");
4610 void Linux::AddIAMCUIncludeArgs(const ArgList &DriverArgs,
4611 ArgStringList &CC1Args) const {
4612 if (GCCInstallation.isValid()) {
4613 CC1Args.push_back("-isystem");
4614 CC1Args.push_back(DriverArgs.MakeArgString(
4615 GCCInstallation.getParentLibPath() + "/../" +
4616 GCCInstallation.getTriple().str() + "/include"));
4620 bool Linux::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); }
4622 SanitizerMask Linux::getSupportedSanitizers() const {
4623 const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
4624 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
4625 const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 ||
4626 getTriple().getArch() == llvm::Triple::mips64el;
4627 const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||
4628 getTriple().getArch() == llvm::Triple::ppc64le;
4629 const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
4630 getTriple().getArch() == llvm::Triple::aarch64_be;
4631 SanitizerMask Res = ToolChain::getSupportedSanitizers();
4632 Res |= SanitizerKind::Address;
4633 Res |= SanitizerKind::KernelAddress;
4634 Res |= SanitizerKind::Vptr;
4635 Res |= SanitizerKind::SafeStack;
4636 if (IsX86_64 || IsMIPS64 || IsAArch64)
4637 Res |= SanitizerKind::DataFlow;
4638 if (IsX86_64 || IsMIPS64 || IsAArch64)
4639 Res |= SanitizerKind::Leak;
4640 if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64)
4641 Res |= SanitizerKind::Thread;
4642 if (IsX86_64 || IsMIPS64 || IsPowerPC64 || IsAArch64)
4643 Res |= SanitizerKind::Memory;
4645 Res |= SanitizerKind::Efficiency;
4646 if (IsX86 || IsX86_64) {
4647 Res |= SanitizerKind::Function;
4652 void Linux::addProfileRTLibs(const llvm::opt::ArgList &Args,
4653 llvm::opt::ArgStringList &CmdArgs) const {
4654 if (!needsProfileRT(Args)) return;
4656 // Add linker option -u__llvm_runtime_variable to cause runtime
4657 // initialization module to be linked in.
4658 if (!Args.hasArg(options::OPT_coverage))
4659 CmdArgs.push_back(Args.MakeArgString(
4660 Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
4661 ToolChain::addProfileRTLibs(Args, CmdArgs);
4664 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
4666 DragonFly::DragonFly(const Driver &D, const llvm::Triple &Triple,
4667 const ArgList &Args)
4668 : Generic_ELF(D, Triple, Args) {
4670 // Path mangling to find libexec
4671 getProgramPaths().push_back(getDriver().getInstalledDir());
4672 if (getDriver().getInstalledDir() != getDriver().Dir)
4673 getProgramPaths().push_back(getDriver().Dir);
4675 getFilePaths().push_back(getDriver().Dir + "/../lib");
4676 getFilePaths().push_back("/usr/lib");
4677 getFilePaths().push_back("/usr/lib/gcc50");
4680 Tool *DragonFly::buildAssembler() const {
4681 return new tools::dragonfly::Assembler(*this);
4684 Tool *DragonFly::buildLinker() const {
4685 return new tools::dragonfly::Linker(*this);
4688 /// CUDA toolchain. Our assembler is ptxas, and our "linker" is fatbinary,
4689 /// which isn't properly a linker but nonetheless performs the step of stitching
4690 /// together object files from the assembler into a single blob.
4692 CudaToolChain::CudaToolChain(const Driver &D, const llvm::Triple &Triple,
4693 const ArgList &Args)
4694 : Linux(D, Triple, Args) {
4695 if (CudaInstallation.isValid())
4696 getProgramPaths().push_back(CudaInstallation.getBinPath());
4700 CudaToolChain::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
4701 llvm::opt::ArgStringList &CC1Args) const {
4702 Linux::addClangTargetOptions(DriverArgs, CC1Args);
4703 CC1Args.push_back("-fcuda-is-device");
4705 if (DriverArgs.hasFlag(options::OPT_fcuda_flush_denormals_to_zero,
4706 options::OPT_fno_cuda_flush_denormals_to_zero, false))
4707 CC1Args.push_back("-fcuda-flush-denormals-to-zero");
4709 if (DriverArgs.hasFlag(options::OPT_fcuda_approx_transcendentals,
4710 options::OPT_fno_cuda_approx_transcendentals, false))
4711 CC1Args.push_back("-fcuda-approx-transcendentals");
4713 if (DriverArgs.hasArg(options::OPT_nocudalib))
4716 std::string LibDeviceFile = CudaInstallation.getLibDeviceFile(
4717 DriverArgs.getLastArgValue(options::OPT_march_EQ));
4718 if (!LibDeviceFile.empty()) {
4719 CC1Args.push_back("-mlink-cuda-bitcode");
4720 CC1Args.push_back(DriverArgs.MakeArgString(LibDeviceFile));
4722 // Libdevice in CUDA-7.0 requires PTX version that's more recent
4723 // than LLVM defaults to. Use PTX4.2 which is the PTX version that
4724 // came with CUDA-7.0.
4725 CC1Args.push_back("-target-feature");
4726 CC1Args.push_back("+ptx42");
4730 void CudaToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
4731 ArgStringList &CC1Args) const {
4732 // Check our CUDA version if we're going to include the CUDA headers.
4733 if (!DriverArgs.hasArg(options::OPT_nocudainc) &&
4734 !DriverArgs.hasArg(options::OPT_no_cuda_version_check)) {
4735 StringRef Arch = DriverArgs.getLastArgValue(options::OPT_march_EQ);
4736 assert(!Arch.empty() && "Must have an explicit GPU arch.");
4737 CudaInstallation.CheckCudaVersionSupportsArch(StringToCudaArch(Arch));
4739 Linux::AddCudaIncludeArgs(DriverArgs, CC1Args);
4742 llvm::opt::DerivedArgList *
4743 CudaToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
4744 const char *BoundArch) const {
4745 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
4746 const OptTable &Opts = getDriver().getOpts();
4748 for (Arg *A : Args) {
4749 if (A->getOption().matches(options::OPT_Xarch__)) {
4750 // Skip this argument unless the architecture matches BoundArch
4751 if (!BoundArch || A->getValue(0) != StringRef(BoundArch))
4754 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
4755 unsigned Prev = Index;
4756 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
4758 // If the argument parsing failed or more than one argument was
4759 // consumed, the -Xarch_ argument's parameter tried to consume
4760 // extra arguments. Emit an error and ignore.
4762 // We also want to disallow any options which would alter the
4763 // driver behavior; that isn't going to work in our model. We
4764 // use isDriverOption() as an approximation, although things
4765 // like -O4 are going to slip through.
4766 if (!XarchArg || Index > Prev + 1) {
4767 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
4768 << A->getAsString(Args);
4770 } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
4771 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
4772 << A->getAsString(Args);
4775 XarchArg->setBaseArg(A);
4776 A = XarchArg.release();
4777 DAL->AddSynthesizedArg(A);
4783 DAL->eraseArg(options::OPT_march_EQ);
4784 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ), BoundArch);
4789 Tool *CudaToolChain::buildAssembler() const {
4790 return new tools::NVPTX::Assembler(*this);
4793 Tool *CudaToolChain::buildLinker() const {
4794 return new tools::NVPTX::Linker(*this);
4797 /// XCore tool chain
4798 XCoreToolChain::XCoreToolChain(const Driver &D, const llvm::Triple &Triple,
4799 const ArgList &Args)
4800 : ToolChain(D, Triple, Args) {
4801 // ProgramPaths are found via 'PATH' environment variable.
4804 Tool *XCoreToolChain::buildAssembler() const {
4805 return new tools::XCore::Assembler(*this);
4808 Tool *XCoreToolChain::buildLinker() const {
4809 return new tools::XCore::Linker(*this);
4812 bool XCoreToolChain::isPICDefault() const { return false; }
4814 bool XCoreToolChain::isPIEDefault() const { return false; }
4816 bool XCoreToolChain::isPICDefaultForced() const { return false; }
4818 bool XCoreToolChain::SupportsProfiling() const { return false; }
4820 bool XCoreToolChain::hasBlocksRuntime() const { return false; }
4822 void XCoreToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
4823 ArgStringList &CC1Args) const {
4824 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
4825 DriverArgs.hasArg(options::OPT_nostdlibinc))
4827 if (const char *cl_include_dir = getenv("XCC_C_INCLUDE_PATH")) {
4828 SmallVector<StringRef, 4> Dirs;
4829 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
4830 StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
4831 ArrayRef<StringRef> DirVec(Dirs);
4832 addSystemIncludes(DriverArgs, CC1Args, DirVec);
4836 void XCoreToolChain::addClangTargetOptions(const ArgList &DriverArgs,
4837 ArgStringList &CC1Args) const {
4838 CC1Args.push_back("-nostdsysteminc");
4841 void XCoreToolChain::AddClangCXXStdlibIncludeArgs(
4842 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
4843 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
4844 DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4845 DriverArgs.hasArg(options::OPT_nostdincxx))
4847 if (const char *cl_include_dir = getenv("XCC_CPLUS_INCLUDE_PATH")) {
4848 SmallVector<StringRef, 4> Dirs;
4849 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
4850 StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
4851 ArrayRef<StringRef> DirVec(Dirs);
4852 addSystemIncludes(DriverArgs, CC1Args, DirVec);
4856 void XCoreToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
4857 ArgStringList &CmdArgs) const {
4858 // We don't output any lib args. This is handled by xcc.
4861 MyriadToolChain::MyriadToolChain(const Driver &D, const llvm::Triple &Triple,
4862 const ArgList &Args)
4863 : Generic_ELF(D, Triple, Args) {
4864 // If a target of 'sparc-myriad-elf' is specified to clang, it wants to use
4865 // 'sparc-myriad--elf' (note the unknown OS) as the canonical triple.
4866 // This won't work to find gcc. Instead we give the installation detector an
4867 // extra triple, which is preferable to further hacks of the logic that at
4868 // present is based solely on getArch(). In particular, it would be wrong to
4869 // choose the myriad installation when targeting a non-myriad sparc install.
4870 switch (Triple.getArch()) {
4872 D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4874 case llvm::Triple::sparc:
4875 case llvm::Triple::sparcel:
4876 case llvm::Triple::shave:
4877 GCCInstallation.init(Triple, Args, {"sparc-myriad-elf"});
4880 if (GCCInstallation.isValid()) {
4881 // The contents of LibDir are independent of the version of gcc.
4882 // This contains libc, libg (a superset of libc), libm, libstdc++, libssp.
4883 SmallString<128> LibDir(GCCInstallation.getParentLibPath());
4884 if (Triple.getArch() == llvm::Triple::sparcel)
4885 llvm::sys::path::append(LibDir, "../sparc-myriad-elf/lib/le");
4887 llvm::sys::path::append(LibDir, "../sparc-myriad-elf/lib");
4888 addPathIfExists(D, LibDir, getFilePaths());
4890 // This directory contains crt{i,n,begin,end}.o as well as libgcc.
4891 // These files are tied to a particular version of gcc.
4892 SmallString<128> CompilerSupportDir(GCCInstallation.getInstallPath());
4893 // There are actually 4 choices: {le,be} x {fpu,nofpu}
4894 // but as this toolchain is for LEON sparc, it can assume FPU.
4895 if (Triple.getArch() == llvm::Triple::sparcel)
4896 llvm::sys::path::append(CompilerSupportDir, "le");
4897 addPathIfExists(D, CompilerSupportDir, getFilePaths());
4901 MyriadToolChain::~MyriadToolChain() {}
4903 void MyriadToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
4904 ArgStringList &CC1Args) const {
4905 if (!DriverArgs.hasArg(options::OPT_nostdinc))
4906 addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot + "/include");
4909 void MyriadToolChain::AddClangCXXStdlibIncludeArgs(
4910 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
4911 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4912 DriverArgs.hasArg(options::OPT_nostdincxx))
4915 // Only libstdc++, for now.
4916 StringRef LibDir = GCCInstallation.getParentLibPath();
4917 const GCCVersion &Version = GCCInstallation.getVersion();
4918 StringRef TripleStr = GCCInstallation.getTriple().str();
4919 const Multilib &Multilib = GCCInstallation.getMultilib();
4921 addLibStdCXXIncludePaths(
4922 LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
4923 "", TripleStr, "", "", Multilib.includeSuffix(), DriverArgs, CC1Args);
4926 // MyriadToolChain handles several triples:
4927 // {shave,sparc{,el}}-myriad-{rtems,unknown}-elf
4928 Tool *MyriadToolChain::SelectTool(const JobAction &JA) const {
4929 // The inherited method works fine if not targeting the SHAVE.
4930 if (!isShaveCompilation(getTriple()))
4931 return ToolChain::SelectTool(JA);
4932 switch (JA.getKind()) {
4933 case Action::PreprocessJobClass:
4934 case Action::CompileJobClass:
4936 Compiler.reset(new tools::SHAVE::Compiler(*this));
4937 return Compiler.get();
4938 case Action::AssembleJobClass:
4940 Assembler.reset(new tools::SHAVE::Assembler(*this));
4941 return Assembler.get();
4943 return ToolChain::getTool(JA.getKind());
4947 Tool *MyriadToolChain::buildLinker() const {
4948 return new tools::Myriad::Linker(*this);
4951 WebAssembly::WebAssembly(const Driver &D, const llvm::Triple &Triple,
4952 const llvm::opt::ArgList &Args)
4953 : ToolChain(D, Triple, Args) {
4955 assert(Triple.isArch32Bit() != Triple.isArch64Bit());
4956 getFilePaths().push_back(
4957 getDriver().SysRoot + "/lib" + (Triple.isArch32Bit() ? "32" : "64"));
4959 // Use LLD by default.
4960 DefaultLinker = "lld";
4963 bool WebAssembly::IsMathErrnoDefault() const { return false; }
4965 bool WebAssembly::IsObjCNonFragileABIDefault() const { return true; }
4967 bool WebAssembly::UseObjCMixedDispatch() const { return true; }
4969 bool WebAssembly::isPICDefault() const { return false; }
4971 bool WebAssembly::isPIEDefault() const { return false; }
4973 bool WebAssembly::isPICDefaultForced() const { return false; }
4975 bool WebAssembly::IsIntegratedAssemblerDefault() const { return true; }
4977 // TODO: Support Objective C stuff.
4978 bool WebAssembly::SupportsObjCGC() const { return false; }
4980 bool WebAssembly::hasBlocksRuntime() const { return false; }
4982 // TODO: Support profiling.
4983 bool WebAssembly::SupportsProfiling() const { return false; }
4985 bool WebAssembly::HasNativeLLVMSupport() const { return true; }
4987 void WebAssembly::addClangTargetOptions(const ArgList &DriverArgs,
4988 ArgStringList &CC1Args) const {
4989 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
4990 options::OPT_fno_use_init_array, true))
4991 CC1Args.push_back("-fuse-init-array");
4994 ToolChain::RuntimeLibType WebAssembly::GetDefaultRuntimeLibType() const {
4995 return ToolChain::RLT_CompilerRT;
4998 ToolChain::CXXStdlibType WebAssembly::GetCXXStdlibType(const ArgList &Args) const {
4999 return ToolChain::CST_Libcxx;
5002 void WebAssembly::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
5003 ArgStringList &CC1Args) const {
5004 if (!DriverArgs.hasArg(options::OPT_nostdinc))
5005 addSystemInclude(DriverArgs, CC1Args, getDriver().SysRoot + "/include");
5008 void WebAssembly::AddClangCXXStdlibIncludeArgs(
5009 const llvm::opt::ArgList &DriverArgs,
5010 llvm::opt::ArgStringList &CC1Args) const {
5011 if (!DriverArgs.hasArg(options::OPT_nostdlibinc) &&
5012 !DriverArgs.hasArg(options::OPT_nostdincxx))
5013 addSystemInclude(DriverArgs, CC1Args,
5014 getDriver().SysRoot + "/include/c++/v1");
5017 Tool *WebAssembly::buildLinker() const {
5018 return new tools::wasm::Linker(*this);
5021 PS4CPU::PS4CPU(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
5022 : Generic_ELF(D, Triple, Args) {
5023 if (Args.hasArg(options::OPT_static))
5024 D.Diag(diag::err_drv_unsupported_opt_for_target) << "-static" << "PS4";
5026 // Determine where to find the PS4 libraries. We use SCE_ORBIS_SDK_DIR
5027 // if it exists; otherwise use the driver's installation path, which
5028 // should be <SDK_DIR>/host_tools/bin.
5030 SmallString<512> PS4SDKDir;
5031 if (const char *EnvValue = getenv("SCE_ORBIS_SDK_DIR")) {
5032 if (!llvm::sys::fs::exists(EnvValue))
5033 getDriver().Diag(clang::diag::warn_drv_ps4_sdk_dir) << EnvValue;
5034 PS4SDKDir = EnvValue;
5036 PS4SDKDir = getDriver().Dir;
5037 llvm::sys::path::append(PS4SDKDir, "/../../");
5040 // By default, the driver won't report a warning if it can't find
5041 // PS4's include or lib directories. This behavior could be changed if
5042 // -Weverything or -Winvalid-or-nonexistent-directory options are passed.
5043 // If -isysroot was passed, use that as the SDK base path.
5044 std::string PrefixDir;
5045 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
5046 PrefixDir = A->getValue();
5047 if (!llvm::sys::fs::exists(PrefixDir))
5048 getDriver().Diag(clang::diag::warn_missing_sysroot) << PrefixDir;
5050 PrefixDir = PS4SDKDir.str();
5052 SmallString<512> PS4SDKIncludeDir(PrefixDir);
5053 llvm::sys::path::append(PS4SDKIncludeDir, "target/include");
5054 if (!Args.hasArg(options::OPT_nostdinc) &&
5055 !Args.hasArg(options::OPT_nostdlibinc) &&
5056 !Args.hasArg(options::OPT_isysroot) &&
5057 !Args.hasArg(options::OPT__sysroot_EQ) &&
5058 !llvm::sys::fs::exists(PS4SDKIncludeDir)) {
5059 getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
5060 << "PS4 system headers" << PS4SDKIncludeDir;
5063 SmallString<512> PS4SDKLibDir(PS4SDKDir);
5064 llvm::sys::path::append(PS4SDKLibDir, "target/lib");
5065 if (!Args.hasArg(options::OPT_nostdlib) &&
5066 !Args.hasArg(options::OPT_nodefaultlibs) &&
5067 !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
5068 !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
5069 !Args.hasArg(options::OPT_emit_ast) &&
5070 !llvm::sys::fs::exists(PS4SDKLibDir)) {
5071 getDriver().Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
5072 << "PS4 system libraries" << PS4SDKLibDir;
5075 getFilePaths().push_back(PS4SDKLibDir.str());
5078 Tool *PS4CPU::buildAssembler() const {
5079 return new tools::PS4cpu::Assemble(*this);
5082 Tool *PS4CPU::buildLinker() const { return new tools::PS4cpu::Link(*this); }
5084 bool PS4CPU::isPICDefault() const { return true; }
5086 bool PS4CPU::HasNativeLLVMSupport() const { return true; }
5088 SanitizerMask PS4CPU::getSupportedSanitizers() const {
5089 SanitizerMask Res = ToolChain::getSupportedSanitizers();
5090 Res |= SanitizerKind::Address;
5091 Res |= SanitizerKind::Vptr;