15 #include "clang/Config/config.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"
38 #include <system_error>
40 using namespace clang::driver;
41 using namespace clang::driver::toolchains;
42 using namespace clang;
43 using namespace llvm::opt;
55 :
MachO(D, Triple, Args), TargetInitialized(
false) {}
61 if (Ty == types::TY_PP_Asm)
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")
124 unsigned ArchKind = llvm::ARM::parseCPUArch(CPU);
125 if (ArchKind == llvm::ARM::AK_INVALID)
127 StringRef Arch = llvm::ARM::getArchName(ArchKind);
131 if (Arch.startswith(
"armv5"))
132 Arch = Arch.substr(0, 5);
134 else if (Arch.startswith(
"armv6") && !Arch.endswith(
"6m"))
135 Arch = Arch.substr(0, 5);
137 else if (Arch.endswith(
"v7a"))
138 Arch = Arch.substr(0, 5);
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"));
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))
167 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
183 return Triple.getTriple();
193 return Triple.getTriple();
205 Triple.setOSName(Str);
207 return Triple.getTriple();
210 void Generic_ELF::anchor() {}
221 return Dsymutil.get();
225 return VerifyDebug.get();
239 :
Darwin(D, Triple, Args) {}
246 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
247 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
252 CC1Args.push_back(
"-Werror=implicit-function-declaration");
259 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc,
false);
263 ArgStringList &CmdArgs)
const {
274 CmdArgs.push_back(
"-force_load");
276 llvm::sys::path::remove_filename(P);
277 llvm::sys::path::remove_filename(P);
278 llvm::sys::path::append(P,
"lib",
"arc",
"libarclite_");
281 P +=
"watchsimulator";
285 P +=
"appletvsimulator";
289 P +=
"iphonesimulator";
296 CmdArgs.push_back(Args.MakeArgString(P));
300 StringRef DarwinLibName,
bool AlwaysLink,
301 bool IsEmbedded,
bool AddRPath)
const {
303 llvm::sys::path::append(Dir,
"lib", IsEmbedded ?
"macho_embedded" :
"darwin");
306 llvm::sys::path::append(P, DarwinLibName);
311 if (AlwaysLink ||
getVFS().exists(P))
312 CmdArgs.push_back(Args.MakeArgString(P));
319 assert(DarwinLibName.endswith(
".dylib") &&
"must be a dynamic library");
323 CmdArgs.push_back(
"-rpath");
324 CmdArgs.push_back(
"@executable_path");
328 CmdArgs.push_back(
"-rpath");
329 CmdArgs.push_back(Args.MakeArgString(Dir));
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");
352 llvm::sys::path::const_iterator SDKDir;
355 for (
auto IT = BeginSDK; IT != EndSDK; ++IT) {
357 if (SDK.endswith(
".sdk"))
358 return SDK.slice(0, SDK.size() - 4);
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");
384 ArgStringList &CmdArgs)
const {
392 void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
393 ArgStringList &CmdArgs,
394 StringRef Sanitizer)
const {
397 (Twine(
"libclang_rt.") + Sanitizer +
"_" +
404 ArgStringList &CmdArgs)
const {
410 getDriver().
Diag(diag::err_drv_unsupported_rtlib_for_platform)
411 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() <<
"darwin";
417 if (Args.hasArg(options::OPT_static) ||
418 Args.hasArg(options::OPT_fapple_kext) ||
419 Args.hasArg(options::OPT_mkernel))
425 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
426 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
432 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
434 AddLinkSanitizerLibArgs(Args, CmdArgs,
"ubsan");
436 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tsan");
440 (Twine(
"libclang_rt.stats_client_") + OS +
".a").str(),
442 AddLinkSanitizerLibArgs(Args, CmdArgs,
"stats");
445 AddLinkSanitizerLibArgs(Args, CmdArgs,
"esan");
449 CmdArgs.push_back(
"-lSystem");
464 CmdArgs.push_back(
"-lgcc_s.1");
473 CmdArgs.push_back(
"-lgcc_s.10.4");
475 CmdArgs.push_back(
"-lgcc_s.10.5");
500 void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
506 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
509 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
511 if (
char *env = ::getenv(
"SDKROOT")) {
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)) {
529 << OSXVersion->getAsString(Args)
530 << (iOSVersion ? iOSVersion :
531 TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
532 iOSVersion = TvOSVersion = WatchOSVersion =
nullptr;
533 }
else if (iOSVersion && (TvOSVersion || WatchOSVersion)) {
535 << iOSVersion->getAsString(Args)
536 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
537 TvOSVersion = WatchOSVersion =
nullptr;
538 }
else if (TvOSVersion && WatchOSVersion) {
540 << TvOSVersion->getAsString(Args)
541 << WatchOSVersion->getAsString(Args);
542 WatchOSVersion =
nullptr;
543 }
else if (!OSXVersion && !iOSVersion && !TvOSVersion && !WatchOSVersion) {
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"))
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();
568 if (SDK.size() > 0) {
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;
593 if (OSXTarget.empty() && iOSTarget.empty() && TvOSTarget.empty() &&
594 WatchOSTarget.empty()) {
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)) {
612 llvm::raw_string_ostream(OSXTarget) << Major <<
'.' << Minor <<
'.'
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");
626 if (!TvOSTarget.empty() && !iOSTarget.empty()) {
627 getDriver().
Diag(diag::err_drv_conflicting_deployment_targets)
628 <<
"TVOS_DEPLOYMENT_TARGET"
629 <<
"IPHONEOS_DEPLOYMENT_TARGET";
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);
669 else if (TvOSVersion)
671 else if (WatchOSVersion)
674 llvm_unreachable(
"Unable to infer Darwin variant");
677 unsigned Major, Minor, Micro;
679 if (Platform ==
MacOS) {
680 assert((!iOSVersion && !TvOSVersion && !WatchOSVersion) &&
681 "Unknown target platform!");
684 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
686 << OSXVersion->getAsString(Args);
688 assert(iOSVersion &&
"Unknown target platform!");
691 HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
693 << iOSVersion->getAsString(Args);
694 }
else if (Platform ==
TvOS) {
696 Micro, HadExtra) || HadExtra ||
697 Major >= 10 || Minor >= 100 || Micro >= 100)
699 << TvOSVersion->getAsString(Args);
700 }
else if (Platform ==
WatchOS) {
702 Micro, HadExtra) || HadExtra ||
703 Major >= 10 || Minor >= 100 || Micro >= 100)
705 << WatchOSVersion->getAsString(Args);
707 llvm_unreachable(
"unknown kind of Darwin platform");
720 setTarget(Platform, Major, Minor, Micro);
722 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
724 if (SDK.size() > 0) {
725 size_t StartVer = SDK.find_first_of(
"0123456789");
726 StringRef SDKName = SDK.slice(0, StartVer);
735 ArgStringList &CmdArgs)
const {
740 CmdArgs.push_back(
"-lc++");
750 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
752 llvm::sys::path::append(
P,
"usr",
"lib",
"libstdc++.dylib");
755 llvm::sys::path::remove_filename(
P);
756 llvm::sys::path::append(
P,
"libstdc++.6.dylib");
758 CmdArgs.push_back(Args.MakeArgString(
P));
769 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
774 CmdArgs.push_back(
"-lstdc++");
780 ArgStringList &CmdArgs)
const {
786 llvm::sys::path::append(P,
"lib",
"darwin");
790 llvm::sys::path::append(P,
"libclang_rt.cc_kext_watchos.a");
792 llvm::sys::path::append(P,
"libclang_rt.cc_kext_tvos.a");
794 llvm::sys::path::append(P,
"libclang_rt.cc_kext_ios.a");
796 llvm::sys::path::append(P,
"libclang_rt.cc_kext.a");
802 CmdArgs.push_back(Args.MakeArgString(P));
806 const char *BoundArch)
const {
807 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
817 for (Arg *A : Args) {
818 if (A->getOption().matches(options::OPT_Xarch__)) {
821 llvm::Triple::ArchType XarchArch =
823 if (!(XarchArch ==
getArch() ||
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));
842 if (!XarchArg || Index > Prev + 1) {
843 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
844 << A->getAsString(Args);
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);
862 for (
const char *
Value : A->getValues()) {
864 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
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),
941 StringRef
Name = BoundArch;
942 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
943 const Option MArch = Opts.getOption(options::OPT_march_EQ);
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");
1021 ArgStringList &CmdArgs)
const {
1030 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic.a" :
"_static.a";
1036 const char *BoundArch)
const {
1048 AddDeploymentTarget(*DAL);
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) &&
1072 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_stdlib_EQ),
1085 if (where != StringRef()) {
1086 getDriver().
Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
1094 return getArch() == llvm::Triple::x86_64;
1098 if (
const char *
S = ::getenv(
"RC_DEBUG_OPTIONS"))
1099 return S[0] !=
'\0';
1111 return !Triple.isWatchABI();
1126 return (
getArch() == llvm::Triple::x86_64 ||
1127 getArch() == llvm::Triple::aarch64);
1132 return getArch() == llvm::Triple::x86 ||
getArch() == llvm::Triple::x86_64;
1136 ArgStringList &CmdArgs)
const {
1140 CmdArgs.push_back(
"-watchos_version_min");
1142 CmdArgs.push_back(
"-watchos_simulator_version_min");
1144 CmdArgs.push_back(
"-tvos_version_min");
1146 CmdArgs.push_back(
"-tvos_simulator_version_min");
1148 CmdArgs.push_back(
"-ios_simulator_version_min");
1150 CmdArgs.push_back(
"-iphoneos_version_min");
1153 CmdArgs.push_back(
"-macosx_version_min");
1156 CmdArgs.push_back(Args.MakeArgString(TargetVersion.
getAsString()));
1160 ArgStringList &CmdArgs)
const {
1162 if (Args.hasArg(options::OPT_dynamiclib)) {
1170 CmdArgs.push_back(
"-ldylib1.o");
1173 CmdArgs.push_back(
"-ldylib1.o");
1175 CmdArgs.push_back(
"-ldylib1.10.5.o");
1178 if (Args.hasArg(options::OPT_bundle)) {
1179 if (!Args.hasArg(options::OPT_static)) {
1187 CmdArgs.push_back(
"-lbundle1.o");
1190 CmdArgs.push_back(
"-lbundle1.o");
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");
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");
1223 if (
getArch() == llvm::Triple::aarch64)
1226 CmdArgs.push_back(
"-lcrt1.o");
1228 CmdArgs.push_back(
"-lcrt1.3.1.o");
1231 CmdArgs.push_back(
"-lcrt1.o");
1233 CmdArgs.push_back(
"-lcrt1.10.5.o");
1235 CmdArgs.push_back(
"-lcrt1.10.6.o");
1247 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
1248 CmdArgs.push_back(Str);
1262 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
1264 Res |= SanitizerKind::Address;
1267 Res |= SanitizerKind::Vptr;
1268 Res |= SanitizerKind::SafeStack;
1270 Res |= SanitizerKind::Thread;
1273 Res |= SanitizerKind::Thread;
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();
1311 StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
1312 if (!PatchText.empty()) {
1313 if (
size_t EndNumber = PatchText.find_first_not_of(
"0123456789")) {
1315 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1316 GoodVersion.Patch < 0)
1318 GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
1328 StringRef RHSPatchSuffix)
const {
1329 if (Major != RHSMajor)
1330 return Major < RHSMajor;
1331 if (Minor != RHSMinor)
1332 return Minor < RHSMinor;
1333 if (Patch != RHSPatch) {
1342 return Patch < RHSPatch;
1344 if (PatchSuffix != RHSPatchSuffix) {
1346 if (RHSPatchSuffix.empty())
1348 if (PatchSuffix.empty())
1352 return PatchSuffix < RHSPatchSuffix;
1360 const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
1362 return A->getValue();
1363 return GCC_INSTALL_PREFIX;
1376 const llvm::Triple &TargetTriple,
const ArgList &Args,
1378 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1379 ? TargetTriple.get64BitArchVariant()
1380 : TargetTriple.get32BitArchVariant();
1386 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1387 CandidateTripleAliases, CandidateBiarchLibDirs,
1388 CandidateBiarchTripleAliases);
1392 D.PrefixDirs.end());
1395 if (GCCToolchainDir !=
"") {
1396 if (GCCToolchainDir.back() ==
'/')
1397 GCCToolchainDir = GCCToolchainDir.drop_back();
1399 Prefixes.push_back(GCCToolchainDir);
1402 if (!D.SysRoot.empty()) {
1403 Prefixes.push_back(D.SysRoot);
1404 Prefixes.push_back(D.SysRoot +
"/usr");
1408 Prefixes.push_back(D.InstalledDir +
"/..");
1411 if (D.SysRoot.empty()) {
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");
1419 Prefixes.push_back(
"/usr");
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)
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,
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";
1457 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
1459 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
1460 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
1464 if (BiarchSibling.hasValue()) {
1465 M = BiarchSibling.getValue();
1471 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1472 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
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));
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));
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));
1693 TripleAliases.push_back(TargetTriple.str());
1696 if (TargetTriple.str() != BiarchTriple.str())
1697 BiarchTripleAliases.push_back(BiarchTriple.str());
1703 if (!V.startswith(
"CUDA Version "))
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))
1713 if (Major == 7 && Minor == 0) {
1718 if (Major == 7 && Minor == 5)
1720 if (Major == 8 && Minor == 0)
1728 const llvm::Triple &TargetTriple,
const llvm::opt::ArgList &Args) {
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");
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)) {
1761 StringRef
FileName = llvm::sys::path::filename(FilePath);
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();
1770 if (GpuArch ==
"compute_20") {
1773 }
else if (GpuArch ==
"compute_30") {
1776 }
else if (GpuArch ==
"compute_35") {
1779 }
else if (GpuArch ==
"compute_50") {
1789 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> VersionFile =
1790 FS.getBufferForFile(InstallPath +
"/version.txt");
1807 ArchsWithVersionTooLowErrors.count(Arch) > 0)
1811 if (Version < RequiredVersion) {
1812 ArchsWithVersionTooLowErrors.insert(Arch);
1813 D.Diag(diag::err_drv_cuda_version_too_low)
1821 OS <<
"Found CUDA installation: " << InstallPath <<
", version "
1827 class FilterNonExistent {
1828 StringRef
Base, File;
1833 : Base(Base), File(File), VFS(VFS) {}
1834 bool operator()(
const Multilib &M) {
1841 std::vector<std::string> &Flags) {
1843 Flags.push_back(std::string(
"+") + Flag);
1845 Flags.push_back(std::string(
"-") + Flag);
1849 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
1853 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
1854 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1858 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel;
1862 return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1866 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1870 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
1871 return A && A->getOption().matches(options::OPT_mips16);
1875 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
1876 return A && A->getOption().matches(options::OPT_mmicromips);
1880 struct DetectedMultilibs {
1894 return Multilib(commonSuffix, commonSuffix, commonSuffix);
1898 FilterNonExistent &NonExistent,
1899 DetectedMultilibs &Result) {
1905 auto MArchMicroMips =
1926 .includeSuffix(
"/64")
1933 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
1938 .
Either(BigEndian, LittleEndian)
1944 std::vector<std::string> Dirs({
"/include"});
1947 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1949 Dirs.push_back(
"/../../../../mips-linux-gnu/libc/usr/include");
1961 .includeSuffix(
"/64")
1968 DebianMipsMultilibs =
1974 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1975 if (CSMipsMultilibs.
size() < DebianMipsMultilibs.
size())
1976 std::iter_swap(Candidates, Candidates + 1);
1978 if (Candidate->select(Flags, Result.SelectedMultilib)) {
1979 if (Candidate == &DebianMipsMultilibs)
1981 Result.Multilibs = *Candidate;
1989 FilterNonExistent &NonExistent,
1990 DetectedMultilibs &Result) {
1998 if (AndroidMipsMultilibs.
select(Flags, Result.SelectedMultilib)) {
1999 Result.Multilibs = AndroidMipsMultilibs;
2006 FilterNonExistent &NonExistent,
2007 DetectedMultilibs &Result) {
2015 .flag(
"+march=mips32r2");
2017 auto MArchMipselR2 =
makeMultilib(
"/mipsel-r2-hard-musl")
2020 .
flag(
"+march=mips32r2");
2026 return std::vector<std::string>(
2027 {
"/../sysroot" + M.
osSuffix() +
"/usr/include"});
2030 if (MuslMipsMultilibs.
select(Flags, Result.SelectedMultilib)) {
2031 Result.Multilibs = MuslMipsMultilibs;
2038 FilterNonExistent &NonExistent,
2039 DetectedMultilibs &Result) {
2046 .
flag(
"-mmicromips")
2047 .
flag(
"+march=mips32");
2052 .
flag(
"+mmicromips");
2057 .
flag(
"+march=mips64r2");
2065 .
flag(
"-mmicromips")
2066 .
flag(
"+march=mips32r2");
2083 MtiMipsMultilibsV1 =
2085 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
2097 .
Either(BigEndian, LittleEndian)
2103 std::vector<std::string> Dirs({
"/include"});
2105 Dirs.push_back(
"/../../../../sysroot/uclibc/usr/include");
2107 Dirs.push_back(
"/../../../../sysroot/usr/include");
2117 .
flag(
"-msoft-float")
2122 .
flag(
"+msoft-float")
2123 .
flag(
"-mnan=2008");
2126 .
flag(
"-msoft-float")
2131 .
flag(
"+msoft-float")
2133 .
flag(
"-mmicromips");
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");
2183 MtiMipsMultilibsV2 =
2185 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
2186 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
2187 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
2188 .Either(O32, N32, N64)
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;
2210 FilterNonExistent &NonExistent,
2211 DetectedMultilibs &Result) {
2226 .
Maybe(LittleEndian)
2229 return std::vector<std::string>(
2230 {
"/include",
"/../../../../sysroot/usr/include"});
2239 .
flag(
"-msoft-float")
2240 .
flag(
"-mmicromips");
2243 .
flag(
"+msoft-float")
2244 .
flag(
"-mmicromips");
2247 .
flag(
"-msoft-float")
2248 .
flag(
"-mmicromips");
2251 .
flag(
"+msoft-float")
2252 .
flag(
"-mmicromips");
2255 .
flag(
"-msoft-float")
2256 .
flag(
"+mmicromips");
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");
2279 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
2280 ElMicroHard, ElMicroSoft})
2281 .Either(O32, N32, N64)
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;
2303 StringRef Path,
const ArgList &Args,
2304 DetectedMultilibs &Result) {
2305 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
2311 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2319 CPUName ==
"mips32r5" || CPUName ==
"p5600",
2320 "march=mips32r2", Flags);
2324 CPUName ==
"mips64r5" || CPUName ==
"octeon",
2325 "march=mips64r2", Flags);
2337 if (TargetTriple.isAndroid())
2340 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
2341 TargetTriple.getOS() == llvm::Triple::Linux &&
2342 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
2345 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
2346 TargetTriple.getOS() == llvm::Triple::Linux &&
2347 TargetTriple.getEnvironment() == llvm::Triple::GNU)
2350 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
2351 TargetTriple.getOS() == llvm::Triple::Linux &&
2352 TargetTriple.getEnvironment() == llvm::Triple::GNU)
2360 Result.Multilibs.push_back(Default);
2361 Result.Multilibs.FilterOut(NonExistent);
2363 if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
2372 const llvm::Triple &TargetTriple,
2373 StringRef Path,
const ArgList &Args,
2374 DetectedMultilibs &Result) {
2376 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
2391 .
Either(ThumbMultilib, ArmV7Multilib,
2392 ArmV7ThumbMultilib, DefaultMultilib)
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));
2409 if (AndroidArmMultilibs.
select(Flags, Result.SelectedMultilib))
2410 Result.Multilibs = AndroidArmMultilibs;
2414 const llvm::Triple &TargetTriple,
2415 StringRef Path,
const ArgList &Args,
2416 bool NeedsBiarchSuffix,
2417 DetectedMultilibs &Result) {
2428 .includeSuffix(
"/64")
2434 .includeSuffix(
"/32")
2440 .includeSuffix(
"/x32")
2446 FilterNonExistent NonExistent(
2447 Path, TargetTriple.isOSIAMCU() ?
"/libgcc.a" :
"/crtbegin.o", D.
getVFS());
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;
2470 else if (Want == WANT64)
2472 else if (Want == WANTX32)
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);
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) {
2508 !EC && LI != LE; LI = LI.
increment(EC)) {
2509 StringRef VersionText = llvm::sys::path::filename(LI->getName());
2512 if (CandidateVersion.Major != -1)
2513 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
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))
2527 std::error_code EEC;
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());
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();
2559 const std::string LibAndInstallSuffixes[][2] = {
2560 {
"/gcc/" + CandidateTriple.str(),
"/../../.."},
2563 {
"/gcc-cross/" + CandidateTriple.str(),
"/../../.."},
2565 {
"/" + CandidateTriple.str() +
"/gcc/" + CandidateTriple.str(),
2570 {
"/" + CandidateTriple.str(),
"/../.."},
2576 {
"/i386-linux-gnu/gcc/" + CandidateTriple.str(),
"/../../../.."}};
2578 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2579 scanLibDirForGCCTripleSolaris(TargetTriple, Args, LibDir, CandidateTriple,
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];
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());
2596 if (CandidateVersion.Major != -1)
2597 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2599 if (CandidateVersion.isOlderThan(4, 1, 1))
2601 if (CandidateVersion <= Version)
2604 DetectedMultilibs Detected;
2616 NeedsBiarchSuffix, Detected)) {
2621 SelectedMultilib = Detected.SelectedMultilib;
2622 BiarchSibling = Detected.BiarchSibling;
2623 Version = CandidateVersion;
2624 GCCTriple.setTriple(CandidateTriple);
2629 LibDir + LibAndInstallSuffixes[i][0] +
"/" + VersionText.str();
2630 GCCParentLibPath = GCCInstallPath + LibAndInstallSuffixes[i][1];
2637 const ArgList &Args)
2651 return Preprocess.get();
2655 return Compile.get();
2674 return getArch() == llvm::Triple::x86_64;
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:
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))
2724 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2725 getVFS().
exists(Base + Suffix +
"/" + GCCTriple + IncludeSuffix)) {
2727 Base + Suffix +
"/" + GCCTriple + IncludeSuffix);
2735 Base +
"/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2737 Base +
"/" + TargetMultiarchTriple + Suffix);
2745 ArgStringList &CC1Args)
const {
2747 bool UseInitArrayDefault =
2748 getTriple().getArch() == llvm::Triple::aarch64 ||
2749 getTriple().getArch() == llvm::Triple::aarch64_be ||
2750 (
getTriple().getOS() == llvm::Triple::Linux &&
2752 getTriple().getOS() == llvm::Triple::NaCl ||
2753 (
getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2756 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2757 options::OPT_fno_use_init_array, UseInitArrayDefault))
2758 CC1Args.push_back(
"-fuse-init-array");
2763 const llvm::Triple &Triple,
2764 const ArgList &Args)
2765 :
Linux(D, Triple, Args) {
2767 DetectedMultilibs
Result;
2770 SelectedMultilib = Result.SelectedMultilib;
2782 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2783 if (DriverArgs.hasArg(options::OPT_nostdinc))
2788 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2790 llvm::sys::path::append(P,
"include");
2794 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2799 for (
const auto &Path :
Callback(SelectedMultilib))
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();
2824 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
2826 StringRef
Value = A->getValue();
2827 if (Value !=
"libc++")
2829 << A->getAsString(Args);
2836 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2837 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2838 DriverArgs.hasArg(options::OPT_nostdincxx))
2842 "Only -lc++ (aka libcxx) is suported in this toolchain.");
2846 for (std::string Path :
Callback(SelectedMultilib)) {
2848 if (llvm::sys::fs::exists(Path)) {
2857 ArgStringList &CmdArgs)
const {
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");
2867 StringRef Component,
2868 bool Shared)
const {
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")));
2880 const std::string &InstalledDir,
2882 std::string InstallRelDir;
2886 for (
auto &
I : PrefixDirs)
2890 if (
getVFS().
exists(InstallRelDir = InstalledDir +
"/../target"))
2891 return InstallRelDir;
2893 return InstallRelDir;
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))
2921 for (Arg *A : Args.filtered(options::OPT_L))
2922 for (
const char *
Value : A->getValues())
2923 LibPaths.push_back(
Value);
2928 std::vector<std::string> RootDirs;
2930 std::back_inserter(RootDirs));
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);
2939 bool HasG0 = Args.hasArg(options::OPT_shared);
2941 HasG0 = G.getValue() == 0;
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);
2958 const llvm::opt::ArgList &Args)
2959 :
Linux(D, Triple, Args) {
2965 const std::string BinDir(TargetDir +
"/bin");
2989 ArgStringList &CC1Args)
const {
2990 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2991 DriverArgs.hasArg(options::OPT_nostdlibinc))
3001 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
3002 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3003 DriverArgs.hasArg(options::OPT_nostdincxx))
3013 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
3017 StringRef
Value = A->getValue();
3018 if (Value !=
"libstdc++")
3019 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3029 return "hexagonv60";
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);
3046 const ArgList &Args)
3056 const ArgList &Args)
3072 std::string ProgPath(
getDriver().Dir +
"/../");
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");
3110 ArgStringList &CC1Args)
const {
3112 if (DriverArgs.hasArg(options::OPT_nostdinc))
3115 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
3117 llvm::sys::path::append(P,
"include");
3121 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
3126 case llvm::Triple::x86:
3130 llvm::sys::path::append(P,
"i686-nacl/usr/include");
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");
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");
3152 llvm::sys::path::remove_filename(P);
3153 llvm::sys::path::remove_filename(P);
3154 llvm::sys::path::append(P,
"include");
3159 ArgStringList &CmdArgs)
const {
3163 CmdArgs.push_back(
"-lc++");
3167 ArgStringList &CC1Args)
const {
3169 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3170 DriverArgs.hasArg(options::OPT_nostdincxx))
3179 case llvm::Triple::arm:
3180 llvm::sys::path::append(P,
"arm-nacl/include/c++/v1");
3183 case llvm::Triple::x86:
3184 llvm::sys::path::append(P,
"x86_64-nacl/include/c++/v1");
3187 case llvm::Triple::x86_64:
3188 llvm::sys::path::append(P,
"x86_64-nacl/include/c++/v1");
3191 case llvm::Triple::mipsel:
3192 llvm::sys::path::append(P,
"mipsel-nacl/include/c++/v1");
3202 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
3203 StringRef
Value = A->getValue();
3204 if (Value ==
"libc++")
3206 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3216 if (TheTriple.getArch() == llvm::Triple::arm &&
3217 TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
3218 TheTriple.setEnvironment(llvm::Triple::GNUEABIHF);
3219 return TheTriple.getTriple();
3238 const ArgList &Args)
3243 Path +=
"/../libexec";
3260 const ArgList &Args)
3263 llvm::sys::path::append(P,
"..",
getTriple().str(),
"lib");
3268 ArgStringList &CC1Args)
const {
3269 if (DriverArgs.hasArg(options::OPT_nostdlibinc) &&
3270 DriverArgs.hasArg(options::OPT_nostdincxx))
3274 llvm::sys::path::append(P,
"..",
getTriple().str(),
"include/c++/v1");
3279 ArgStringList &CmdArgs)
const {
3280 CmdArgs.push_back(
"-lc++");
3281 CmdArgs.push_back(
"-lc++abi");
3282 CmdArgs.push_back(
"-lunwind");
3294 case llvm::Triple::aarch64:
3295 case llvm::Triple::x86_64:
3304 Res |= SanitizerKind::SafeStack;
3309 return SanitizerKind::SafeStack;
3320 ArgStringList &CC1Args)
const {
3321 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3322 DriverArgs.hasArg(options::OPT_nostdincxx))
3328 getDriver().SysRoot +
"/system/develop/headers/c++/v1");
3332 getDriver().SysRoot +
"/system/develop/headers/c++");
3334 getDriver().SysRoot +
"/system/develop/headers/c++/backward");
3338 getDriver().SysRoot +
"/system/develop/headers/c++/" +
3347 const ArgList &Args)
3378 ArgStringList &CC1Args)
const {
3379 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3380 DriverArgs.hasArg(options::OPT_nostdincxx))
3386 getDriver().SysRoot +
"/usr/include/c++/v1");
3390 getDriver().SysRoot +
"/usr/include/c++/stdc++");
3392 getDriver().SysRoot +
"/usr/include/c++/stdc++/backward");
3395 if (Triple.startswith(
"amd64"))
3401 "/usr/include/c++/stdc++/" +
3408 ArgStringList &CmdArgs)
const {
3411 CmdArgs.push_back(
"-lc++");
3412 CmdArgs.push_back(
"-lc++abi");
3413 CmdArgs.push_back(
"-lpthread");
3416 CmdArgs.push_back(
"-lstdc++");
3424 const ArgList &Args)
3429 if ((Triple.getArch() == llvm::Triple::x86 ||
3430 Triple.getArch() == llvm::Triple::ppc) &&
3438 if (
getTriple().getOSMajorVersion() >= 10)
3444 ArgStringList &CC1Args)
const {
3445 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3446 DriverArgs.hasArg(options::OPT_nostdincxx))
3452 getDriver().SysRoot +
"/usr/include/c++/v1");
3456 getDriver().SysRoot +
"/usr/include/c++/4.2");
3458 getDriver().SysRoot +
"/usr/include/c++/4.2/backward");
3464 ArgStringList &CmdArgs)
const {
3466 bool Profiling = Args.hasArg(options::OPT_pg);
3470 CmdArgs.push_back(Profiling ?
"-lc++_p" :
"-lc++");
3474 CmdArgs.push_back(Profiling ?
"-lstdc++_p" :
"-lstdc++");
3488 case llvm::Triple::GNUEABIHF:
3489 case llvm::Triple::GNUEABI:
3490 case llvm::Triple::EABI:
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;
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;
3531 switch (Triple.getArch()) {
3532 case llvm::Triple::x86:
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:
3544 case llvm::Triple::EABIHF:
3545 case llvm::Triple::GNUEABIHF:
3553 case llvm::Triple::mips64:
3554 case llvm::Triple::mips64el:
3560 case llvm::Triple::ppc:
3563 case llvm::Triple::sparc:
3581 unsigned Major, Minor, Micro;
3582 getTriple().getOSVersion(Major, Minor, Micro);
3583 if (Major >= 7 || Major == 0) {
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:
3606 ArgStringList &CC1Args)
const {
3607 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3608 DriverArgs.hasArg(options::OPT_nostdincxx))
3614 getDriver().SysRoot +
"/usr/include/c++/");
3618 getDriver().SysRoot +
"/usr/include/g++");
3620 getDriver().SysRoot +
"/usr/include/g++/backward");
3642 Paths.push_back(Path.str());
3648 const ArgList &Args)
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");
3688 ArgStringList &CC1Args)
const {
3689 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3690 DriverArgs.hasArg(options::OPT_nostdincxx))
3695 addSystemInclude(DriverArgs, CC1Args,
"/usr/include/c++/v1/support/solaris");
3703 "/include/c++/" + Version.
Text);
3706 "." + Version.
MinorStr +
"/include/c++/" +
3707 Version.
Text +
"/" +
3765 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
3766 llvm::MemoryBuffer::getFile(
"/etc/lsb-release");
3768 StringRef Data = File.get()->getBuffer();
3770 Data.split(Lines,
"\n");
3772 for (StringRef
Line : Lines)
3774 Version = llvm::StringSwitch<Distro>(
Line.substr(17))
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)
3815 File = llvm::MemoryBuffer::getFile(
"/etc/debian_version");
3817 StringRef Data = File.get()->getBuffer();
3820 else if (Data.startswith(
"squeeze/sid") || Data[0] ==
'6')
3822 else if (Data.startswith(
"wheezy/sid") || Data[0] ==
'7')
3824 else if (Data.startswith(
"jessie/sid") || Data[0] ==
'8')
3826 else if (Data.startswith(
"stretch/sid") || Data[0] ==
'9')
3850 const llvm::Triple &TargetTriple,
3851 StringRef SysRoot) {
3852 llvm::Triple::EnvironmentType TargetEnvironment =
3853 TargetTriple.getEnvironment();
3857 switch (TargetTriple.getArch()) {
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:
3891 if (TargetEnvironment != llvm::Triple::GNUX32 &&
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) {
3960 return Triple.isArch32Bit() ?
"lib" :
"lib64";
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";
3985 StringRef InstallPath,
3988 for (
const auto &Path : PathsCallback(Multilib))
3997 llvm::Triple::ArchType Arch = Triple.getArch();
4020 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
4023 const bool IsAndroid = Triple.isAndroid();
4026 if (IsMips && !SysRoot.empty())
4027 ExtraOpts.push_back(
"--sysroot=" + SysRoot);
4034 if (!IsMips && !IsAndroid) {
4037 ExtraOpts.push_back(
"--hash-style=gnu");
4041 ExtraOpts.push_back(
"--hash-style=both");
4047 #ifdef ENABLE_LINKER_BUILD_ID
4052 ExtraOpts.push_back(
"--enable-new-dtags");
4061 const std::string OSLibDir =
getOSLibDir(Triple, Args);
4111 if (StringRef(LibPath).startswith(SysRoot)) {
4122 if (StringRef(D.
Dir).startswith(SysRoot)) {
4137 "/../../" + OSLibDir,
4144 BiarchSibling.gccSuffix(),
4159 if (StringRef(LibPath).startswith(SysRoot))
4168 if (StringRef(D.
Dir).startswith(SysRoot))
4188 return std::string();
4199 (InstallDir +
"/../../../../" + TripleStr +
"/libc" + Multilib.
osSuffix())
4205 Path = (InstallDir +
"/../../../../sysroot" + Multilib.
osSuffix()).str();
4210 return std::string();
4214 const llvm::Triple::ArchType Arch =
getArch();
4215 const llvm::Triple &Triple =
getTriple();
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 ||
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);
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:
4295 case llvm::Triple::ppc64le:
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;
4333 ArgStringList &CC1Args)
const {
4337 if (DriverArgs.hasArg(options::OPT_nostdinc))
4340 if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
4343 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
4345 llvm::sys::path::append(P,
"include");
4349 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
4353 StringRef CIncludeDirs(C_INCLUDE_DIRS);
4354 if (CIncludeDirs !=
"") {
4356 CIncludeDirs.split(dirs,
":");
4357 for (StringRef dir : dirs) {
4359 llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) :
"";
4379 const StringRef X86_64MultiarchIncludeDirs[] = {
4380 "/usr/include/x86_64-linux-gnu",
4385 "/usr/include/i686-linux-gnu/64",
"/usr/include/i486-linux-gnu/64"};
4386 const StringRef X86MultiarchIncludeDirs[] = {
4387 "/usr/include/i386-linux-gnu",
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"};
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) {
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() :
"";
4521 ArgStringList &CC1Args)
const {
4522 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4523 DriverArgs.hasArg(options::OPT_nostdincxx))
4528 const std::string LibCXXIncludePathCandidates[] = {
4535 for (
const auto &IncludePath : LibCXXIncludePathCandidates) {
4536 if (IncludePath.empty() || !
getVFS().
exists(IncludePath))
4559 const std::string TargetMultiarchTriple =
4565 "/c++/" + Version.
Text, TripleStr,
4566 GCCMultiarchTriple, TargetMultiarchTriple,
4572 const std::string LibStdCXXIncludePathCandidates[] = {
4575 InstallDir.str() +
"/include/g++-v" + Version.
Text,
4576 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr +
"." +
4578 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr,
4580 LibDir.str() +
"/../" + TripleStr.str() +
"/include/c++/" + Version.
Text,
4583 LibDir.str() +
"/../include/c++",
4586 for (
const auto &IncludePath : LibStdCXXIncludePathCandidates) {
4596 ArgStringList &CC1Args)
const {
4597 if (DriverArgs.hasArg(options::OPT_nocudainc))
4606 CC1Args.push_back(
"-include");
4607 CC1Args.push_back(
"__clang_cuda_runtime_wrapper.h");
4611 ArgStringList &CC1Args)
const {
4613 CC1Args.push_back(
"-isystem");
4614 CC1Args.push_back(DriverArgs.MakeArgString(
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;
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;
4653 llvm::opt::ArgStringList &CmdArgs)
const {
4658 if (!Args.hasArg(options::OPT_coverage))
4659 CmdArgs.push_back(Args.MakeArgString(
4660 Twine(
"-u", llvm::getInstrProfRuntimeHookVarName())));
4667 const ArgList &Args)
4693 const ArgList &Args)
4694 :
Linux(D, Triple, Args) {
4701 llvm::opt::ArgStringList &CC1Args)
const {
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))
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));
4725 CC1Args.push_back(
"-target-feature");
4726 CC1Args.push_back(
"+ptx42");
4731 ArgStringList &CC1Args)
const {
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.");
4742 llvm::opt::DerivedArgList *
4744 const char *BoundArch)
const {
4745 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
4748 for (Arg *A : Args) {
4749 if (A->getOption().matches(options::OPT_Xarch__)) {
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));
4766 if (!XarchArg || Index > Prev + 1) {
4767 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
4768 << A->getAsString(Args);
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);
4799 const ArgList &Args)
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")) {
4829 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,
'\0'};
4830 StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
4837 ArgStringList &CC1Args)
const {
4838 CC1Args.push_back(
"-nostdsysteminc");
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")) {
4849 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,
'\0'};
4850 StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
4857 ArgStringList &CmdArgs)
const {
4862 const ArgList &Args)
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:
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");
4895 if (Triple.getArch() == llvm::Triple::sparcel)
4896 llvm::sys::path::append(CompilerSupportDir,
"le");
4904 ArgStringList &CC1Args)
const {
4905 if (!DriverArgs.hasArg(options::OPT_nostdinc))
4910 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
4911 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4912 DriverArgs.hasArg(options::OPT_nostdincxx))
4922 LibDir.str() +
"/../" + TripleStr.str() +
"/include/c++/" + Version.
Text,
4923 "", TripleStr,
"",
"", Multilib.
includeSuffix(), DriverArgs, CC1Args);
4937 return Compiler.get();
4941 return Assembler.get();
4952 const llvm::opt::ArgList &Args)
4955 assert(Triple.isArch32Bit() != Triple.isArch64Bit());
4957 getDriver().SysRoot +
"/lib" + (Triple.isArch32Bit() ?
"32" :
"64"));
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; }
4978 bool WebAssembly::SupportsObjCGC()
const {
return false; }
4980 bool WebAssembly::hasBlocksRuntime()
const {
return false; }
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");
5002 void WebAssembly::AddClangSystemIncludeArgs(
const ArgList &DriverArgs,
5003 ArgStringList &CC1Args)
const {
5004 if (!DriverArgs.hasArg(options::OPT_nostdinc))
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))
5017 Tool *WebAssembly::buildLinker()
const {
5023 if (Args.hasArg(options::OPT_static))
5024 D.
Diag(diag::err_drv_unsupported_opt_for_target) <<
"-static" <<
"PS4";
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;
5037 llvm::sys::path::append(PS4SDKDir,
"/../../");
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();
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;
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;
5090 Res |= SanitizerKind::Address;
5091 Res |= SanitizerKind::Vptr;
MultilibSet & Either(const Multilib &M1, const Multilib &M2)
Add a set of mutually incompatible Multilib segments.
MultilibSet & Maybe(const Multilib &M)
Add an optional Multilib segment.
const std::string & includeSuffix() const
Get the include directory suffix.
ID lookupTypeForExtension(const char *Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
Represents a version number in the form major[.minor[.subminor[.build]]].
const char * CudaArchToString(CudaArch A)
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
Defines types useful for describing an Objective-C runtime.
The base class of the type hierarchy.
const llvm::opt::OptTable & getOpts() const
DiagnosticBuilder Diag(unsigned DiagID) const
CudaArch StringToCudaArch(llvm::StringRef S)
static bool GetReleaseVersion(const char *Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
GetReleaseVersion - Parse (([0-9]+)(.
The virtual file system interface.
Multilib & flag(StringRef F)
Add a flag to the flags list.
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
std::string Dir
The path the driver executable was in, as invoked from the command line.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
ActionClass getKind() const
directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
std::string getAsString() const
Retrieve a string representation of the version number.
const char * getInstalledDir() const
Get the path to where the clang executable was installed.
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
MultilibSet & setIncludeDirsCallback(IncludeDirsFunc F)
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
detail::InMemoryDirectory::const_iterator I
'watchos' is a variant of iOS for Apple's watchOS.
const char * CudaVersionToString(CudaVersion V)
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
MatchFinder::MatchCallback * Callback
Defines version macros and version-related utility functions for Clang.
bool needsUbsanRt() const
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag...
vfs::FileSystem & getVFS() const
The result type of a method or function.
const TemplateArgument * iterator
std::string InstalledDir
The path to the installed clang directory, if any.
bool hasSubscripting() const
Does this runtime directly support the subscripting methods?
CudaVersion MinVersionForCudaArch(CudaArch A)
Get the earliest CudaVersion that supports the given CudaArch.
The basic abstraction for the target Objective-C runtime.
std::string SysRoot
sysroot, if present
Defines the virtual file system interface vfs::FileSystem.
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
bool exists(const Twine &Path)
Check whether a file exists. Provided for convenience.
bool isDefault() const
Check whether the default is selected.
bool needsStatsRt() const
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
MultilibSet & FilterOut(FilterCallback F)
Filter out some subset of the Multilibs using a user defined callback.
std::vector< std::string > flags_list
bool select(const Multilib::flags_list &Flags, Multilib &M) const
Pick the best multilib in the set,.
const IncludeDirsFunc & filePathsCallback() const
const IncludeDirsFunc & includeDirsCallback() const
std::string ResourceDir
The path to the compiler resource directory.