14 #include "clang/Config/config.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/StringSwitch.h"
24 #include "llvm/Option/Arg.h"
25 #include "llvm/Option/ArgList.h"
26 #include "llvm/Option/OptTable.h"
27 #include "llvm/Option/Option.h"
28 #include "llvm/ProfileData/InstrProf.h"
29 #include "llvm/Support/ErrorHandling.h"
30 #include "llvm/Support/FileSystem.h"
31 #include "llvm/Support/MemoryBuffer.h"
32 #include "llvm/Support/Path.h"
33 #include "llvm/Support/Program.h"
34 #include "llvm/Support/TargetParser.h"
35 #include "llvm/Support/raw_ostream.h"
37 #include <system_error>
39 using namespace clang::driver;
40 using namespace clang::driver::toolchains;
41 using namespace clang;
42 using namespace llvm::opt;
54 :
MachO(D, Triple, Args), TargetInitialized(
false) {}
60 if (Ty == types::TY_PP_Asm)
96 return llvm::StringSwitch<const char *>(Arch)
97 .Case(
"armv6k",
"armv6")
98 .Case(
"armv6m",
"armv6m")
99 .Case(
"armv5tej",
"armv5")
100 .Case(
"xscale",
"xscale")
101 .Case(
"armv4t",
"armv4t")
102 .Case(
"armv7",
"armv7")
103 .Cases(
"armv7a",
"armv7-a",
"armv7")
104 .Cases(
"armv7r",
"armv7-r",
"armv7")
105 .Cases(
"armv7em",
"armv7e-m",
"armv7em")
106 .Cases(
"armv7k",
"armv7-k",
"armv7k")
107 .Cases(
"armv7m",
"armv7-m",
"armv7m")
108 .Cases(
"armv7s",
"armv7-s",
"armv7s")
113 unsigned ArchKind = llvm::ARM::parseCPUArch(CPU);
114 if (ArchKind == llvm::ARM::AK_INVALID)
116 StringRef Arch = llvm::ARM::getArchName(ArchKind);
120 if (Arch.startswith(
"armv5"))
121 Arch = Arch.substr(0, 5);
123 else if (Arch.startswith(
"armv6") && !Arch.endswith(
"6m"))
124 Arch = Arch.substr(0, 5);
126 else if (Arch.endswith(
"v7a"))
127 Arch = Arch.substr(0, 5);
132 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
133 options::OPT_mfloat_abi_EQ);
137 return A->getOption().matches(options::OPT_msoft_float) ||
138 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
139 A->getValue() == StringRef(
"soft"));
147 case llvm::Triple::aarch64:
150 case llvm::Triple::thumb:
151 case llvm::Triple::arm:
152 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
156 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
172 return Triple.getTriple();
182 return Triple.getTriple();
194 Triple.setOSName(Str);
196 return Triple.getTriple();
199 void Generic_ELF::anchor() {}
210 return Dsymutil.get();
214 return VerifyDebug.get();
228 :
Darwin(D, Triple, Args) {}
235 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
236 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
241 CC1Args.push_back(
"-Werror=implicit-function-declaration");
248 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc,
false);
252 ArgStringList &CmdArgs)
const {
263 CmdArgs.push_back(
"-force_load");
265 llvm::sys::path::remove_filename(P);
266 llvm::sys::path::remove_filename(P);
267 llvm::sys::path::append(P,
"lib",
"arc",
"libarclite_");
270 P +=
"watchsimulator";
274 P +=
"appletvsimulator";
278 P +=
"iphonesimulator";
285 CmdArgs.push_back(Args.MakeArgString(P));
289 StringRef DarwinLibName,
bool AlwaysLink,
290 bool IsEmbedded,
bool AddRPath)
const {
292 llvm::sys::path::append(Dir,
"lib", IsEmbedded ?
"macho_embedded" :
"darwin");
295 llvm::sys::path::append(P, DarwinLibName);
300 if (AlwaysLink ||
getVFS().exists(P))
301 CmdArgs.push_back(Args.MakeArgString(P));
308 assert(DarwinLibName.endswith(
".dylib") &&
"must be a dynamic library");
312 CmdArgs.push_back(
"-rpath");
313 CmdArgs.push_back(
"@executable_path");
317 CmdArgs.push_back(
"-rpath");
318 CmdArgs.push_back(Args.MakeArgString(Dir));
323 ArgStringList &CmdArgs)
const {
328 llvm::sys::path::append(P,
"lib",
"darwin");
329 const char *Library =
"libclang_rt.profile_osx.a";
333 Library =
"libclang_rt.profile_watchos.a";
335 llvm::sys::path::append(P,
"libclang_rt.profile_watchossim.a");
336 Library =
getVFS().
exists(P) ?
"libclang_rt.profile_watchossim.a"
337 :
"libclang_rt.profile_watchos.a";
339 Library =
"libclang_rt.profile_tvos.a";
341 llvm::sys::path::append(P,
"libclang_rt.profile_tvossim.a");
342 Library =
getVFS().
exists(P) ?
"libclang_rt.profile_tvossim.a"
343 :
"libclang_rt.profile_tvos.a";
345 Library =
"libclang_rt.profile_ios.a";
347 llvm::sys::path::append(P,
"libclang_rt.profile_iossim.a");
348 Library =
getVFS().
exists(P) ?
"libclang_rt.profile_iossim.a"
349 :
"libclang_rt.profile_ios.a";
358 void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
359 ArgStringList &CmdArgs,
360 StringRef Sanitizer)
const {
361 if (!Args.hasArg(options::OPT_dynamiclib) &&
362 !Args.hasArg(options::OPT_bundle)) {
371 (Twine(
"libclang_rt.") + Sanitizer +
"_" + OS +
"_dynamic.dylib").str(),
378 CmdArgs.push_back(
"-lc++abi");
383 ArgStringList &CmdArgs)
const {
389 getDriver().
Diag(diag::err_drv_unsupported_rtlib_for_platform)
390 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() <<
"darwin";
396 if (Args.hasArg(options::OPT_static) ||
397 Args.hasArg(options::OPT_fapple_kext) ||
398 Args.hasArg(options::OPT_mkernel))
404 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
405 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
411 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
413 AddLinkSanitizerLibArgs(Args, CmdArgs,
"ubsan");
415 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tsan");
419 CmdArgs.push_back(
"-lSystem");
434 CmdArgs.push_back(
"-lgcc_s.1");
443 CmdArgs.push_back(
"-lgcc_s.10.4");
445 CmdArgs.push_back(
"-lgcc_s.10.5");
465 void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
471 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
474 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
476 if (
char *env = ::getenv(
"SDKROOT")) {
479 if (llvm::sys::path::is_absolute(env) &&
getVFS().exists(env) &&
480 StringRef(env) !=
"/") {
481 Args.append(Args.MakeSeparateArg(
482 nullptr, Opts.getOption(options::OPT_isysroot), env));
487 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
488 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
489 Arg *TvOSVersion = Args.getLastArg(options::OPT_mtvos_version_min_EQ);
490 Arg *WatchOSVersion = Args.getLastArg(options::OPT_mwatchos_version_min_EQ);
492 if (OSXVersion && (iOSVersion || TvOSVersion || WatchOSVersion)) {
494 << OSXVersion->getAsString(Args)
495 << (iOSVersion ? iOSVersion :
496 TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
497 iOSVersion = TvOSVersion = WatchOSVersion =
nullptr;
498 }
else if (iOSVersion && (TvOSVersion || WatchOSVersion)) {
500 << iOSVersion->getAsString(Args)
501 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
502 TvOSVersion = WatchOSVersion =
nullptr;
503 }
else if (TvOSVersion && WatchOSVersion) {
505 << TvOSVersion->getAsString(Args)
506 << WatchOSVersion->getAsString(Args);
507 WatchOSVersion =
nullptr;
508 }
else if (!OSXVersion && !iOSVersion && !TvOSVersion && !WatchOSVersion) {
511 std::string OSXTarget;
512 std::string iOSTarget;
513 std::string TvOSTarget;
514 std::string WatchOSTarget;
516 if (
char *env = ::getenv(
"MACOSX_DEPLOYMENT_TARGET"))
518 if (
char *env = ::getenv(
"IPHONEOS_DEPLOYMENT_TARGET"))
520 if (
char *env = ::getenv(
"TVOS_DEPLOYMENT_TARGET"))
522 if (
char *env = ::getenv(
"WATCHOS_DEPLOYMENT_TARGET"))
528 if (OSXTarget.empty() && iOSTarget.empty() && WatchOSTarget.empty() &&
529 TvOSTarget.empty() && Args.hasArg(options::OPT_isysroot)) {
530 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
531 StringRef isysroot = A->getValue();
533 size_t BeginSDK = isysroot.rfind(
"SDKs/");
534 size_t EndSDK = isysroot.rfind(
".sdk");
535 if (BeginSDK != StringRef::npos && EndSDK != StringRef::npos) {
536 StringRef SDK = isysroot.slice(BeginSDK + 5, EndSDK);
539 size_t StartVer = SDK.find_first_of(
"0123456789");
540 size_t EndVer = SDK.find_last_of(
"0123456789");
541 if (StartVer != StringRef::npos && EndVer > StartVer) {
542 StringRef Version = SDK.slice(StartVer, EndVer + 1);
543 if (SDK.startswith(
"iPhoneOS") ||
544 SDK.startswith(
"iPhoneSimulator"))
546 else if (SDK.startswith(
"MacOSX"))
548 else if (SDK.startswith(
"WatchOS") ||
549 SDK.startswith(
"WatchSimulator"))
550 WatchOSTarget = Version;
551 else if (SDK.startswith(
"AppleTVOS") ||
552 SDK.startswith(
"AppleTVSimulator"))
553 TvOSTarget = Version;
561 if (OSXTarget.empty() && iOSTarget.empty() && TvOSTarget.empty() &&
562 WatchOSTarget.empty()) {
564 unsigned Major, Minor, Micro;
565 if (MachOArchName ==
"armv7" || MachOArchName ==
"armv7s" ||
566 MachOArchName ==
"arm64") {
567 getTriple().getiOSVersion(Major, Minor, Micro);
568 llvm::raw_string_ostream(iOSTarget) << Major <<
'.' << Minor <<
'.'
570 }
else if (MachOArchName ==
"armv7k") {
571 getTriple().getWatchOSVersion(Major, Minor, Micro);
572 llvm::raw_string_ostream(WatchOSTarget) << Major <<
'.' << Minor <<
'.'
574 }
else if (MachOArchName !=
"armv6m" && MachOArchName !=
"armv7m" &&
575 MachOArchName !=
"armv7em") {
576 if (!
getTriple().getMacOSXVersion(Major, Minor, Micro)) {
580 llvm::raw_string_ostream(OSXTarget) << Major <<
'.' << Minor <<
'.'
586 if (!WatchOSTarget.empty() && (!iOSTarget.empty() || !TvOSTarget.empty())) {
587 getDriver().
Diag(diag::err_drv_conflicting_deployment_targets)
588 <<
"WATCHOS_DEPLOYMENT_TARGET"
589 << (!iOSTarget.empty() ?
"IPHONEOS_DEPLOYMENT_TARGET" :
590 "TVOS_DEPLOYMENT_TARGET");
594 if (!TvOSTarget.empty() && !iOSTarget.empty()) {
595 getDriver().
Diag(diag::err_drv_conflicting_deployment_targets)
596 <<
"TVOS_DEPLOYMENT_TARGET"
597 <<
"IPHONEOS_DEPLOYMENT_TARGET";
602 if (!OSXTarget.empty() && (!iOSTarget.empty() ||
603 !WatchOSTarget.empty() ||
604 !TvOSTarget.empty())) {
605 if (
getTriple().getArch() == llvm::Triple::arm ||
606 getTriple().getArch() == llvm::Triple::aarch64 ||
607 getTriple().getArch() == llvm::Triple::thumb)
610 iOSTarget = WatchOSTarget = TvOSTarget =
"";
613 if (!OSXTarget.empty()) {
614 const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
615 OSXVersion = Args.MakeJoinedArg(
nullptr, O, OSXTarget);
616 Args.append(OSXVersion);
617 }
else if (!iOSTarget.empty()) {
618 const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
619 iOSVersion = Args.MakeJoinedArg(
nullptr, O, iOSTarget);
620 Args.append(iOSVersion);
621 }
else if (!TvOSTarget.empty()) {
622 const Option O = Opts.getOption(options::OPT_mtvos_version_min_EQ);
623 TvOSVersion = Args.MakeJoinedArg(
nullptr, O, TvOSTarget);
624 Args.append(TvOSVersion);
625 }
else if (!WatchOSTarget.empty()) {
626 const Option O = Opts.getOption(options::OPT_mwatchos_version_min_EQ);
627 WatchOSVersion = Args.MakeJoinedArg(
nullptr, O, WatchOSTarget);
628 Args.append(WatchOSVersion);
637 else if (TvOSVersion)
639 else if (WatchOSVersion)
642 llvm_unreachable(
"Unable to infer Darwin variant");
645 unsigned Major, Minor, Micro;
647 if (Platform ==
MacOS) {
648 assert((!iOSVersion && !TvOSVersion && !WatchOSVersion) &&
649 "Unknown target platform!");
652 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
654 << OSXVersion->getAsString(Args);
656 assert(iOSVersion &&
"Unknown target platform!");
659 HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
661 << iOSVersion->getAsString(Args);
662 }
else if (Platform ==
TvOS) {
664 Micro, HadExtra) || HadExtra ||
665 Major >= 10 || Minor >= 100 || Micro >= 100)
667 << TvOSVersion->getAsString(Args);
668 }
else if (Platform ==
WatchOS) {
670 Micro, HadExtra) || HadExtra ||
671 Major >= 10 || Minor >= 100 || Micro >= 100)
673 << WatchOSVersion->getAsString(Args);
675 llvm_unreachable(
"unknown kind of Darwin platform");
688 setTarget(Platform, Major, Minor, Micro);
692 ArgStringList &CmdArgs)
const {
697 CmdArgs.push_back(
"-lc++");
707 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
709 llvm::sys::path::append(
P,
"usr",
"lib",
"libstdc++.dylib");
712 llvm::sys::path::remove_filename(
P);
713 llvm::sys::path::append(
P,
"libstdc++.6.dylib");
715 CmdArgs.push_back(Args.MakeArgString(
P));
726 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
731 CmdArgs.push_back(
"-lstdc++");
737 ArgStringList &CmdArgs)
const {
744 llvm::sys::path::append(P,
"lib",
"darwin");
748 llvm::sys::path::append(P,
"libclang_rt.cc_kext_watchos.a");
750 llvm::sys::path::append(P,
"libclang_rt.cc_kext_tvos.a");
752 llvm::sys::path::append(P,
"libclang_rt.cc_kext_ios.a");
754 llvm::sys::path::append(P,
"libclang_rt.cc_kext.a");
760 CmdArgs.push_back(Args.MakeArgString(P));
764 const char *BoundArch)
const {
765 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
775 for (Arg *A : Args) {
776 if (A->getOption().matches(options::OPT_Xarch__)) {
779 llvm::Triple::ArchType XarchArch =
781 if (!(XarchArch ==
getArch() ||
787 Arg *OriginalArg = A;
788 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
789 unsigned Prev = Index;
790 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
800 if (!XarchArg || Index > Prev + 1) {
801 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
802 << A->getAsString(Args);
805 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
806 << A->getAsString(Args);
810 XarchArg->setBaseArg(A);
812 A = XarchArg.release();
813 DAL->AddSynthesizedArg(A);
820 for (
const char *
Value : A->getValues()) {
822 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
836 case options::OPT_mkernel:
837 case options::OPT_fapple_kext:
839 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
842 case options::OPT_dependency_file:
843 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
846 case options::OPT_gfull:
847 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
849 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
852 case options::OPT_gused:
853 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
855 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
858 case options::OPT_shared:
859 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
862 case options::OPT_fconstant_cfstrings:
863 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
866 case options::OPT_fno_constant_cfstrings:
867 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
870 case options::OPT_Wnonportable_cfstrings:
872 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
875 case options::OPT_Wno_nonportable_cfstrings:
877 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
880 case options::OPT_fpascal_strings:
881 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
884 case options::OPT_fno_pascal_strings:
885 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
890 if (
getTriple().getArch() == llvm::Triple::x86 ||
891 getTriple().getArch() == llvm::Triple::x86_64)
892 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
893 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_mtune_EQ),
899 StringRef
Name = BoundArch;
900 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
901 const Option MArch = Opts.getOption(options::OPT_march_EQ);
907 else if (Name ==
"ppc601")
908 DAL->AddJoinedArg(
nullptr, MCpu,
"601");
909 else if (Name ==
"ppc603")
910 DAL->AddJoinedArg(
nullptr, MCpu,
"603");
911 else if (Name ==
"ppc604")
912 DAL->AddJoinedArg(
nullptr, MCpu,
"604");
913 else if (Name ==
"ppc604e")
914 DAL->AddJoinedArg(
nullptr, MCpu,
"604e");
915 else if (Name ==
"ppc750")
916 DAL->AddJoinedArg(
nullptr, MCpu,
"750");
917 else if (Name ==
"ppc7400")
918 DAL->AddJoinedArg(
nullptr, MCpu,
"7400");
919 else if (Name ==
"ppc7450")
920 DAL->AddJoinedArg(
nullptr, MCpu,
"7450");
921 else if (Name ==
"ppc970")
922 DAL->AddJoinedArg(
nullptr, MCpu,
"970");
924 else if (Name ==
"ppc64" || Name ==
"ppc64le")
925 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
927 else if (Name ==
"i386")
929 else if (Name ==
"i486")
930 DAL->AddJoinedArg(
nullptr, MArch,
"i486");
931 else if (Name ==
"i586")
932 DAL->AddJoinedArg(
nullptr, MArch,
"i586");
933 else if (Name ==
"i686")
934 DAL->AddJoinedArg(
nullptr, MArch,
"i686");
935 else if (Name ==
"pentium")
936 DAL->AddJoinedArg(
nullptr, MArch,
"pentium");
937 else if (Name ==
"pentium2")
938 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
939 else if (Name ==
"pentpro")
940 DAL->AddJoinedArg(
nullptr, MArch,
"pentiumpro");
941 else if (Name ==
"pentIIm3")
942 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
944 else if (Name ==
"x86_64")
945 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
946 else if (Name ==
"x86_64h") {
947 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
948 DAL->AddJoinedArg(
nullptr, MArch,
"x86_64h");
951 else if (Name ==
"arm")
952 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
953 else if (Name ==
"armv4t")
954 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
955 else if (Name ==
"armv5")
956 DAL->AddJoinedArg(
nullptr, MArch,
"armv5tej");
957 else if (Name ==
"xscale")
958 DAL->AddJoinedArg(
nullptr, MArch,
"xscale");
959 else if (Name ==
"armv6")
960 DAL->AddJoinedArg(
nullptr, MArch,
"armv6k");
961 else if (Name ==
"armv6m")
962 DAL->AddJoinedArg(
nullptr, MArch,
"armv6m");
963 else if (Name ==
"armv7")
964 DAL->AddJoinedArg(
nullptr, MArch,
"armv7a");
965 else if (Name ==
"armv7em")
966 DAL->AddJoinedArg(
nullptr, MArch,
"armv7em");
967 else if (Name ==
"armv7k")
968 DAL->AddJoinedArg(
nullptr, MArch,
"armv7k");
969 else if (Name ==
"armv7m")
970 DAL->AddJoinedArg(
nullptr, MArch,
"armv7m");
971 else if (Name ==
"armv7s")
972 DAL->AddJoinedArg(
nullptr, MArch,
"armv7s");
979 ArgStringList &CmdArgs)
const {
988 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic.a" :
"_static.a";
994 const char *BoundArch)
const {
1006 AddDeploymentTarget(*DAL);
1017 if (A->getOption().getID() != options::OPT_mkernel &&
1018 A->getOption().getID() != options::OPT_fapple_kext)
1020 assert(it != ie &&
"unexpected argument translation");
1022 assert(A->getOption().getID() == options::OPT_static &&
1023 "missing expected -static argument");
1024 it = DAL->getArgs().erase(it);
1032 !Args.getLastArg(options::OPT_stdlib_EQ))
1033 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_stdlib_EQ),
1046 if (where != StringRef()) {
1047 getDriver().
Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
1055 return getArch() == llvm::Triple::x86_64;
1059 if (
const char *
S = ::getenv(
"RC_DEBUG_OPTIONS"))
1060 return S[0] !=
'\0';
1079 return (
getArch() == llvm::Triple::x86_64 ||
1080 getArch() == llvm::Triple::aarch64);
1085 return getArch() == llvm::Triple::x86 ||
getArch() == llvm::Triple::x86_64;
1089 ArgStringList &CmdArgs)
const {
1093 CmdArgs.push_back(
"-watchos_version_min");
1095 CmdArgs.push_back(
"-watchos_simulator_version_min");
1097 CmdArgs.push_back(
"-tvos_version_min");
1099 CmdArgs.push_back(
"-tvos_simulator_version_min");
1101 CmdArgs.push_back(
"-ios_simulator_version_min");
1103 CmdArgs.push_back(
"-iphoneos_version_min");
1106 CmdArgs.push_back(
"-macosx_version_min");
1109 CmdArgs.push_back(Args.MakeArgString(TargetVersion.
getAsString()));
1113 ArgStringList &CmdArgs)
const {
1115 if (Args.hasArg(options::OPT_dynamiclib)) {
1123 CmdArgs.push_back(
"-ldylib1.o");
1126 CmdArgs.push_back(
"-ldylib1.o");
1128 CmdArgs.push_back(
"-ldylib1.10.5.o");
1131 if (Args.hasArg(options::OPT_bundle)) {
1132 if (!Args.hasArg(options::OPT_static)) {
1140 CmdArgs.push_back(
"-lbundle1.o");
1143 CmdArgs.push_back(
"-lbundle1.o");
1148 if (Args.hasArg(options::OPT_static) ||
1149 Args.hasArg(options::OPT_object) ||
1150 Args.hasArg(options::OPT_preload)) {
1151 CmdArgs.push_back(
"-lgcrt0.o");
1153 CmdArgs.push_back(
"-lgcrt1.o");
1163 CmdArgs.push_back(
"-no_new_main");
1165 if (Args.hasArg(options::OPT_static) ||
1166 Args.hasArg(options::OPT_object) ||
1167 Args.hasArg(options::OPT_preload)) {
1168 CmdArgs.push_back(
"-lcrt0.o");
1176 if (
getArch() == llvm::Triple::aarch64)
1179 CmdArgs.push_back(
"-lcrt1.o");
1181 CmdArgs.push_back(
"-lcrt1.3.1.o");
1184 CmdArgs.push_back(
"-lcrt1.o");
1186 CmdArgs.push_back(
"-lcrt1.10.5.o");
1188 CmdArgs.push_back(
"-lcrt1.10.6.o");
1200 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
1201 CmdArgs.push_back(Str);
1217 Res |= SanitizerKind::Address;
1220 Res |= SanitizerKind::Vptr;
1221 Res |= SanitizerKind::SafeStack;
1222 Res |= SanitizerKind::Thread;
1236 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1237 std::pair<StringRef, StringRef> First = VersionText.split(
'.');
1238 std::pair<StringRef, StringRef> Second = First.second.split(
'.');
1240 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1241 if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
1243 GoodVersion.
MajorStr = First.first.str();
1244 if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
1246 GoodVersion.MinorStr = Second.first.str();
1257 StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
1258 if (!PatchText.empty()) {
1259 if (
size_t EndNumber = PatchText.find_first_not_of(
"0123456789")) {
1261 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1262 GoodVersion.Patch < 0)
1264 GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
1274 StringRef RHSPatchSuffix)
const {
1275 if (Major != RHSMajor)
1276 return Major < RHSMajor;
1277 if (Minor != RHSMinor)
1278 return Minor < RHSMinor;
1279 if (Patch != RHSPatch) {
1288 return Patch < RHSPatch;
1290 if (PatchSuffix != RHSPatchSuffix) {
1292 if (RHSPatchSuffix.empty())
1294 if (PatchSuffix.empty())
1298 return PatchSuffix < RHSPatchSuffix;
1306 const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
1308 return A->getValue();
1309 return GCC_INSTALL_PREFIX;
1322 const llvm::Triple &TargetTriple,
const ArgList &Args,
1324 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1325 ? TargetTriple.get64BitArchVariant()
1326 : TargetTriple.get32BitArchVariant();
1332 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1333 CandidateTripleAliases, CandidateBiarchLibDirs,
1334 CandidateBiarchTripleAliases);
1338 D.PrefixDirs.end());
1341 if (GCCToolchainDir !=
"") {
1342 if (GCCToolchainDir.back() ==
'/')
1343 GCCToolchainDir = GCCToolchainDir.drop_back();
1345 Prefixes.push_back(GCCToolchainDir);
1348 if (!D.SysRoot.empty()) {
1349 Prefixes.push_back(D.SysRoot);
1350 Prefixes.push_back(D.SysRoot +
"/usr");
1354 Prefixes.push_back(D.InstalledDir +
"/..");
1357 if (D.SysRoot.empty())
1358 Prefixes.push_back(
"/usr");
1364 for (
const std::string &Prefix : Prefixes) {
1365 if (!D.getVFS().exists(Prefix))
1367 for (StringRef Suffix : CandidateLibDirs) {
1368 const std::string LibDir = Prefix + Suffix.str();
1369 if (!D.getVFS().exists(LibDir))
1371 for (StringRef Candidate : ExtraTripleAliases)
1372 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1373 for (StringRef Candidate : CandidateTripleAliases)
1374 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1376 for (StringRef Suffix : CandidateBiarchLibDirs) {
1377 const std::string LibDir = Prefix + Suffix.str();
1378 if (!D.getVFS().exists(LibDir))
1380 for (StringRef Candidate : CandidateBiarchTripleAliases)
1381 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1388 for (
const auto &InstallPath : CandidateGCCInstallPaths)
1389 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
1391 if (!GCCInstallPath.empty())
1392 OS <<
"Selected GCC installation: " << GCCInstallPath <<
"\n";
1395 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
1397 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
1398 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
1402 if (BiarchSibling.hasValue()) {
1403 M = BiarchSibling.getValue();
1409 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1410 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
1418 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
1419 static const char *
const AArch64Triples[] = {
1420 "aarch64-none-linux-gnu",
"aarch64-linux-gnu",
"aarch64-linux-android",
1421 "aarch64-redhat-linux"};
1422 static const char *
const AArch64beLibDirs[] = {
"/lib"};
1423 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu",
1424 "aarch64_be-linux-gnu"};
1426 static const char *
const ARMLibDirs[] = {
"/lib"};
1427 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi",
1428 "arm-linux-androideabi"};
1429 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
1430 "armv7hl-redhat-linux-gnueabi"};
1431 static const char *
const ARMebLibDirs[] = {
"/lib"};
1432 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi",
1433 "armeb-linux-androideabi"};
1434 static const char *
const ARMebHFTriples[] = {
1435 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
1437 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
1438 static const char *
const X86_64Triples[] = {
1439 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
1440 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
1441 "x86_64-redhat-linux",
"x86_64-suse-linux",
1442 "x86_64-manbo-linux-gnu",
"x86_64-linux-gnu",
1443 "x86_64-slackware-linux",
"x86_64-linux-android",
1444 "x86_64-unknown-linux"};
1445 static const char *
const X32LibDirs[] = {
"/libx32"};
1446 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
1447 static const char *
const X86Triples[] = {
1448 "i686-linux-gnu",
"i686-pc-linux-gnu",
"i486-linux-gnu",
1449 "i386-linux-gnu",
"i386-redhat-linux6E",
"i686-redhat-linux",
1450 "i586-redhat-linux",
"i386-redhat-linux",
"i586-suse-linux",
1451 "i486-slackware-linux",
"i686-montavista-linux",
"i686-linux-android",
1454 static const char *
const MIPSLibDirs[] = {
"/lib"};
1455 static const char *
const MIPSTriples[] = {
"mips-linux-gnu",
"mips-mti-linux",
1456 "mips-mti-linux-gnu",
1457 "mips-img-linux-gnu"};
1458 static const char *
const MIPSELLibDirs[] = {
"/lib"};
1459 static const char *
const MIPSELTriples[] = {
1460 "mipsel-linux-gnu",
"mipsel-linux-android",
"mips-img-linux-gnu"};
1462 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
1463 static const char *
const MIPS64Triples[] = {
1464 "mips64-linux-gnu",
"mips-mti-linux-gnu",
"mips-img-linux-gnu",
1465 "mips64-linux-gnuabi64"};
1466 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
1467 static const char *
const MIPS64ELTriples[] = {
1468 "mips64el-linux-gnu",
"mips-mti-linux-gnu",
"mips-img-linux-gnu",
1469 "mips64el-linux-android",
"mips64el-linux-gnuabi64"};
1471 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
1472 static const char *
const PPCTriples[] = {
1473 "powerpc-linux-gnu",
"powerpc-unknown-linux-gnu",
"powerpc-linux-gnuspe",
1474 "powerpc-suse-linux",
"powerpc-montavista-linuxspe"};
1475 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
1476 static const char *
const PPC64Triples[] = {
1477 "powerpc64-linux-gnu",
"powerpc64-unknown-linux-gnu",
1478 "powerpc64-suse-linux",
"ppc64-redhat-linux"};
1479 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
1480 static const char *
const PPC64LETriples[] = {
1481 "powerpc64le-linux-gnu",
"powerpc64le-unknown-linux-gnu",
1482 "powerpc64le-suse-linux",
"ppc64le-redhat-linux"};
1484 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
1485 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
1486 "sparcv8-linux-gnu"};
1487 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
1488 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
1489 "sparcv9-linux-gnu"};
1491 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
1492 static const char *
const SystemZTriples[] = {
1493 "s390x-linux-gnu",
"s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
1494 "s390x-suse-linux",
"s390x-redhat-linux"};
1497 static const char *
const SolarisSPARCLibDirs[] = {
"/gcc"};
1498 static const char *
const SolarisSPARCTriples[] = {
"sparc-sun-solaris2.11",
1499 "i386-pc-solaris2.11"};
1504 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1505 LibDirs.append(
begin(SolarisSPARCLibDirs),
end(SolarisSPARCLibDirs));
1506 TripleAliases.append(
begin(SolarisSPARCTriples),
end(SolarisSPARCTriples));
1510 switch (TargetTriple.getArch()) {
1511 case llvm::Triple::aarch64:
1512 LibDirs.append(
begin(AArch64LibDirs),
end(AArch64LibDirs));
1513 TripleAliases.append(
begin(AArch64Triples),
end(AArch64Triples));
1514 BiarchLibDirs.append(
begin(AArch64LibDirs),
end(AArch64LibDirs));
1515 BiarchTripleAliases.append(
begin(AArch64Triples),
end(AArch64Triples));
1517 case llvm::Triple::aarch64_be:
1518 LibDirs.append(
begin(AArch64beLibDirs),
end(AArch64beLibDirs));
1519 TripleAliases.append(
begin(AArch64beTriples),
end(AArch64beTriples));
1520 BiarchLibDirs.append(
begin(AArch64beLibDirs),
end(AArch64beLibDirs));
1521 BiarchTripleAliases.append(
begin(AArch64beTriples),
end(AArch64beTriples));
1523 case llvm::Triple::arm:
1524 case llvm::Triple::thumb:
1525 LibDirs.append(
begin(ARMLibDirs),
end(ARMLibDirs));
1526 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1527 TripleAliases.append(
begin(ARMHFTriples),
end(ARMHFTriples));
1529 TripleAliases.append(
begin(ARMTriples),
end(ARMTriples));
1532 case llvm::Triple::armeb:
1533 case llvm::Triple::thumbeb:
1534 LibDirs.append(
begin(ARMebLibDirs),
end(ARMebLibDirs));
1535 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1536 TripleAliases.append(
begin(ARMebHFTriples),
end(ARMebHFTriples));
1538 TripleAliases.append(
begin(ARMebTriples),
end(ARMebTriples));
1541 case llvm::Triple::x86_64:
1542 LibDirs.append(
begin(X86_64LibDirs),
end(X86_64LibDirs));
1543 TripleAliases.append(
begin(X86_64Triples),
end(X86_64Triples));
1546 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
1547 BiarchLibDirs.append(
begin(X32LibDirs),
end(X32LibDirs));
1548 BiarchTripleAliases.append(
begin(X86_64Triples),
end(X86_64Triples));
1550 BiarchLibDirs.append(
begin(X86LibDirs),
end(X86LibDirs));
1551 BiarchTripleAliases.append(
begin(X86Triples),
end(X86Triples));
1554 case llvm::Triple::x86:
1555 LibDirs.append(
begin(X86LibDirs),
end(X86LibDirs));
1556 TripleAliases.append(
begin(X86Triples),
end(X86Triples));
1557 BiarchLibDirs.append(
begin(X86_64LibDirs),
end(X86_64LibDirs));
1558 BiarchTripleAliases.append(
begin(X86_64Triples),
end(X86_64Triples));
1560 case llvm::Triple::mips:
1561 LibDirs.append(
begin(MIPSLibDirs),
end(MIPSLibDirs));
1562 TripleAliases.append(
begin(MIPSTriples),
end(MIPSTriples));
1563 BiarchLibDirs.append(
begin(MIPS64LibDirs),
end(MIPS64LibDirs));
1564 BiarchTripleAliases.append(
begin(MIPS64Triples),
end(MIPS64Triples));
1566 case llvm::Triple::mipsel:
1567 LibDirs.append(
begin(MIPSELLibDirs),
end(MIPSELLibDirs));
1568 TripleAliases.append(
begin(MIPSELTriples),
end(MIPSELTriples));
1569 TripleAliases.append(
begin(MIPSTriples),
end(MIPSTriples));
1570 BiarchLibDirs.append(
begin(MIPS64ELLibDirs),
end(MIPS64ELLibDirs));
1571 BiarchTripleAliases.append(
begin(MIPS64ELTriples),
end(MIPS64ELTriples));
1573 case llvm::Triple::mips64:
1574 LibDirs.append(
begin(MIPS64LibDirs),
end(MIPS64LibDirs));
1575 TripleAliases.append(
begin(MIPS64Triples),
end(MIPS64Triples));
1576 BiarchLibDirs.append(
begin(MIPSLibDirs),
end(MIPSLibDirs));
1577 BiarchTripleAliases.append(
begin(MIPSTriples),
end(MIPSTriples));
1579 case llvm::Triple::mips64el:
1580 LibDirs.append(
begin(MIPS64ELLibDirs),
end(MIPS64ELLibDirs));
1581 TripleAliases.append(
begin(MIPS64ELTriples),
end(MIPS64ELTriples));
1582 BiarchLibDirs.append(
begin(MIPSELLibDirs),
end(MIPSELLibDirs));
1583 BiarchTripleAliases.append(
begin(MIPSELTriples),
end(MIPSELTriples));
1584 BiarchTripleAliases.append(
begin(MIPSTriples),
end(MIPSTriples));
1586 case llvm::Triple::ppc:
1587 LibDirs.append(
begin(PPCLibDirs),
end(PPCLibDirs));
1588 TripleAliases.append(
begin(PPCTriples),
end(PPCTriples));
1589 BiarchLibDirs.append(
begin(PPC64LibDirs),
end(PPC64LibDirs));
1590 BiarchTripleAliases.append(
begin(PPC64Triples),
end(PPC64Triples));
1592 case llvm::Triple::ppc64:
1593 LibDirs.append(
begin(PPC64LibDirs),
end(PPC64LibDirs));
1594 TripleAliases.append(
begin(PPC64Triples),
end(PPC64Triples));
1595 BiarchLibDirs.append(
begin(PPCLibDirs),
end(PPCLibDirs));
1596 BiarchTripleAliases.append(
begin(PPCTriples),
end(PPCTriples));
1598 case llvm::Triple::ppc64le:
1599 LibDirs.append(
begin(PPC64LELibDirs),
end(PPC64LELibDirs));
1600 TripleAliases.append(
begin(PPC64LETriples),
end(PPC64LETriples));
1602 case llvm::Triple::sparc:
1603 case llvm::Triple::sparcel:
1604 LibDirs.append(
begin(SPARCv8LibDirs),
end(SPARCv8LibDirs));
1605 TripleAliases.append(
begin(SPARCv8Triples),
end(SPARCv8Triples));
1606 BiarchLibDirs.append(
begin(SPARCv9LibDirs),
end(SPARCv9LibDirs));
1607 BiarchTripleAliases.append(
begin(SPARCv9Triples),
end(SPARCv9Triples));
1609 case llvm::Triple::sparcv9:
1610 LibDirs.append(
begin(SPARCv9LibDirs),
end(SPARCv9LibDirs));
1611 TripleAliases.append(
begin(SPARCv9Triples),
end(SPARCv9Triples));
1612 BiarchLibDirs.append(
begin(SPARCv8LibDirs),
end(SPARCv8LibDirs));
1613 BiarchTripleAliases.append(
begin(SPARCv8Triples),
end(SPARCv8Triples));
1615 case llvm::Triple::systemz:
1616 LibDirs.append(
begin(SystemZLibDirs),
end(SystemZLibDirs));
1617 TripleAliases.append(
begin(SystemZTriples),
end(SystemZTriples));
1627 TripleAliases.push_back(TargetTriple.str());
1630 if (TargetTriple.str() != BiarchTriple.str())
1631 BiarchTripleAliases.push_back(BiarchTriple.str());
1638 const llvm::Triple &TargetTriple,
const llvm::opt::ArgList &Args) {
1641 if (Args.hasArg(options::OPT_cuda_path_EQ))
1642 CudaPathCandidates.push_back(
1643 Args.getLastArgValue(options::OPT_cuda_path_EQ));
1645 CudaPathCandidates.push_back(D.SysRoot +
"/usr/local/cuda");
1646 CudaPathCandidates.push_back(D.SysRoot +
"/usr/local/cuda-7.5");
1647 CudaPathCandidates.push_back(D.SysRoot +
"/usr/local/cuda-7.0");
1650 for (
const auto &CudaPath : CudaPathCandidates) {
1651 if (CudaPath.empty() || !D.getVFS().exists(CudaPath))
1654 CudaInstallPath = CudaPath;
1655 CudaIncludePath = CudaInstallPath +
"/include";
1656 CudaLibDevicePath = CudaInstallPath +
"/nvvm/libdevice";
1658 CudaInstallPath + (TargetTriple.isArch64Bit() ?
"/lib64" :
"/lib");
1660 if (!(D.getVFS().exists(CudaIncludePath) &&
1661 D.getVFS().exists(CudaLibPath) &&
1662 D.getVFS().exists(CudaLibDevicePath)))
1666 for (llvm::sys::fs::directory_iterator LI(CudaLibDevicePath, EC), LE;
1667 !EC && LI != LE; LI = LI.increment(EC)) {
1669 StringRef FileName = llvm::sys::path::filename(FilePath);
1671 const StringRef LibDeviceName =
"libdevice.";
1672 if (!(FileName.startswith(LibDeviceName) && FileName.endswith(
".bc")))
1674 StringRef GpuArch = FileName.slice(
1675 LibDeviceName.size(), FileName.find(
'.', LibDeviceName.size()));
1676 CudaLibDeviceMap[GpuArch] = FilePath.str();
1678 if (GpuArch ==
"compute_20") {
1679 CudaLibDeviceMap[
"sm_20"] =
FilePath;
1680 CudaLibDeviceMap[
"sm_21"] =
FilePath;
1681 }
else if (GpuArch ==
"compute_30") {
1682 CudaLibDeviceMap[
"sm_30"] =
FilePath;
1683 CudaLibDeviceMap[
"sm_32"] =
FilePath;
1684 }
else if (GpuArch ==
"compute_35") {
1685 CudaLibDeviceMap[
"sm_35"] =
FilePath;
1686 CudaLibDeviceMap[
"sm_37"] =
FilePath;
1697 OS <<
"Found CUDA installation: " << CudaInstallPath <<
"\n";
1702 class FilterNonExistent {
1708 : Base(Base), VFS(VFS) {}
1709 bool operator()(
const Multilib &M) {
1716 std::vector<std::string> &Flags) {
1718 Flags.push_back(std::string(
"+") + Flag);
1720 Flags.push_back(std::string(
"-") + Flag);
1724 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
1725 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1729 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel;
1733 return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1737 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1741 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
1742 return A && A->getOption().matches(options::OPT_mips16);
1746 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
1747 return A && A->getOption().matches(options::OPT_mmicromips);
1751 struct DetectedMultilibs {
1765 return Multilib(commonSuffix, commonSuffix, commonSuffix);
1769 StringRef Path,
const ArgList &Args,
1770 DetectedMultilibs &Result) {
1796 FilterNonExistent NonExistent(Path, D.
getVFS());
1804 .
flag(
"-mmicromips")
1805 .
flag(
"+march=mips32");
1810 .
flag(
"+mmicromips");
1815 .
flag(
"+march=mips64r2");
1823 .
flag(
"-mmicromips")
1824 .
flag(
"+march=mips32r2");
1843 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1855 .
Either(BigEndian, LittleEndian)
1861 StringRef TripleStr,
const Multilib &M) {
1862 std::vector<std::string> Dirs;
1863 Dirs.push_back((InstallDir +
"/include").str());
1864 std::string SysRootInc =
1865 InstallDir.str() +
"/../../../../sysroot";
1867 Dirs.push_back(SysRootInc +
"/uclibc/usr/include");
1869 Dirs.push_back(SysRootInc +
"/usr/include");
1881 .flag(
"+march=mips32r2");
1883 auto MArchMipselR2 =
makeMultilib(
"/mipsel-r2-hard-musl")
1886 .
flag(
"+march=mips32r2");
1892 StringRef InstallDir, StringRef TripleStr,
const Multilib &M) {
1893 std::vector<std::string> Dirs;
1895 (InstallDir +
"/../sysroot" + M.
osSuffix() +
"/usr/include").str());
1905 auto MArchMicroMips =
1926 .includeSuffix(
"/64")
1933 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
1938 .
Either(BigEndian, LittleEndian)
1944 StringRef TripleStr,
const Multilib &M) {
1945 std::vector<std::string> Dirs;
1946 Dirs.push_back((InstallDir +
"/include").str());
1947 std::string SysRootInc =
1948 InstallDir.str() +
"/../../../../" + TripleStr.str();
1950 Dirs.push_back(SysRootInc +
"/libc/uclibc/usr/include");
1952 Dirs.push_back(SysRootInc +
"/libc/usr/include");
1970 .includeSuffix(
"/64")
1977 DebianMipsMultilibs =
1994 .
Maybe(LittleEndian)
1997 StringRef TripleStr,
const Multilib &M) {
1998 std::vector<std::string> Dirs;
1999 Dirs.push_back((InstallDir +
"/include").str());
2001 (InstallDir +
"/../../../../sysroot/usr/include").str());
2010 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2018 CPUName ==
"mips32r5" || CPUName ==
"p5600",
2019 "march=mips32r2", Flags);
2023 CPUName ==
"mips64r5" || CPUName ==
"octeon",
2024 "march=mips64r2", Flags);
2036 if (TargetTriple.isAndroid()) {
2038 if (AndroidMipsMultilibs.
select(Flags, Result.SelectedMultilib)) {
2039 Result.Multilibs = AndroidMipsMultilibs;
2045 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
2046 TargetTriple.getOS() == llvm::Triple::Linux &&
2047 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment) {
2048 if (MuslMipsMultilibs.
select(Flags, Result.SelectedMultilib)) {
2049 Result.Multilibs = MuslMipsMultilibs;
2055 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
2056 TargetTriple.getOS() == llvm::Triple::Linux &&
2057 TargetTriple.getEnvironment() == llvm::Triple::GNU) {
2059 if (ImgMultilibs.
select(Flags, Result.SelectedMultilib)) {
2060 Result.Multilibs = ImgMultilibs;
2068 MultilibSet *candidates[] = {&DebianMipsMultilibs, &FSFMipsMultilibs,
2073 for (
const auto &candidate : candidates) {
2074 if (candidate->select(Flags, Result.SelectedMultilib)) {
2075 if (candidate == &DebianMipsMultilibs)
2077 Result.Multilibs = *candidate;
2085 Result.Multilibs.push_back(Default);
2086 Result.Multilibs.FilterOut(NonExistent);
2088 if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
2098 const llvm::Triple &TargetTriple,
2099 StringRef Path,
const ArgList &Args,
2100 bool NeedsBiarchSuffix,
2101 DetectedMultilibs &Result) {
2112 .includeSuffix(
"/64")
2118 .includeSuffix(
"/32")
2124 .includeSuffix(
"/x32")
2129 FilterNonExistent NonExistent(Path, D.
getVFS());
2133 enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
2134 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
2135 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
2137 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
2139 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
2142 if (TargetTriple.isArch32Bit())
2143 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
2145 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
2147 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
2152 else if (Want == WANT64)
2154 else if (Want == WANTX32)
2159 Result.Multilibs.push_back(Default);
2160 Result.Multilibs.push_back(Alt64);
2161 Result.Multilibs.push_back(Alt32);
2162 Result.Multilibs.push_back(Altx32);
2164 Result.Multilibs.FilterOut(NonExistent);
2171 if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
2174 if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
2175 Result.SelectedMultilib == Altx32)
2176 Result.BiarchSibling = Default;
2181 void Generic_GCC::GCCInstallationDetector::scanLibDirForGCCTripleSolaris(
2182 const llvm::Triple &TargetArch,
const llvm::opt::ArgList &Args,
2183 const std::string &LibDir, StringRef CandidateTriple,
2184 bool NeedsBiarchSuffix) {
2190 !EC && LI != LE; LI = LI.
increment(EC)) {
2191 StringRef VersionText = llvm::sys::path::filename(LI->getName());
2194 if (CandidateVersion.Major != -1)
2195 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2197 if (CandidateVersion.isOlderThan(4, 1, 1))
2199 if (CandidateVersion <= Version)
2203 LibDir +
"/" + VersionText.str() +
"/lib/gcc/" + CandidateTriple.str();
2204 if (!D.getVFS().exists(GCCInstallPath))
2209 std::error_code EEC;
2211 LLI = D.getVFS().dir_begin(GCCInstallPath, EEC),
2213 !EEC && LLI != LLE; LLI = LLI.
increment(EEC)) {
2215 StringRef SubVersionText = llvm::sys::path::filename(LLI->getName());
2218 if (CandidateSubVersion > Version)
2219 Version = CandidateSubVersion;
2222 GCCTriple.setTriple(CandidateTriple);
2224 GCCInstallPath +=
"/" + Version.Text;
2225 GCCParentLibPath = GCCInstallPath +
"/../../../../";
2231 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2232 const llvm::Triple &TargetTriple,
const ArgList &Args,
2233 const std::string &LibDir, StringRef CandidateTriple,
2234 bool NeedsBiarchSuffix) {
2235 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2241 const std::string LibAndInstallSuffixes[][2] = {
2242 {
"/gcc/" + CandidateTriple.str(),
"/../../.."},
2245 {
"/gcc-cross/" + CandidateTriple.str(),
"/../../.."},
2247 {
"/" + CandidateTriple.str() +
"/gcc/" + CandidateTriple.str(),
2252 {
"/" + CandidateTriple.str(),
"/../.."},
2258 {
"/i386-linux-gnu/gcc/" + CandidateTriple.str(),
"/../../../.."}};
2260 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2261 scanLibDirForGCCTripleSolaris(TargetTriple, Args, LibDir, CandidateTriple,
2267 const unsigned NumLibSuffixes = (llvm::array_lengthof(LibAndInstallSuffixes) -
2268 (TargetArch != llvm::Triple::x86));
2269 for (
unsigned i = 0; i < NumLibSuffixes; ++i) {
2270 StringRef LibSuffix = LibAndInstallSuffixes[i][0];
2273 LI = D.getVFS().dir_begin(LibDir + LibSuffix, EC),
2275 !EC && LI != LE; LI = LI.
increment(EC)) {
2276 StringRef VersionText = llvm::sys::path::filename(LI->getName());
2278 if (CandidateVersion.Major != -1)
2279 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2281 if (CandidateVersion.isOlderThan(4, 1, 1))
2283 if (CandidateVersion <= Version)
2286 DetectedMultilibs Detected;
2294 NeedsBiarchSuffix, Detected)) {
2299 SelectedMultilib = Detected.SelectedMultilib;
2300 BiarchSibling = Detected.BiarchSibling;
2301 Version = CandidateVersion;
2302 GCCTriple.setTriple(CandidateTriple);
2307 LibDir + LibAndInstallSuffixes[i][0] +
"/" + VersionText.str();
2308 GCCParentLibPath = GCCInstallPath + LibAndInstallSuffixes[i][1];
2315 const ArgList &Args)
2329 return Preprocess.get();
2333 return Compile.get();
2352 return getArch() == llvm::Triple::x86_64;
2367 case llvm::Triple::x86:
2368 case llvm::Triple::x86_64:
2369 case llvm::Triple::aarch64:
2370 case llvm::Triple::aarch64_be:
2371 case llvm::Triple::arm:
2372 case llvm::Triple::armeb:
2373 case llvm::Triple::bpfel:
2374 case llvm::Triple::bpfeb:
2375 case llvm::Triple::thumb:
2376 case llvm::Triple::thumbeb:
2377 case llvm::Triple::ppc:
2378 case llvm::Triple::ppc64:
2379 case llvm::Triple::ppc64le:
2380 case llvm::Triple::systemz:
2389 Twine
Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2390 StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2391 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2392 if (!
getVFS().exists(Base + Suffix))
2400 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2401 getVFS().
exists(Base + Suffix +
"/" + GCCTriple + IncludeSuffix)) {
2403 Base + Suffix +
"/" + GCCTriple + IncludeSuffix);
2411 Base +
"/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2413 Base +
"/" + TargetMultiarchTriple + Suffix);
2422 ArgStringList &CC1Args)
const {
2424 bool UseInitArrayDefault =
2425 getTriple().getArch() == llvm::Triple::aarch64 ||
2426 getTriple().getArch() == llvm::Triple::aarch64_be ||
2427 (
getTriple().getOS() == llvm::Triple::Linux &&
2429 getTriple().getOS() == llvm::Triple::NaCl ||
2430 (
getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2433 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2434 options::OPT_fno_use_init_array, UseInitArrayDefault))
2435 CC1Args.push_back(
"-fuse-init-array");
2440 const llvm::Triple &Triple,
2441 const ArgList &Args)
2442 :
Linux(D, Triple, Args) {
2444 DetectedMultilibs
Result;
2447 SelectedMultilib = Result.SelectedMultilib;
2459 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2460 if (DriverArgs.hasArg(options::OPT_nostdinc))
2465 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2467 llvm::sys::path::append(P,
"include");
2471 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2476 const auto IncludePaths =
2478 for (
const auto &Path : IncludePaths)
2491 const std::string InstalledDir(
getDriver().getInstalledDir());
2492 std::string SysRootPath =
2493 InstalledDir +
"/../sysroot" + SelectedMultilib.
osSuffix();
2494 if (llvm::sys::fs::exists(SysRootPath))
2497 return std::string();
2502 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
2504 StringRef
Value = A->getValue();
2505 if (Value !=
"libc++")
2507 << A->getAsString(Args);
2514 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2515 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2516 DriverArgs.hasArg(options::OPT_nostdincxx))
2520 "Only -lc++ (aka libcxx) is suported in this toolchain.");
2526 for (
const auto &Path : IncludePaths) {
2527 if (llvm::sys::fs::exists(Path +
"/c++/v1")) {
2536 ArgStringList &CmdArgs)
const {
2538 "Only -lc++ (aka libxx) is suported in this toolchain.");
2540 CmdArgs.push_back(
"-lc++");
2541 CmdArgs.push_back(
"-lc++abi");
2542 CmdArgs.push_back(
"-lunwind");
2546 StringRef Component,
2547 bool Shared)
const {
2549 llvm::sys::path::append(Path, SelectedMultilib.
osSuffix(),
"lib" + LibSuffix,
2551 llvm::sys::path::append(Path, Twine(
"libclang_rt." + Component +
"-" +
2552 "mips" + (Shared ?
".so" :
".a")));
2559 const std::string &InstalledDir,
2561 std::string InstallRelDir;
2565 for (
auto &
I : PrefixDirs)
2569 if (
getVFS().
exists(InstallRelDir = InstalledDir +
"/../target"))
2570 return InstallRelDir;
2572 std::string PrefixRelDir = std::string(LLVM_PREFIX) +
"/target";
2573 if (
getVFS().exists(PrefixRelDir))
2574 return PrefixRelDir;
2576 return InstallRelDir;
2581 const ArgList &Args) {
2583 if (Arg *A = Args.getLastArg(options::OPT_G, options::OPT_G_EQ,
2584 options::OPT_msmall_data_threshold_EQ)) {
2586 }
else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2587 options::OPT_fPIC)) {
2592 if (!Gn.getAsInteger(10, G))
2606 for (Arg *A : Args.filtered(options::OPT_L))
2607 for (
const char *
Value : A->getValues())
2608 LibPaths.push_back(
Value);
2613 std::vector<std::string> RootDirs;
2615 std::back_inserter(RootDirs));
2619 if (std::find(RootDirs.begin(), RootDirs.end(), TargetDir) == RootDirs.end())
2620 RootDirs.push_back(TargetDir);
2622 bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
2624 bool HasG0 = Args.hasArg(options::OPT_shared);
2626 HasG0 = G.getValue() == 0;
2629 for (
auto &Dir : RootDirs) {
2630 std::string LibDir = Dir +
"/hexagon/lib";
2631 std::string LibDirCpu = LibDir +
'/' + CpuVer;
2634 LibPaths.push_back(LibDirCpu +
"/G0/pic");
2635 LibPaths.push_back(LibDirCpu +
"/G0");
2637 LibPaths.push_back(LibDirCpu);
2638 LibPaths.push_back(LibDir);
2643 const llvm::opt::ArgList &Args)
2644 :
Linux(D, Triple, Args) {
2650 const std::string BinDir(TargetDir +
"/bin");
2674 ArgStringList &CC1Args)
const {
2675 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2676 DriverArgs.hasArg(options::OPT_nostdlibinc))
2686 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2687 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2688 DriverArgs.hasArg(options::OPT_nostdincxx))
2698 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
2702 StringRef
Value = A->getValue();
2703 if (Value !=
"libstdc++")
2704 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
2714 return "hexagonv60";
2718 Arg *CpuArg =
nullptr;
2719 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ, options::OPT_march_EQ))
2722 StringRef CPU = CpuArg ? CpuArg->getValue() :
GetDefaultCPU();
2723 if (CPU.startswith(
"hexagon"))
2724 return CPU.substr(
sizeof(
"hexagon") - 1);
2731 const ArgList &Args)
2741 const ArgList &Args)
2757 std::string ProgPath(
getDriver().Dir +
"/../");
2760 std::string ToolPath(
getDriver().ResourceDir +
"/lib/");
2762 switch (Triple.getArch()) {
2763 case llvm::Triple::x86:
2764 file_paths.push_back(FilePath +
"x86_64-nacl/lib32");
2765 file_paths.push_back(FilePath +
"i686-nacl/usr/lib");
2766 prog_paths.push_back(ProgPath +
"x86_64-nacl/bin");
2767 file_paths.push_back(ToolPath +
"i686-nacl");
2769 case llvm::Triple::x86_64:
2770 file_paths.push_back(FilePath +
"x86_64-nacl/lib");
2771 file_paths.push_back(FilePath +
"x86_64-nacl/usr/lib");
2772 prog_paths.push_back(ProgPath +
"x86_64-nacl/bin");
2773 file_paths.push_back(ToolPath +
"x86_64-nacl");
2775 case llvm::Triple::arm:
2776 file_paths.push_back(FilePath +
"arm-nacl/lib");
2777 file_paths.push_back(FilePath +
"arm-nacl/usr/lib");
2778 prog_paths.push_back(ProgPath +
"arm-nacl/bin");
2779 file_paths.push_back(ToolPath +
"arm-nacl");
2781 case llvm::Triple::mipsel:
2782 file_paths.push_back(FilePath +
"mipsel-nacl/lib");
2783 file_paths.push_back(FilePath +
"mipsel-nacl/usr/lib");
2784 prog_paths.push_back(ProgPath +
"bin");
2785 file_paths.push_back(ToolPath +
"mipsel-nacl");
2791 NaClArmMacrosPath =
GetFilePath(
"nacl-arm-macros.s");
2795 ArgStringList &CC1Args)
const {
2797 if (DriverArgs.hasArg(options::OPT_nostdinc))
2800 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2802 llvm::sys::path::append(P,
"include");
2806 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2811 case llvm::Triple::x86:
2815 llvm::sys::path::append(P,
"i686-nacl/usr/include");
2817 llvm::sys::path::remove_filename(P);
2818 llvm::sys::path::remove_filename(P);
2819 llvm::sys::path::remove_filename(P);
2820 llvm::sys::path::append(P,
"x86_64-nacl/include");
2823 case llvm::Triple::arm:
2824 llvm::sys::path::append(P,
"arm-nacl/usr/include");
2826 case llvm::Triple::x86_64:
2827 llvm::sys::path::append(P,
"x86_64-nacl/usr/include");
2829 case llvm::Triple::mipsel:
2830 llvm::sys::path::append(P,
"mipsel-nacl/usr/include");
2837 llvm::sys::path::remove_filename(P);
2838 llvm::sys::path::remove_filename(P);
2839 llvm::sys::path::append(P,
"include");
2844 ArgStringList &CmdArgs)
const {
2848 CmdArgs.push_back(
"-lc++");
2852 ArgStringList &CC1Args)
const {
2854 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2855 DriverArgs.hasArg(options::OPT_nostdincxx))
2864 case llvm::Triple::arm:
2865 llvm::sys::path::append(P,
"arm-nacl/include/c++/v1");
2868 case llvm::Triple::x86:
2869 llvm::sys::path::append(P,
"x86_64-nacl/include/c++/v1");
2872 case llvm::Triple::x86_64:
2873 llvm::sys::path::append(P,
"x86_64-nacl/include/c++/v1");
2876 case llvm::Triple::mipsel:
2877 llvm::sys::path::append(P,
"mipsel-nacl/include/c++/v1");
2887 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2888 StringRef
Value = A->getValue();
2889 if (Value ==
"libc++")
2891 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
2901 if (TheTriple.getArch() == llvm::Triple::arm &&
2902 TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
2903 TheTriple.setEnvironment(llvm::Triple::GNUEABIHF);
2904 return TheTriple.getTriple();
2923 const ArgList &Args)
2928 Path +=
"/../libexec";
2945 const ArgList &Args)
2948 llvm::sys::path::append(P,
"..",
getTriple().str(),
"lib");
2953 ArgStringList &CC1Args)
const {
2954 if (DriverArgs.hasArg(options::OPT_nostdlibinc) &&
2955 DriverArgs.hasArg(options::OPT_nostdincxx))
2959 llvm::sys::path::append(P,
"..",
getTriple().str(),
"include/c++/v1");
2964 ArgStringList &CmdArgs)
const {
2965 CmdArgs.push_back(
"-lc++");
2966 CmdArgs.push_back(
"-lc++abi");
2967 CmdArgs.push_back(
"-lunwind");
2977 const ArgList &Args)
3004 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
3005 StringRef
Value = A->getValue();
3006 if (Value ==
"libstdc++")
3008 if (Value ==
"libc++")
3011 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3017 ArgStringList &CC1Args)
const {
3018 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3019 DriverArgs.hasArg(options::OPT_nostdincxx))
3025 getDriver().SysRoot +
"/usr/include/c++/v1");
3029 getDriver().SysRoot +
"/usr/include/c++/stdc++");
3031 getDriver().SysRoot +
"/usr/include/c++/stdc++/backward");
3034 if (Triple.startswith(
"amd64"))
3040 "/usr/include/c++/stdc++/" +
3047 ArgStringList &CmdArgs)
const {
3050 CmdArgs.push_back(
"-lc++");
3051 CmdArgs.push_back(
"-lc++abi");
3052 CmdArgs.push_back(
"-lpthread");
3055 CmdArgs.push_back(
"-lstdc++");
3063 const ArgList &Args)
3068 if ((Triple.getArch() == llvm::Triple::x86 ||
3069 Triple.getArch() == llvm::Triple::ppc) &&
3077 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
3078 StringRef
Value = A->getValue();
3079 if (Value ==
"libstdc++")
3081 if (Value ==
"libc++")
3084 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3086 if (
getTriple().getOSMajorVersion() >= 10)
3092 ArgStringList &CC1Args)
const {
3093 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3094 DriverArgs.hasArg(options::OPT_nostdincxx))
3100 getDriver().SysRoot +
"/usr/include/c++/v1");
3104 getDriver().SysRoot +
"/usr/include/c++/4.2");
3106 getDriver().SysRoot +
"/usr/include/c++/4.2/backward");
3112 ArgStringList &CmdArgs)
const {
3114 bool Profiling = Args.hasArg(options::OPT_pg);
3118 CmdArgs.push_back(Profiling ?
"-lc++_p" :
"-lc++");
3122 CmdArgs.push_back(Profiling ?
"-lstdc++_p" :
"-lstdc++");
3136 case llvm::Triple::GNUEABIHF:
3137 case llvm::Triple::GNUEABI:
3138 case llvm::Triple::EABI:
3152 const bool IsX86 =
getTriple().getArch() == llvm::Triple::x86;
3153 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
3154 const bool IsMIPS64 =
getTriple().getArch() == llvm::Triple::mips64 ||
3155 getTriple().getArch() == llvm::Triple::mips64el;
3157 Res |= SanitizerKind::Address;
3158 Res |= SanitizerKind::Vptr;
3159 if (IsX86_64 || IsMIPS64) {
3160 Res |= SanitizerKind::Leak;
3161 Res |= SanitizerKind::Thread;
3163 if (IsX86 || IsX86_64) {
3164 Res |= SanitizerKind::SafeStack;
3180 switch (Triple.getArch()) {
3181 case llvm::Triple::x86:
3184 case llvm::Triple::arm:
3185 case llvm::Triple::armeb:
3186 case llvm::Triple::thumb:
3187 case llvm::Triple::thumbeb:
3188 switch (Triple.getEnvironment()) {
3189 case llvm::Triple::EABI:
3190 case llvm::Triple::GNUEABI:
3193 case llvm::Triple::EABIHF:
3194 case llvm::Triple::GNUEABIHF:
3202 case llvm::Triple::mips64:
3203 case llvm::Triple::mips64el:
3209 case llvm::Triple::ppc:
3212 case llvm::Triple::sparc:
3230 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
3231 StringRef
Value = A->getValue();
3232 if (Value ==
"libstdc++")
3234 if (Value ==
"libc++")
3237 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
3240 unsigned Major, Minor, Micro;
3241 getTriple().getOSVersion(Major, Minor, Micro);
3242 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
3244 case llvm::Triple::aarch64:
3245 case llvm::Triple::arm:
3246 case llvm::Triple::armeb:
3247 case llvm::Triple::thumb:
3248 case llvm::Triple::thumbeb:
3249 case llvm::Triple::ppc:
3250 case llvm::Triple::ppc64:
3251 case llvm::Triple::ppc64le:
3252 case llvm::Triple::sparc:
3253 case llvm::Triple::sparcv9:
3254 case llvm::Triple::x86:
3255 case llvm::Triple::x86_64:
3265 ArgStringList &CC1Args)
const {
3266 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3267 DriverArgs.hasArg(options::OPT_nostdincxx))
3273 getDriver().SysRoot +
"/usr/include/c++/");
3277 getDriver().SysRoot +
"/usr/include/g++");
3279 getDriver().SysRoot +
"/usr/include/g++/backward");
3301 Paths.push_back(Path.str());
3307 const ArgList &Args)
3322 std::string LibPath =
"/usr/lib/";
3323 switch (Triple.getArch()) {
3324 case llvm::Triple::x86:
3325 case llvm::Triple::sparc:
3327 case llvm::Triple::x86_64:
3328 LibPath +=
"amd64/";
3330 case llvm::Triple::sparcv9:
3331 LibPath +=
"sparcv9/";
3334 llvm_unreachable(
"Unsupported architecture");
3347 ArgStringList &CC1Args)
const {
3348 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3349 DriverArgs.hasArg(options::OPT_nostdincxx))
3354 addSystemInclude(DriverArgs, CC1Args,
"/usr/include/c++/v1/support/solaris");
3362 "/include/c++/" + Version.
Text);
3365 "." + Version.
MinorStr +
"/include/c++/" +
3366 Version.
Text +
"/" +
3425 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
3426 llvm::MemoryBuffer::getFile(
"/etc/lsb-release");
3428 StringRef Data = File.get()->getBuffer();
3430 Data.split(Lines,
"\n");
3432 for (StringRef
Line : Lines)
3434 Version = llvm::StringSwitch<Distro>(
Line.substr(17))
3456 File = llvm::MemoryBuffer::getFile(
"/etc/redhat-release");
3458 StringRef Data = File.get()->getBuffer();
3459 if (Data.startswith(
"Fedora release"))
3461 if (Data.startswith(
"Red Hat Enterprise Linux") ||
3462 Data.startswith(
"CentOS")) {
3463 if (Data.find(
"release 7") != StringRef::npos)
3465 else if (Data.find(
"release 6") != StringRef::npos)
3467 else if (Data.find(
"release 5") != StringRef::npos)
3469 else if (Data.find(
"release 4") != StringRef::npos)
3475 File = llvm::MemoryBuffer::getFile(
"/etc/debian_version");
3477 StringRef Data = File.get()->getBuffer();
3480 else if (Data.startswith(
"squeeze/sid") || Data[0] ==
'6')
3482 else if (Data.startswith(
"wheezy/sid") || Data[0] ==
'7')
3484 else if (Data.startswith(
"jessie/sid") || Data[0] ==
'8')
3486 else if (Data.startswith(
"stretch/sid") || Data[0] ==
'9')
3510 const llvm::Triple &TargetTriple,
3511 StringRef SysRoot) {
3512 llvm::Triple::EnvironmentType TargetEnvironment =
3513 TargetTriple.getEnvironment();
3517 switch (TargetTriple.getArch()) {
3525 case llvm::Triple::arm:
3526 case llvm::Triple::thumb:
3527 if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
3528 if (D.
getVFS().
exists(SysRoot +
"/lib/arm-linux-gnueabihf"))
3529 return "arm-linux-gnueabihf";
3531 if (D.
getVFS().
exists(SysRoot +
"/lib/arm-linux-gnueabi"))
3532 return "arm-linux-gnueabi";
3535 case llvm::Triple::armeb:
3536 case llvm::Triple::thumbeb:
3537 if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
3538 if (D.
getVFS().
exists(SysRoot +
"/lib/armeb-linux-gnueabihf"))
3539 return "armeb-linux-gnueabihf";
3541 if (D.
getVFS().
exists(SysRoot +
"/lib/armeb-linux-gnueabi"))
3542 return "armeb-linux-gnueabi";
3545 case llvm::Triple::x86:
3546 if (D.
getVFS().
exists(SysRoot +
"/lib/i386-linux-gnu"))
3547 return "i386-linux-gnu";
3549 case llvm::Triple::x86_64:
3551 if (TargetEnvironment != llvm::Triple::GNUX32 &&
3553 return "x86_64-linux-gnu";
3555 case llvm::Triple::aarch64:
3556 if (D.
getVFS().
exists(SysRoot +
"/lib/aarch64-linux-gnu"))
3557 return "aarch64-linux-gnu";
3559 case llvm::Triple::aarch64_be:
3560 if (D.
getVFS().
exists(SysRoot +
"/lib/aarch64_be-linux-gnu"))
3561 return "aarch64_be-linux-gnu";
3563 case llvm::Triple::mips:
3564 if (D.
getVFS().
exists(SysRoot +
"/lib/mips-linux-gnu"))
3565 return "mips-linux-gnu";
3567 case llvm::Triple::mipsel:
3568 if (D.
getVFS().
exists(SysRoot +
"/lib/mipsel-linux-gnu"))
3569 return "mipsel-linux-gnu";
3571 case llvm::Triple::mips64:
3572 if (D.
getVFS().
exists(SysRoot +
"/lib/mips64-linux-gnu"))
3573 return "mips64-linux-gnu";
3574 if (D.
getVFS().
exists(SysRoot +
"/lib/mips64-linux-gnuabi64"))
3575 return "mips64-linux-gnuabi64";
3577 case llvm::Triple::mips64el:
3578 if (D.
getVFS().
exists(SysRoot +
"/lib/mips64el-linux-gnu"))
3579 return "mips64el-linux-gnu";
3580 if (D.
getVFS().
exists(SysRoot +
"/lib/mips64el-linux-gnuabi64"))
3581 return "mips64el-linux-gnuabi64";
3583 case llvm::Triple::ppc:
3584 if (D.
getVFS().
exists(SysRoot +
"/lib/powerpc-linux-gnuspe"))
3585 return "powerpc-linux-gnuspe";
3586 if (D.
getVFS().
exists(SysRoot +
"/lib/powerpc-linux-gnu"))
3587 return "powerpc-linux-gnu";
3589 case llvm::Triple::ppc64:
3590 if (D.
getVFS().
exists(SysRoot +
"/lib/powerpc64-linux-gnu"))
3591 return "powerpc64-linux-gnu";
3593 case llvm::Triple::ppc64le:
3594 if (D.
getVFS().
exists(SysRoot +
"/lib/powerpc64le-linux-gnu"))
3595 return "powerpc64le-linux-gnu";
3597 case llvm::Triple::sparc:
3598 if (D.
getVFS().
exists(SysRoot +
"/lib/sparc-linux-gnu"))
3599 return "sparc-linux-gnu";
3601 case llvm::Triple::sparcv9:
3602 if (D.
getVFS().
exists(SysRoot +
"/lib/sparc64-linux-gnu"))
3603 return "sparc64-linux-gnu";
3605 case llvm::Triple::systemz:
3606 if (D.
getVFS().
exists(SysRoot +
"/lib/s390x-linux-gnu"))
3607 return "s390x-linux-gnu";
3610 return TargetTriple.str();
3613 static StringRef
getOSLibDir(
const llvm::Triple &Triple,
const ArgList &Args) {
3620 return Triple.isArch32Bit() ?
"lib" :
"lib64";
3632 if (Triple.getArch() == llvm::Triple::x86 ||
3633 Triple.getArch() == llvm::Triple::ppc)
3636 if (Triple.getArch() == llvm::Triple::x86_64 &&
3637 Triple.getEnvironment() == llvm::Triple::GNUX32)
3640 return Triple.isArch32Bit() ?
"lib" :
"lib64";
3648 llvm::Triple::ArchType Arch = Triple.getArch();
3671 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
3674 const bool IsAndroid = Triple.isAndroid();
3677 if (IsMips && !SysRoot.empty())
3678 ExtraOpts.push_back(
"--sysroot=" + SysRoot);
3685 if (!IsMips && !IsAndroid) {
3688 ExtraOpts.push_back(
"--hash-style=gnu");
3692 ExtraOpts.push_back(
"--hash-style=both");
3704 ExtraOpts.push_back(
"--enable-new-dtags");
3713 const std::string OSLibDir =
getOSLibDir(Triple, Args);
3758 if (StringRef(LibPath).startswith(SysRoot)) {
3769 if (StringRef(D.
Dir).startswith(SysRoot)) {
3784 "/../../" + OSLibDir,
3791 BiarchSibling.gccSuffix(),
3806 if (StringRef(LibPath).startswith(SysRoot))
3815 if (StringRef(D.
Dir).startswith(SysRoot))
3835 return std::string();
3846 (InstallDir +
"/../../../../" + TripleStr +
"/libc" + Multilib.
osSuffix())
3852 Path = (InstallDir +
"/../../../../sysroot" + Multilib.
osSuffix()).str();
3857 return std::string();
3861 ArgStringList &CC1Args)
const {
3865 if (DriverArgs.hasArg(options::OPT_nostdinc))
3868 if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
3871 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
3873 llvm::sys::path::append(P,
"include");
3877 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
3881 StringRef CIncludeDirs(C_INCLUDE_DIRS);
3882 if (CIncludeDirs !=
"") {
3884 CIncludeDirs.split(dirs,
":");
3885 for (StringRef dir : dirs) {
3887 llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) :
"";
3903 for (
const auto &Path : IncludePaths)
3909 const StringRef X86_64MultiarchIncludeDirs[] = {
3910 "/usr/include/x86_64-linux-gnu",
3915 "/usr/include/i686-linux-gnu/64",
"/usr/include/i486-linux-gnu/64"};
3916 const StringRef X86MultiarchIncludeDirs[] = {
3917 "/usr/include/i386-linux-gnu",
3922 "/usr/include/x86_64-linux-gnu/32",
"/usr/include/i686-linux-gnu",
3923 "/usr/include/i486-linux-gnu"};
3924 const StringRef AArch64MultiarchIncludeDirs[] = {
3925 "/usr/include/aarch64-linux-gnu"};
3926 const StringRef ARMMultiarchIncludeDirs[] = {
3927 "/usr/include/arm-linux-gnueabi"};
3928 const StringRef ARMHFMultiarchIncludeDirs[] = {
3929 "/usr/include/arm-linux-gnueabihf"};
3930 const StringRef ARMEBMultiarchIncludeDirs[] = {
3931 "/usr/include/armeb-linux-gnueabi"};
3932 const StringRef ARMEBHFMultiarchIncludeDirs[] = {
3933 "/usr/include/armeb-linux-gnueabihf"};
3934 const StringRef MIPSMultiarchIncludeDirs[] = {
"/usr/include/mips-linux-gnu"};
3935 const StringRef MIPSELMultiarchIncludeDirs[] = {
3936 "/usr/include/mipsel-linux-gnu"};
3937 const StringRef MIPS64MultiarchIncludeDirs[] = {
3938 "/usr/include/mips64-linux-gnu",
"/usr/include/mips64-linux-gnuabi64"};
3939 const StringRef MIPS64ELMultiarchIncludeDirs[] = {
3940 "/usr/include/mips64el-linux-gnu",
3941 "/usr/include/mips64el-linux-gnuabi64"};
3942 const StringRef PPCMultiarchIncludeDirs[] = {
3943 "/usr/include/powerpc-linux-gnu"};
3944 const StringRef PPC64MultiarchIncludeDirs[] = {
3945 "/usr/include/powerpc64-linux-gnu"};
3946 const StringRef PPC64LEMultiarchIncludeDirs[] = {
3947 "/usr/include/powerpc64le-linux-gnu"};
3948 const StringRef SparcMultiarchIncludeDirs[] = {
3949 "/usr/include/sparc-linux-gnu"};
3950 const StringRef Sparc64MultiarchIncludeDirs[] = {
3951 "/usr/include/sparc64-linux-gnu"};
3952 const StringRef SYSTEMZMultiarchIncludeDirs[] = {
3953 "/usr/include/s390x-linux-gnu"};
3956 case llvm::Triple::x86_64:
3957 MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
3959 case llvm::Triple::x86:
3960 MultiarchIncludeDirs = X86MultiarchIncludeDirs;
3962 case llvm::Triple::aarch64:
3963 case llvm::Triple::aarch64_be:
3964 MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
3966 case llvm::Triple::arm:
3967 case llvm::Triple::thumb:
3968 if (
getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
3969 MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
3971 MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
3973 case llvm::Triple::armeb:
3974 case llvm::Triple::thumbeb:
3975 if (
getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
3976 MultiarchIncludeDirs = ARMEBHFMultiarchIncludeDirs;
3978 MultiarchIncludeDirs = ARMEBMultiarchIncludeDirs;
3980 case llvm::Triple::mips:
3981 MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
3983 case llvm::Triple::mipsel:
3984 MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
3986 case llvm::Triple::mips64:
3987 MultiarchIncludeDirs = MIPS64MultiarchIncludeDirs;
3989 case llvm::Triple::mips64el:
3990 MultiarchIncludeDirs = MIPS64ELMultiarchIncludeDirs;
3992 case llvm::Triple::ppc:
3993 MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
3995 case llvm::Triple::ppc64:
3996 MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
3998 case llvm::Triple::ppc64le:
3999 MultiarchIncludeDirs = PPC64LEMultiarchIncludeDirs;
4001 case llvm::Triple::sparc:
4002 MultiarchIncludeDirs = SparcMultiarchIncludeDirs;
4004 case llvm::Triple::sparcv9:
4005 MultiarchIncludeDirs = Sparc64MultiarchIncludeDirs;
4007 case llvm::Triple::systemz:
4008 MultiarchIncludeDirs = SYSTEMZMultiarchIncludeDirs;
4013 for (StringRef Dir : MultiarchIncludeDirs) {
4035 std::string MaxVersionString =
"";
4036 for (llvm::sys::fs::directory_iterator LI(base, EC), LE; !EC && LI != LE;
4037 LI = LI.increment(EC)) {
4038 StringRef VersionText = llvm::sys::path::filename(LI->path());
4040 if (VersionText[0] ==
'v' &&
4041 !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
4042 if (Version > MaxVersion) {
4043 MaxVersion = Version;
4044 MaxVersionString = VersionText;
4048 return MaxVersion ? (base +
"/" + MaxVersionString).str() :
"";
4052 ArgStringList &CC1Args)
const {
4053 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4054 DriverArgs.hasArg(options::OPT_nostdincxx))
4059 const std::string LibCXXIncludePathCandidates[] = {
4066 for (
const auto &IncludePath : LibCXXIncludePathCandidates) {
4067 if (IncludePath.empty() || !
getVFS().
exists(IncludePath))
4090 const std::string TargetMultiarchTriple =
4096 "/c++/" + Version.
Text, TripleStr,
4097 GCCMultiarchTriple, TargetMultiarchTriple,
4103 const std::string LibStdCXXIncludePathCandidates[] = {
4106 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr +
"." +
4108 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr,
4110 LibDir.str() +
"/../" + TripleStr.str() +
"/include/c++/" + Version.
Text,
4113 LibDir.str() +
"/../include/c++",
4116 for (
const auto &IncludePath : LibStdCXXIncludePathCandidates) {
4126 ArgStringList &CC1Args)
const {
4127 if (DriverArgs.hasArg(options::OPT_nocudainc))
4132 CC1Args.push_back(
"-include");
4133 CC1Args.push_back(
"__clang_cuda_runtime_wrapper.h");
4140 const bool IsX86 =
getTriple().getArch() == llvm::Triple::x86;
4141 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
4142 const bool IsMIPS64 =
getTriple().getArch() == llvm::Triple::mips64 ||
4143 getTriple().getArch() == llvm::Triple::mips64el;
4144 const bool IsPowerPC64 =
getTriple().getArch() == llvm::Triple::ppc64 ||
4145 getTriple().getArch() == llvm::Triple::ppc64le;
4146 const bool IsAArch64 =
getTriple().getArch() == llvm::Triple::aarch64 ||
4147 getTriple().getArch() == llvm::Triple::aarch64_be;
4149 Res |= SanitizerKind::Address;
4150 Res |= SanitizerKind::KernelAddress;
4151 Res |= SanitizerKind::Vptr;
4152 Res |= SanitizerKind::SafeStack;
4153 if (IsX86_64 || IsMIPS64 || IsAArch64)
4154 Res |= SanitizerKind::DataFlow;
4155 if (IsX86_64 || IsMIPS64 || IsAArch64)
4156 Res |= SanitizerKind::Leak;
4157 if (IsX86_64 || IsMIPS64 || IsAArch64 || IsPowerPC64)
4158 Res |= SanitizerKind::Thread;
4159 if (IsX86_64 || IsMIPS64 || IsPowerPC64 || IsAArch64)
4160 Res |= SanitizerKind::Memory;
4161 if (IsX86 || IsX86_64) {
4162 Res |= SanitizerKind::Function;
4168 llvm::opt::ArgStringList &CmdArgs)
const {
4173 if (!Args.hasArg(options::OPT_coverage))
4174 CmdArgs.push_back(Args.MakeArgString(
4175 Twine(
"-u", llvm::getInstrProfRuntimeHookVarName())));
4182 const ArgList &Args)
4208 const ArgList &Args)
4209 :
Linux(D, Triple, Args) {}
4213 llvm::opt::ArgStringList &CC1Args)
const {
4215 CC1Args.push_back(
"-fcuda-is-device");
4217 if (DriverArgs.hasArg(options::OPT_nocudalib))
4221 DriverArgs.getLastArgValue(options::OPT_march_EQ));
4222 if (!LibDeviceFile.empty()) {
4223 CC1Args.push_back(
"-mlink-cuda-bitcode");
4224 CC1Args.push_back(DriverArgs.MakeArgString(LibDeviceFile));
4229 CC1Args.push_back(
"-target-feature");
4230 CC1Args.push_back(
"+ptx42");
4234 llvm::opt::DerivedArgList *
4236 const char *BoundArch)
const {
4237 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
4240 for (Arg *A : Args) {
4241 if (A->getOption().matches(options::OPT_Xarch__)) {
4243 if (A->getValue(0) != StringRef(BoundArch))
4246 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
4247 unsigned Prev = Index;
4248 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
4258 if (!XarchArg || Index > Prev + 1) {
4259 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
4260 << A->getAsString(Args);
4263 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
4264 << A->getAsString(Args);
4267 XarchArg->setBaseArg(A);
4268 A = XarchArg.release();
4269 DAL->AddSynthesizedArg(A);
4274 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_march_EQ), BoundArch);
4280 const ArgList &Args)
4304 ArgStringList &CC1Args)
const {
4305 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
4306 DriverArgs.hasArg(options::OPT_nostdlibinc))
4308 if (
const char *cl_include_dir = getenv(
"XCC_C_INCLUDE_PATH")) {
4310 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,
'\0'};
4311 StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
4318 ArgStringList &CC1Args)
const {
4319 CC1Args.push_back(
"-nostdsysteminc");
4323 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
4324 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
4325 DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4326 DriverArgs.hasArg(options::OPT_nostdincxx))
4328 if (
const char *cl_include_dir = getenv(
"XCC_CPLUS_INCLUDE_PATH")) {
4330 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,
'\0'};
4331 StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
4338 ArgStringList &CmdArgs)
const {
4343 const ArgList &Args)
4351 switch (Triple.getArch()) {
4353 D.
Diag(diag::err_target_unsupported_arch) << Triple.getArchName()
4355 case llvm::Triple::sparc:
4356 case llvm::Triple::sparcel:
4357 case llvm::Triple::shave:
4365 if (Triple.getArch() == llvm::Triple::sparcel)
4366 llvm::sys::path::append(LibDir,
"../sparc-myriad-elf/lib/le");
4368 llvm::sys::path::append(LibDir,
"../sparc-myriad-elf/lib");
4376 if (Triple.getArch() == llvm::Triple::sparcel)
4377 llvm::sys::path::append(CompilerSupportDir,
"le");
4385 ArgStringList &CC1Args)
const {
4386 if (!DriverArgs.hasArg(options::OPT_nostdinc))
4391 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
4392 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
4393 DriverArgs.hasArg(options::OPT_nostdincxx))
4403 LibDir.str() +
"/../" + TripleStr.str() +
"/include/c++/" + Version.
Text,
4404 "", TripleStr,
"",
"", Multilib.
includeSuffix(), DriverArgs, CC1Args);
4418 return Compiler.get();
4422 return Assembler.get();
4433 const llvm::opt::ArgList &Args)
4439 bool WebAssembly::IsMathErrnoDefault()
const {
return false; }
4441 bool WebAssembly::IsObjCNonFragileABIDefault()
const {
return true; }
4443 bool WebAssembly::UseObjCMixedDispatch()
const {
return true; }
4445 bool WebAssembly::isPICDefault()
const {
return false; }
4447 bool WebAssembly::isPIEDefault()
const {
return false; }
4449 bool WebAssembly::isPICDefaultForced()
const {
return false; }
4451 bool WebAssembly::IsIntegratedAssemblerDefault()
const {
return true; }
4454 bool WebAssembly::SupportsObjCGC()
const {
return false; }
4456 bool WebAssembly::hasBlocksRuntime()
const {
return false; }
4459 bool WebAssembly::SupportsProfiling()
const {
return false; }
4461 bool WebAssembly::HasNativeLLVMSupport()
const {
return true; }
4463 void WebAssembly::addClangTargetOptions(
const ArgList &DriverArgs,
4464 ArgStringList &CC1Args)
const {
4465 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
4466 options::OPT_fno_use_init_array,
true))
4467 CC1Args.push_back(
"-fuse-init-array");
4470 Tool *WebAssembly::buildLinker()
const {
4476 if (Args.hasArg(options::OPT_static))
4477 D.
Diag(diag::err_drv_unsupported_opt_for_target) <<
"-static" <<
"PS4";
4484 if (
const char *EnvValue = getenv(
"SCE_PS4_SDK_DIR")) {
4485 if (!llvm::sys::fs::exists(EnvValue))
4486 getDriver().
Diag(clang::diag::warn_drv_ps4_sdk_dir) << EnvValue;
4487 PS4SDKDir = EnvValue;
4490 llvm::sys::path::append(PS4SDKDir,
"/../../");
4497 std::string PrefixDir;
4498 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4499 PrefixDir = A->getValue();
4500 if (!llvm::sys::fs::exists(PrefixDir))
4501 getDriver().
Diag(clang::diag::warn_missing_sysroot) << PrefixDir;
4503 PrefixDir = PS4SDKDir.str();
4506 llvm::sys::path::append(PS4SDKIncludeDir,
"target/include");
4507 if (!Args.hasArg(options::OPT_nostdinc) &&
4508 !Args.hasArg(options::OPT_nostdlibinc) &&
4509 !Args.hasArg(options::OPT_isysroot) &&
4510 !Args.hasArg(options::OPT__sysroot_EQ) &&
4511 !llvm::sys::fs::exists(PS4SDKIncludeDir)) {
4512 getDriver().
Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
4513 <<
"PS4 system headers" << PS4SDKIncludeDir;
4517 llvm::sys::path::append(PS4SDKLibDir,
"target/lib");
4518 if (!Args.hasArg(options::OPT_nostdlib) &&
4519 !Args.hasArg(options::OPT_nodefaultlibs) &&
4520 !Args.hasArg(options::OPT__sysroot_EQ) && !Args.hasArg(options::OPT_E) &&
4521 !Args.hasArg(options::OPT_c) && !Args.hasArg(options::OPT_S) &&
4522 !Args.hasArg(options::OPT_emit_ast) &&
4523 !llvm::sys::fs::exists(PS4SDKLibDir)) {
4524 getDriver().
Diag(clang::diag::warn_drv_unable_to_find_directory_expected)
4525 <<
"PS4 system libraries" << PS4SDKLibDir;
4543 Res |= SanitizerKind::Address;
4544 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 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
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.
'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?
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.
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 & includeDirsCallback() const
std::string ResourceDir
The path to the compiler resource directory.