13 #include "clang/Config/config.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/SmallString.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/StringSwitch.h"
23 #include "llvm/Option/Arg.h"
24 #include "llvm/Option/ArgList.h"
25 #include "llvm/Option/OptTable.h"
26 #include "llvm/Option/Option.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/FileSystem.h"
29 #include "llvm/Support/MemoryBuffer.h"
30 #include "llvm/Support/Path.h"
31 #include "llvm/Support/Program.h"
32 #include "llvm/Support/TargetParser.h"
33 #include "llvm/Support/raw_ostream.h"
35 #include <system_error>
37 using namespace clang::driver;
38 using namespace clang::driver::toolchains;
39 using namespace clang;
40 using namespace llvm::opt;
52 :
MachO(D, Triple, Args), TargetInitialized(
false) {}
58 if (Ty == types::TY_PP_Asm)
90 return llvm::StringSwitch<const char *>(Arch)
91 .Case(
"armv6k",
"armv6")
92 .Case(
"armv6m",
"armv6m")
93 .Case(
"armv5tej",
"armv5")
94 .Case(
"xscale",
"xscale")
95 .Case(
"armv4t",
"armv4t")
96 .Case(
"armv7",
"armv7")
97 .Cases(
"armv7a",
"armv7-a",
"armv7")
98 .Cases(
"armv7r",
"armv7-r",
"armv7")
99 .Cases(
"armv7em",
"armv7e-m",
"armv7em")
100 .Cases(
"armv7k",
"armv7-k",
"armv7k")
101 .Cases(
"armv7m",
"armv7-m",
"armv7m")
102 .Cases(
"armv7s",
"armv7-s",
"armv7s")
107 unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(CPU);
108 if (ArchKind == llvm::ARM::AK_INVALID)
110 StringRef Arch = llvm::ARMTargetParser::getArchName(ArchKind);
114 if (Arch.startswith(
"armv5"))
115 Arch = Arch.substr(0, 5);
117 else if (Arch.startswith(
"armv6") && !Arch.endswith(
"6m"))
118 Arch = Arch.substr(0, 5);
120 else if (Arch.endswith(
"v7a"))
121 Arch = Arch.substr(0, 5);
126 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
127 options::OPT_mfloat_abi_EQ);
131 return A->getOption().matches(options::OPT_msoft_float) ||
132 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
133 A->getValue() == StringRef(
"soft"));
141 case llvm::Triple::aarch64:
144 case llvm::Triple::thumb:
145 case llvm::Triple::arm: {
146 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
150 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
167 return Triple.getTriple();
177 return Triple.getTriple();
182 Triple.setOSName(Str);
184 return Triple.getTriple();
187 void Generic_ELF::anchor() {}
198 return Dsymutil.get();
202 return VerifyDebug.get();
216 :
Darwin(D, Triple, Args) {}
223 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
224 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
228 CC1Args.push_back(
"-Werror=implicit-function-declaration");
235 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc,
false);
239 ArgStringList &CmdArgs)
const {
250 CmdArgs.push_back(
"-force_load");
252 llvm::sys::path::remove_filename(P);
253 llvm::sys::path::remove_filename(P);
254 llvm::sys::path::append(P,
"lib",
"arc",
"libarclite_");
257 P +=
"iphonesimulator";
264 CmdArgs.push_back(Args.MakeArgString(P));
268 StringRef DarwinLibName,
bool AlwaysLink,
269 bool IsEmbedded,
bool AddRPath)
const {
271 llvm::sys::path::append(Dir,
"lib", IsEmbedded ?
"macho_embedded" :
"darwin");
274 llvm::sys::path::append(P, DarwinLibName);
279 if (AlwaysLink || llvm::sys::fs::exists(P))
280 CmdArgs.push_back(Args.MakeArgString(P));
287 assert(DarwinLibName.endswith(
".dylib") &&
"must be a dynamic library");
291 CmdArgs.push_back(
"-rpath");
292 CmdArgs.push_back(
"@executable_path");
296 CmdArgs.push_back(
"-rpath");
297 CmdArgs.push_back(Args.MakeArgString(Dir));
302 ArgStringList &CmdArgs)
const {
303 if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
305 Args.hasArg(options::OPT_fprofile_generate) ||
306 Args.hasArg(options::OPT_fprofile_generate_EQ) ||
307 Args.hasArg(options::OPT_fprofile_instr_generate) ||
308 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
309 Args.hasArg(options::OPT_fcreate_profile) ||
310 Args.hasArg(options::OPT_coverage)))
322 void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
323 ArgStringList &CmdArgs,
324 StringRef Sanitizer)
const {
325 if (!Args.hasArg(options::OPT_dynamiclib) &&
326 !Args.hasArg(options::OPT_bundle)) {
334 (Twine(
"libclang_rt.") + Sanitizer +
"_" + OS +
"_dynamic.dylib").str(),
341 CmdArgs.push_back(
"-lc++abi");
346 ArgStringList &CmdArgs)
const {
352 getDriver().
Diag(diag::err_drv_unsupported_rtlib_for_platform)
353 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() <<
"darwin";
359 if (Args.hasArg(options::OPT_static) ||
360 Args.hasArg(options::OPT_fapple_kext) ||
361 Args.hasArg(options::OPT_mkernel))
367 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
368 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
374 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
376 AddLinkSanitizerLibArgs(Args, CmdArgs,
"ubsan");
380 CmdArgs.push_back(
"-lSystem");
389 CmdArgs.push_back(
"-lgcc_s.1");
398 CmdArgs.push_back(
"-lgcc_s.10.4");
400 CmdArgs.push_back(
"-lgcc_s.10.5");
420 void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
426 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
428 if (!llvm::sys::fs::exists(A->getValue()))
429 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
431 if (
char *env = ::getenv(
"SDKROOT")) {
434 if (llvm::sys::path::is_absolute(env) && llvm::sys::fs::exists(env) &&
435 StringRef(env) !=
"/") {
436 Args.append(Args.MakeSeparateArg(
437 nullptr, Opts.getOption(options::OPT_isysroot), env));
442 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
443 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ);
445 if (OSXVersion && iOSVersion) {
447 << OSXVersion->getAsString(Args) << iOSVersion->getAsString(Args);
448 iOSVersion =
nullptr;
449 }
else if (!OSXVersion && !iOSVersion) {
452 std::string OSXTarget;
453 std::string iOSTarget;
454 if (
char *env = ::getenv(
"MACOSX_DEPLOYMENT_TARGET"))
456 if (
char *env = ::getenv(
"IPHONEOS_DEPLOYMENT_TARGET"))
462 if (iOSTarget.empty() && OSXTarget.empty() &&
463 Args.hasArg(options::OPT_isysroot)) {
464 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
465 StringRef isysroot = A->getValue();
467 size_t BeginSDK = isysroot.rfind(
"SDKs/");
468 size_t EndSDK = isysroot.rfind(
".sdk");
469 if (BeginSDK != StringRef::npos && EndSDK != StringRef::npos) {
470 StringRef SDK = isysroot.slice(BeginSDK + 5, EndSDK);
473 size_t StartVer = SDK.find_first_of(
"0123456789");
474 size_t EndVer = SDK.find_last_of(
"0123456789");
475 if (StartVer != StringRef::npos && EndVer > StartVer) {
476 StringRef Version = SDK.slice(StartVer, EndVer + 1);
477 if (SDK.startswith(
"iPhoneOS") ||
478 SDK.startswith(
"iPhoneSimulator"))
480 else if (SDK.startswith(
"MacOSX"))
489 if (OSXTarget.empty() && iOSTarget.empty()) {
491 unsigned Major, Minor, Micro;
492 if (MachOArchName ==
"armv7" || MachOArchName ==
"armv7s" ||
493 MachOArchName ==
"arm64") {
494 getTriple().getiOSVersion(Major, Minor, Micro);
495 llvm::raw_string_ostream(iOSTarget) << Major <<
'.' << Minor <<
'.'
497 }
else if (MachOArchName !=
"armv6m" && MachOArchName !=
"armv7m" &&
498 MachOArchName !=
"armv7em") {
499 if (!
getTriple().getMacOSXVersion(Major, Minor, Micro)) {
503 llvm::raw_string_ostream(OSXTarget) << Major <<
'.' << Minor <<
'.'
510 if (!OSXTarget.empty() && !iOSTarget.empty()) {
511 if (
getTriple().getArch() == llvm::Triple::arm ||
512 getTriple().getArch() == llvm::Triple::aarch64 ||
513 getTriple().getArch() == llvm::Triple::thumb)
519 if (!OSXTarget.empty()) {
520 const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
521 OSXVersion = Args.MakeJoinedArg(
nullptr, O, OSXTarget);
522 Args.append(OSXVersion);
523 }
else if (!iOSTarget.empty()) {
524 const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
525 iOSVersion = Args.MakeJoinedArg(
nullptr, O, iOSTarget);
526 Args.append(iOSVersion);
536 llvm_unreachable(
"Unable to infer Darwin variant");
539 unsigned Major, Minor, Micro;
541 if (Platform ==
MacOS) {
542 assert(!iOSVersion &&
"Unknown target platform!");
545 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
547 << OSXVersion->getAsString(Args);
549 assert(iOSVersion &&
"Unknown target platform!");
552 HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
554 << iOSVersion->getAsString(Args);
556 llvm_unreachable(
"unknown kind of Darwin platform");
563 setTarget(Platform, Major, Minor, Micro);
567 ArgStringList &CmdArgs)
const {
572 CmdArgs.push_back(
"-lc++");
582 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
584 llvm::sys::path::append(
P,
"usr",
"lib",
"libstdc++.dylib");
586 if (!llvm::sys::fs::exists(
P)) {
587 llvm::sys::path::remove_filename(
P);
588 llvm::sys::path::append(
P,
"libstdc++.6.dylib");
589 if (llvm::sys::fs::exists(
P)) {
590 CmdArgs.push_back(Args.MakeArgString(
P));
599 if (!llvm::sys::fs::exists(
"/usr/lib/libstdc++.dylib") &&
600 llvm::sys::fs::exists(
"/usr/lib/libstdc++.6.dylib")) {
601 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
606 CmdArgs.push_back(
"-lstdc++");
613 ArgStringList &CmdArgs)
const {
620 llvm::sys::path::append(P,
"lib",
"darwin");
626 llvm::sys::path::append(P,
"libclang_rt.cc_kext.a");
628 llvm::sys::path::append(P,
"libclang_rt.cc_kext_ios5.a");
633 if (llvm::sys::fs::exists(P))
634 CmdArgs.push_back(Args.MakeArgString(P));
638 const char *BoundArch)
const {
639 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
649 for (Arg *A : Args) {
650 if (A->getOption().matches(options::OPT_Xarch__)) {
653 llvm::Triple::ArchType XarchArch =
655 if (!(XarchArch ==
getArch() ||
661 Arg *OriginalArg = A;
662 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
663 unsigned Prev = Index;
664 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
674 if (!XarchArg || Index > Prev + 1) {
675 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
676 << A->getAsString(Args);
679 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
680 << A->getAsString(Args);
684 XarchArg->setBaseArg(A);
686 A = XarchArg.release();
687 DAL->AddSynthesizedArg(A);
694 for (
const char *
Value : A->getValues()) {
696 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
710 case options::OPT_mkernel:
711 case options::OPT_fapple_kext:
713 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
716 case options::OPT_dependency_file:
717 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
720 case options::OPT_gfull:
721 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
723 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
726 case options::OPT_gused:
727 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
729 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
732 case options::OPT_shared:
733 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
736 case options::OPT_fconstant_cfstrings:
737 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
740 case options::OPT_fno_constant_cfstrings:
741 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
744 case options::OPT_Wnonportable_cfstrings:
746 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
749 case options::OPT_Wno_nonportable_cfstrings:
751 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
754 case options::OPT_fpascal_strings:
755 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
758 case options::OPT_fno_pascal_strings:
759 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
764 if (
getTriple().getArch() == llvm::Triple::x86 ||
765 getTriple().getArch() == llvm::Triple::x86_64)
766 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
767 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_mtune_EQ),
773 StringRef Name = BoundArch;
774 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
775 const Option MArch = Opts.getOption(options::OPT_march_EQ);
781 else if (Name ==
"ppc601")
782 DAL->AddJoinedArg(
nullptr, MCpu,
"601");
783 else if (Name ==
"ppc603")
784 DAL->AddJoinedArg(
nullptr, MCpu,
"603");
785 else if (Name ==
"ppc604")
786 DAL->AddJoinedArg(
nullptr, MCpu,
"604");
787 else if (Name ==
"ppc604e")
788 DAL->AddJoinedArg(
nullptr, MCpu,
"604e");
789 else if (Name ==
"ppc750")
790 DAL->AddJoinedArg(
nullptr, MCpu,
"750");
791 else if (Name ==
"ppc7400")
792 DAL->AddJoinedArg(
nullptr, MCpu,
"7400");
793 else if (Name ==
"ppc7450")
794 DAL->AddJoinedArg(
nullptr, MCpu,
"7450");
795 else if (Name ==
"ppc970")
796 DAL->AddJoinedArg(
nullptr, MCpu,
"970");
798 else if (Name ==
"ppc64" || Name ==
"ppc64le")
799 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
801 else if (Name ==
"i386")
803 else if (Name ==
"i486")
804 DAL->AddJoinedArg(
nullptr, MArch,
"i486");
805 else if (Name ==
"i586")
806 DAL->AddJoinedArg(
nullptr, MArch,
"i586");
807 else if (Name ==
"i686")
808 DAL->AddJoinedArg(
nullptr, MArch,
"i686");
809 else if (Name ==
"pentium")
810 DAL->AddJoinedArg(
nullptr, MArch,
"pentium");
811 else if (Name ==
"pentium2")
812 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
813 else if (Name ==
"pentpro")
814 DAL->AddJoinedArg(
nullptr, MArch,
"pentiumpro");
815 else if (Name ==
"pentIIm3")
816 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
818 else if (Name ==
"x86_64")
819 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
820 else if (Name ==
"x86_64h") {
821 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
822 DAL->AddJoinedArg(
nullptr, MArch,
"x86_64h");
825 else if (Name ==
"arm")
826 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
827 else if (Name ==
"armv4t")
828 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
829 else if (Name ==
"armv5")
830 DAL->AddJoinedArg(
nullptr, MArch,
"armv5tej");
831 else if (Name ==
"xscale")
832 DAL->AddJoinedArg(
nullptr, MArch,
"xscale");
833 else if (Name ==
"armv6")
834 DAL->AddJoinedArg(
nullptr, MArch,
"armv6k");
835 else if (Name ==
"armv6m")
836 DAL->AddJoinedArg(
nullptr, MArch,
"armv6m");
837 else if (Name ==
"armv7")
838 DAL->AddJoinedArg(
nullptr, MArch,
"armv7a");
839 else if (Name ==
"armv7em")
840 DAL->AddJoinedArg(
nullptr, MArch,
"armv7em");
841 else if (Name ==
"armv7k")
842 DAL->AddJoinedArg(
nullptr, MArch,
"armv7k");
843 else if (Name ==
"armv7m")
844 DAL->AddJoinedArg(
nullptr, MArch,
"armv7m");
845 else if (Name ==
"armv7s")
846 DAL->AddJoinedArg(
nullptr, MArch,
"armv7s");
853 ArgStringList &CmdArgs)
const {
862 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic.a" :
"_static.a";
868 const char *BoundArch)
const {
880 AddDeploymentTarget(*DAL);
887 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie;) {
890 if (A->getOption().getID() != options::OPT_mkernel &&
891 A->getOption().getID() != options::OPT_fapple_kext)
893 assert(it != ie &&
"unexpected argument translation");
895 assert(A->getOption().getID() == options::OPT_static &&
896 "missing expected -static argument");
897 it = DAL->getArgs().erase(it);
904 !Args.getLastArg(options::OPT_stdlib_EQ))
905 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_stdlib_EQ),
918 if (where != StringRef()) {
919 getDriver().
Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
927 return getArch() == llvm::Triple::x86_64;
931 if (
const char *
S = ::getenv(
"RC_DEBUG_OPTIONS"))
947 return (
getArch() == llvm::Triple::x86_64 ||
948 getArch() == llvm::Triple::aarch64);
953 return getArch() == llvm::Triple::x86 ||
getArch() == llvm::Triple::x86_64;
957 ArgStringList &CmdArgs)
const {
961 CmdArgs.push_back(
"-ios_simulator_version_min");
963 CmdArgs.push_back(
"-iphoneos_version_min");
966 CmdArgs.push_back(
"-macosx_version_min");
969 CmdArgs.push_back(Args.MakeArgString(TargetVersion.
getAsString()));
973 ArgStringList &CmdArgs)
const {
975 if (Args.hasArg(options::OPT_dynamiclib)) {
981 CmdArgs.push_back(
"-ldylib1.o");
984 CmdArgs.push_back(
"-ldylib1.o");
986 CmdArgs.push_back(
"-ldylib1.10.5.o");
989 if (Args.hasArg(options::OPT_bundle)) {
990 if (!Args.hasArg(options::OPT_static)) {
996 CmdArgs.push_back(
"-lbundle1.o");
999 CmdArgs.push_back(
"-lbundle1.o");
1004 if (Args.hasArg(options::OPT_static) ||
1005 Args.hasArg(options::OPT_object) ||
1006 Args.hasArg(options::OPT_preload)) {
1007 CmdArgs.push_back(
"-lgcrt0.o");
1009 CmdArgs.push_back(
"-lgcrt1.o");
1019 CmdArgs.push_back(
"-no_new_main");
1021 if (Args.hasArg(options::OPT_static) ||
1022 Args.hasArg(options::OPT_object) ||
1023 Args.hasArg(options::OPT_preload)) {
1024 CmdArgs.push_back(
"-lcrt0.o");
1030 if (
getArch() == llvm::Triple::aarch64)
1033 CmdArgs.push_back(
"-lcrt1.o");
1035 CmdArgs.push_back(
"-lcrt1.3.1.o");
1038 CmdArgs.push_back(
"-lcrt1.o");
1040 CmdArgs.push_back(
"-lcrt1.10.5.o");
1042 CmdArgs.push_back(
"-lcrt1.10.6.o");
1053 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
1054 CmdArgs.push_back(Str);
1069 Res |= SanitizerKind::Address;
1072 Res |= SanitizerKind::Vptr;
1073 Res |= SanitizerKind::SafeStack;
1087 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1088 std::pair<StringRef, StringRef> First = VersionText.split(
'.');
1089 std::pair<StringRef, StringRef> Second = First.second.split(
'.');
1091 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1092 if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
1094 GoodVersion.
MajorStr = First.first.str();
1095 if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
1097 GoodVersion.MinorStr = Second.first.str();
1108 StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
1109 if (!PatchText.empty()) {
1110 if (
size_t EndNumber = PatchText.find_first_not_of(
"0123456789")) {
1112 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1113 GoodVersion.Patch < 0)
1115 GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
1125 StringRef RHSPatchSuffix)
const {
1126 if (Major != RHSMajor)
1127 return Major < RHSMajor;
1128 if (Minor != RHSMinor)
1129 return Minor < RHSMinor;
1130 if (Patch != RHSPatch) {
1139 return Patch < RHSPatch;
1141 if (PatchSuffix != RHSPatchSuffix) {
1143 if (RHSPatchSuffix.empty())
1145 if (PatchSuffix.empty())
1149 return PatchSuffix < RHSPatchSuffix;
1157 const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain);
1159 return A->getValue();
1160 return GCC_INSTALL_PREFIX;
1173 const Driver &D,
const llvm::Triple &TargetTriple,
const ArgList &Args) {
1174 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1175 ? TargetTriple.get64BitArchVariant()
1176 : TargetTriple.get32BitArchVariant();
1182 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1183 CandidateTripleAliases, CandidateBiarchLibDirs,
1184 CandidateBiarchTripleAliases);
1191 if (GCCToolchainDir !=
"") {
1192 if (GCCToolchainDir.back() ==
'/')
1193 GCCToolchainDir = GCCToolchainDir.drop_back();
1195 Prefixes.push_back(GCCToolchainDir);
1199 Prefixes.push_back(D.
SysRoot);
1200 Prefixes.push_back(D.
SysRoot +
"/usr");
1208 Prefixes.push_back(
"/usr");
1214 for (
const std::string &Prefix : Prefixes) {
1215 if (!llvm::sys::fs::exists(Prefix))
1217 for (
const StringRef Suffix : CandidateLibDirs) {
1218 const std::string LibDir = Prefix + Suffix.str();
1219 if (!llvm::sys::fs::exists(LibDir))
1221 for (
const StringRef Candidate : CandidateTripleAliases)
1222 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1224 for (
const StringRef Suffix : CandidateBiarchLibDirs) {
1225 const std::string LibDir = Prefix + Suffix.str();
1226 if (!llvm::sys::fs::exists(LibDir))
1228 for (
const StringRef Candidate : CandidateBiarchTripleAliases)
1229 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1236 for (
const auto &InstallPath : CandidateGCCInstallPaths)
1237 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
1239 if (!GCCInstallPath.empty())
1240 OS <<
"Selected GCC installation: " << GCCInstallPath <<
"\n";
1243 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
1245 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
1246 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
1250 if (BiarchSibling.hasValue()) {
1251 M = BiarchSibling.getValue();
1257 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1258 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
1266 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
1267 static const char *
const AArch64Triples[] = {
1268 "aarch64-none-linux-gnu",
"aarch64-linux-gnu",
"aarch64-linux-android",
1269 "aarch64-redhat-linux"};
1270 static const char *
const AArch64beLibDirs[] = {
"/lib"};
1271 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu",
1272 "aarch64_be-linux-gnu"};
1274 static const char *
const ARMLibDirs[] = {
"/lib"};
1275 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi",
1276 "arm-linux-androideabi"};
1277 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
1278 "armv7hl-redhat-linux-gnueabi"};
1279 static const char *
const ARMebLibDirs[] = {
"/lib"};
1280 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi",
1281 "armeb-linux-androideabi"};
1282 static const char *
const ARMebHFTriples[] = {
1283 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
1285 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
1286 static const char *
const X86_64Triples[] = {
1287 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
1288 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
1289 "x86_64-redhat-linux",
"x86_64-suse-linux",
1290 "x86_64-manbo-linux-gnu",
"x86_64-linux-gnu",
1291 "x86_64-slackware-linux",
"x86_64-linux-android",
1292 "x86_64-unknown-linux"};
1293 static const char *
const X32LibDirs[] = {
"/libx32"};
1294 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
1295 static const char *
const X86Triples[] = {
1296 "i686-linux-gnu",
"i686-pc-linux-gnu",
"i486-linux-gnu",
1297 "i386-linux-gnu",
"i386-redhat-linux6E",
"i686-redhat-linux",
1298 "i586-redhat-linux",
"i386-redhat-linux",
"i586-suse-linux",
1299 "i486-slackware-linux",
"i686-montavista-linux",
"i686-linux-android",
1302 static const char *
const MIPSLibDirs[] = {
"/lib"};
1303 static const char *
const MIPSTriples[] = {
1304 "mips-linux-gnu",
"mips-mti-linux-gnu",
"mips-img-linux-gnu"};
1305 static const char *
const MIPSELLibDirs[] = {
"/lib"};
1306 static const char *
const MIPSELTriples[] = {
1307 "mipsel-linux-gnu",
"mipsel-linux-android",
"mips-img-linux-gnu"};
1309 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
1310 static const char *
const MIPS64Triples[] = {
1311 "mips64-linux-gnu",
"mips-mti-linux-gnu",
"mips-img-linux-gnu",
1312 "mips64-linux-gnuabi64"};
1313 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
1314 static const char *
const MIPS64ELTriples[] = {
1315 "mips64el-linux-gnu",
"mips-mti-linux-gnu",
"mips-img-linux-gnu",
1316 "mips64el-linux-android",
"mips64el-linux-gnuabi64"};
1318 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
1319 static const char *
const PPCTriples[] = {
1320 "powerpc-linux-gnu",
"powerpc-unknown-linux-gnu",
"powerpc-linux-gnuspe",
1321 "powerpc-suse-linux",
"powerpc-montavista-linuxspe"};
1322 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
1323 static const char *
const PPC64Triples[] = {
1324 "powerpc64-linux-gnu",
"powerpc64-unknown-linux-gnu",
1325 "powerpc64-suse-linux",
"ppc64-redhat-linux"};
1326 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
1327 static const char *
const PPC64LETriples[] = {
1328 "powerpc64le-linux-gnu",
"powerpc64le-unknown-linux-gnu",
1329 "powerpc64le-suse-linux",
"ppc64le-redhat-linux"};
1331 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
1332 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
1333 "sparcv8-linux-gnu"};
1334 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
1335 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
1336 "sparcv9-linux-gnu"};
1338 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
1339 static const char *
const SystemZTriples[] = {
1340 "s390x-linux-gnu",
"s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
1341 "s390x-suse-linux",
"s390x-redhat-linux"};
1346 switch (TargetTriple.getArch()) {
1347 case llvm::Triple::aarch64:
1348 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1349 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1350 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1351 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1353 case llvm::Triple::aarch64_be:
1354 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1355 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1356 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1357 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1359 case llvm::Triple::arm:
1360 case llvm::Triple::thumb:
1361 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
1362 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1363 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
1365 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
1368 case llvm::Triple::armeb:
1369 case llvm::Triple::thumbeb:
1370 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
1371 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1372 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
1374 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
1377 case llvm::Triple::x86_64:
1378 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1379 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1382 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
1383 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
1384 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1386 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1387 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
1390 case llvm::Triple::x86:
1391 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1392 TripleAliases.append(begin(X86Triples), end(X86Triples));
1393 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1394 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1396 case llvm::Triple::mips:
1397 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1398 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1399 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1400 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1402 case llvm::Triple::mipsel:
1403 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1404 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1405 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1406 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1407 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1409 case llvm::Triple::mips64:
1410 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1411 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1412 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1413 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1415 case llvm::Triple::mips64el:
1416 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1417 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1418 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1419 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1420 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1422 case llvm::Triple::ppc:
1423 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1424 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
1425 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1426 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1428 case llvm::Triple::ppc64:
1429 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1430 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1431 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1432 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
1434 case llvm::Triple::ppc64le:
1435 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
1436 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
1438 case llvm::Triple::sparc:
1439 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1440 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1441 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1442 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1444 case llvm::Triple::sparcv9:
1445 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1446 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1447 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1448 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1450 case llvm::Triple::systemz:
1451 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
1452 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
1463 TripleAliases.push_back(TargetTriple.str());
1466 if (TargetTriple.str() != BiarchTriple.str())
1467 BiarchTripleAliases.push_back(BiarchTriple.str());
1472 class FilterNonExistent {
1476 FilterNonExistent(StringRef
Base) : Base(Base) {}
1477 bool operator()(
const Multilib &M) {
1478 return !llvm::sys::fs::exists(
Base + M.
gccSuffix() +
"/crtbegin.o");
1484 std::vector<std::string> &Flags) {
1486 Flags.push_back(std::string(
"+") + Flag);
1488 Flags.push_back(std::string(
"-") + Flag);
1492 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
1493 Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1497 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel;
1501 return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
1505 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1509 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
1510 return A && A->getOption().matches(options::OPT_mips16);
1514 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
1515 return A && A->getOption().matches(options::OPT_mmicromips);
1531 return Multilib(commonSuffix, commonSuffix, commonSuffix);
1561 FilterNonExistent NonExistent(Path);
1569 .
flag(
"-mmicromips")
1570 .
flag(
"+march=mips32");
1575 .
flag(
"+mmicromips");
1580 .
flag(
"+march=mips64r2");
1588 .
flag(
"-mmicromips")
1589 .
flag(
"+march=mips32r2");
1608 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1620 .
Either(BigEndian, LittleEndian)
1626 StringRef TripleStr,
const Multilib &M) {
1627 std::vector<std::string> Dirs;
1628 Dirs.push_back((InstallDir +
"/include").str());
1629 std::string SysRootInc =
1630 InstallDir.str() +
"/../../../../sysroot";
1632 Dirs.push_back(SysRootInc +
"/uclibc/usr/include");
1634 Dirs.push_back(SysRootInc +
"/usr/include");
1644 auto MArchMicroMips =
1665 .includeSuffix(
"/64")
1672 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
1677 .
Either(BigEndian, LittleEndian)
1683 StringRef TripleStr,
const Multilib &M) {
1684 std::vector<std::string> Dirs;
1685 Dirs.push_back((InstallDir +
"/include").str());
1686 std::string SysRootInc =
1687 InstallDir.str() +
"/../../../../" + TripleStr.str();
1689 Dirs.push_back(SysRootInc +
"/libc/uclibc/usr/include");
1691 Dirs.push_back(SysRootInc +
"/libc/usr/include");
1709 .includeSuffix(
"/64")
1716 DebianMipsMultilibs =
1733 .
Maybe(LittleEndian)
1736 StringRef TripleStr,
const Multilib &M) {
1737 std::vector<std::string> Dirs;
1738 Dirs.push_back((InstallDir +
"/include").str());
1740 (InstallDir +
"/../../../../sysroot/usr/include").str());
1749 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1757 CPUName ==
"mips32r5",
1758 "march=mips32r2", Flags);
1762 CPUName ==
"mips64r5" || CPUName ==
"octeon",
1763 "march=mips64r2", Flags);
1775 if (TargetTriple.getEnvironment() == llvm::Triple::Android) {
1778 Result.
Multilibs = AndroidMipsMultilibs;
1784 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1785 TargetTriple.getOS() == llvm::Triple::Linux &&
1786 TargetTriple.getEnvironment() == llvm::Triple::GNU) {
1797 MultilibSet *candidates[] = {&DebianMipsMultilibs, &FSFMipsMultilibs,
1800 std::begin(candidates), std::end(candidates),
1802 for (
const auto &candidate : candidates) {
1804 if (candidate == &DebianMipsMultilibs)
1827 StringRef Path,
const ArgList &Args,
1828 bool NeedsBiarchSuffix,
1841 .includeSuffix(
"/64")
1847 .includeSuffix(
"/32")
1853 .includeSuffix(
"/x32")
1858 FilterNonExistent NonExistent(Path);
1862 enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
1863 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
1864 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1866 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1868 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1871 if (TargetTriple.isArch32Bit())
1872 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1874 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1876 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1881 else if (Want == WANT64)
1883 else if (Want == WANTX32)
1910 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
1911 const llvm::Triple &TargetTriple,
const ArgList &Args,
1912 const std::string &LibDir, StringRef CandidateTriple,
1913 bool NeedsBiarchSuffix) {
1914 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1918 const std::string LibSuffixes[] = {
1919 "/gcc/" + CandidateTriple.str(),
1921 "/gcc-cross/" + CandidateTriple.str(),
1922 "/" + CandidateTriple.str() +
"/gcc/" + CandidateTriple.str(),
1926 "/" + CandidateTriple.str(),
1932 "/i386-linux-gnu/gcc/" + CandidateTriple.str()};
1933 const std::string InstallSuffixes[] = {
1941 const unsigned NumLibSuffixes =
1942 (llvm::array_lengthof(LibSuffixes) - (TargetArch != llvm::Triple::x86));
1943 for (
unsigned i = 0; i < NumLibSuffixes; ++i) {
1944 StringRef LibSuffix = LibSuffixes[i];
1946 for (llvm::sys::fs::directory_iterator LI(LibDir + LibSuffix, EC), LE;
1947 !EC && LI != LE; LI = LI.increment(EC)) {
1948 StringRef VersionText = llvm::sys::path::filename(LI->path());
1950 if (CandidateVersion.Major != -1)
1951 if (!CandidateGCCInstallPaths.insert(LI->path()).second)
1953 if (CandidateVersion.isOlderThan(4, 1, 1))
1955 if (CandidateVersion <= Version)
1966 NeedsBiarchSuffix, Detected)) {
1973 Version = CandidateVersion;
1974 GCCTriple.setTriple(CandidateTriple);
1978 GCCInstallPath = LibDir + LibSuffixes[i] +
"/" + VersionText.str();
1979 GCCParentLibPath = GCCInstallPath + InstallSuffixes[i];
1986 const ArgList &Args)
2000 return Preprocess.get();
2004 return Compile.get();
2022 return getArch() == llvm::Triple::x86_64;
2037 case llvm::Triple::x86:
2038 case llvm::Triple::x86_64:
2039 case llvm::Triple::aarch64:
2040 case llvm::Triple::aarch64_be:
2041 case llvm::Triple::arm:
2042 case llvm::Triple::armeb:
2043 case llvm::Triple::bpfel:
2044 case llvm::Triple::bpfeb:
2045 case llvm::Triple::thumb:
2046 case llvm::Triple::thumbeb:
2047 case llvm::Triple::ppc:
2048 case llvm::Triple::ppc64:
2049 case llvm::Triple::ppc64le:
2050 case llvm::Triple::sparc:
2051 case llvm::Triple::sparcel:
2052 case llvm::Triple::sparcv9:
2053 case llvm::Triple::systemz:
2061 ArgStringList &CC1Args)
const {
2063 bool UseInitArrayDefault =
2064 getTriple().getArch() == llvm::Triple::aarch64 ||
2065 getTriple().getArch() == llvm::Triple::aarch64_be ||
2066 (
getTriple().getOS() == llvm::Triple::Linux &&
2068 getTriple().getEnvironment() == llvm::Triple::Android)) ||
2069 getTriple().getOS() == llvm::Triple::NaCl;
2071 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2072 options::OPT_fno_use_init_array, UseInitArrayDefault))
2073 CC1Args.push_back(
"-fuse-init-array");
2079 const ArgList &Args) {
2084 if (!GccToolchain.empty())
2085 return GccToolchain;
2087 std::string InstallRelDir = InstalledDir +
"/../../gnu";
2088 if (llvm::sys::fs::exists(InstallRelDir))
2089 return InstallRelDir;
2091 std::string PrefixRelDir = std::string(LLVM_PREFIX) +
"/../gnu";
2092 if (llvm::sys::fs::exists(PrefixRelDir))
2093 return PrefixRelDir;
2095 return InstallRelDir;
2101 A = Args.getLastArg(options::OPT_G, options::OPT_G_EQ,
2102 options::OPT_msmall_data_threshold_EQ);
2104 return A->getValue();
2106 A = Args.getLastArg(options::OPT_shared, options::OPT_fpic,
2115 return smallDataThreshold && smallDataThreshold[0] ==
'0';
2119 const std::string &MarchString,
2120 const std::string &InstalledDir,
2122 bool buildingLib = Args.hasArg(options::OPT_shared);
2127 for (Arg *A : Args.filtered(options::OPT_L))
2128 for (
const char *
Value : A->getValues())
2129 LibPaths->push_back(
Value);
2134 const std::string MarchSuffix =
"/" + MarchString;
2135 const std::string G0Suffix =
"/G0";
2136 const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
2140 std::string LibGCCHexagonDir = RootDir +
"lib/gcc/hexagon/";
2142 LibPaths->push_back(LibGCCHexagonDir + Ver + MarchG0Suffix);
2143 LibPaths->push_back(LibGCCHexagonDir + Ver + G0Suffix);
2145 LibPaths->push_back(LibGCCHexagonDir + Ver + MarchSuffix);
2146 LibPaths->push_back(LibGCCHexagonDir + Ver);
2149 LibPaths->push_back(RootDir +
"lib/gcc");
2152 std::string HexagonLibDir = RootDir +
"hexagon/lib";
2154 LibPaths->push_back(HexagonLibDir + MarchG0Suffix);
2155 LibPaths->push_back(HexagonLibDir + G0Suffix);
2157 LibPaths->push_back(HexagonLibDir + MarchSuffix);
2158 LibPaths->push_back(HexagonLibDir);
2162 const ArgList &Args)
2163 :
Linux(D, Triple, Args) {
2164 const std::string InstalledDir(
getDriver().getInstalledDir());
2169 const std::string BinDir(GnuDir +
"/bin");
2170 if (llvm::sys::fs::exists(BinDir))
2174 const std::string HexagonDir(GnuDir +
"/lib/gcc/hexagon");
2177 for (llvm::sys::fs::directory_iterator di(HexagonDir, ec), de;
2178 !ec && di != de; di = di.increment(ec)) {
2180 if (MaxVersion < cv)
2193 InstalledDir, LibPaths);
2207 ArgStringList &CC1Args)
const {
2210 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
2211 DriverArgs.hasArg(options::OPT_nostdlibinc))
2216 std::string HexagonDir(GnuDir +
"/lib/gcc/hexagon/" + Ver);
2223 ArgStringList &CC1Args)
const {
2225 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2226 DriverArgs.hasArg(options::OPT_nostdincxx))
2234 llvm::sys::path::append(IncludeDir,
"hexagon/include/c++/");
2235 llvm::sys::path::append(IncludeDir, Ver);
2241 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
2245 StringRef
Value = A->getValue();
2246 if (Value !=
"libstdc++") {
2247 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
2254 Arg *A = Args.getLastArg(options::OPT_march_EQ, options::OPT_mcpu_EQ);
2260 StringRef WhichHexagon = A->getValue();
2261 if (WhichHexagon.startswith(
"hexagonv")) {
2263 if (!WhichHexagon.substr(
sizeof(
"hexagonv") - 1).getAsInteger(10, Val))
2266 if (WhichHexagon.startswith(
"v")) {
2268 if (!WhichHexagon.substr(1).getAsInteger(10, Val))
2281 llvm_unreachable(
"Unexpected version");
2298 const ArgList &Args)
2311 std::string FilePath(
getDriver().Dir +
"/../");
2314 std::string ProgPath(
getDriver().Dir +
"/../");
2317 std::string ToolPath(
getDriver().ResourceDir +
"/lib/");
2319 switch (Triple.getArch()) {
2320 case llvm::Triple::x86: {
2321 file_paths.push_back(FilePath +
"x86_64-nacl/lib32");
2322 file_paths.push_back(FilePath +
"x86_64-nacl/usr/lib32");
2323 prog_paths.push_back(ProgPath +
"x86_64-nacl/bin");
2324 file_paths.push_back(ToolPath +
"i686-nacl");
2327 case llvm::Triple::x86_64: {
2328 file_paths.push_back(FilePath +
"x86_64-nacl/lib");
2329 file_paths.push_back(FilePath +
"x86_64-nacl/usr/lib");
2330 prog_paths.push_back(ProgPath +
"x86_64-nacl/bin");
2331 file_paths.push_back(ToolPath +
"x86_64-nacl");
2334 case llvm::Triple::arm: {
2335 file_paths.push_back(FilePath +
"arm-nacl/lib");
2336 file_paths.push_back(FilePath +
"arm-nacl/usr/lib");
2337 prog_paths.push_back(ProgPath +
"arm-nacl/bin");
2338 file_paths.push_back(ToolPath +
"arm-nacl");
2341 case llvm::Triple::mipsel: {
2342 file_paths.push_back(FilePath +
"mipsel-nacl/lib");
2343 file_paths.push_back(FilePath +
"mipsel-nacl/usr/lib");
2344 prog_paths.push_back(ProgPath +
"bin");
2345 file_paths.push_back(ToolPath +
"mipsel-nacl");
2354 NaClArmMacrosPath =
GetFilePath(
"nacl-arm-macros.s");
2358 ArgStringList &CC1Args)
const {
2360 if (DriverArgs.hasArg(options::OPT_nostdinc))
2363 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
2365 llvm::sys::path::append(P,
"include");
2369 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
2374 case llvm::Triple::arm:
2375 llvm::sys::path::append(P,
"arm-nacl/usr/include");
2377 case llvm::Triple::x86:
2378 llvm::sys::path::append(P,
"x86_64-nacl/usr/include");
2380 case llvm::Triple::x86_64:
2381 llvm::sys::path::append(P,
"x86_64-nacl/usr/include");
2383 case llvm::Triple::mipsel:
2384 llvm::sys::path::append(P,
"mipsel-nacl/usr/include");
2391 llvm::sys::path::remove_filename(P);
2392 llvm::sys::path::remove_filename(P);
2393 llvm::sys::path::append(P,
"include");
2398 ArgStringList &CmdArgs)
const {
2402 CmdArgs.push_back(
"-lc++");
2406 ArgStringList &CC1Args)
const {
2408 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2409 DriverArgs.hasArg(options::OPT_nostdincxx))
2418 case llvm::Triple::arm:
2419 llvm::sys::path::append(P,
"arm-nacl/include/c++/v1");
2422 case llvm::Triple::x86:
2423 llvm::sys::path::append(P,
"x86_64-nacl/include/c++/v1");
2426 case llvm::Triple::x86_64:
2427 llvm::sys::path::append(P,
"x86_64-nacl/include/c++/v1");
2430 case llvm::Triple::mipsel:
2431 llvm::sys::path::append(P,
"mipsel-nacl/include/c++/v1");
2440 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2441 StringRef
Value = A->getValue();
2442 if (Value ==
"libc++")
2444 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
2453 if (TheTriple.getArch() == llvm::Triple::arm &&
2454 TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
2455 TheTriple.setEnvironment(llvm::Triple::GNUEABIHF);
2456 return TheTriple.getTriple();
2475 const ArgList &Args)
2480 Path +=
"/../libexec";
2497 const ArgList &Args)
2500 llvm::sys::path::append(P,
"..",
getTriple().str(),
"lib");
2505 ArgStringList &CC1Args)
const {
2506 if (DriverArgs.hasArg(options::OPT_nostdlibinc) &&
2507 DriverArgs.hasArg(options::OPT_nostdincxx))
2511 llvm::sys::path::append(P,
"..",
getTriple().str(),
"include/c++/v1");
2516 ArgStringList &CmdArgs)
const {
2517 CmdArgs.push_back(
"-lc++");
2518 CmdArgs.push_back(
"-lc++abi");
2519 CmdArgs.push_back(
"-lunwind");
2529 const ArgList &Args)
2556 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2557 StringRef
Value = A->getValue();
2558 if (Value ==
"libstdc++")
2560 if (Value ==
"libc++")
2563 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
2569 ArgStringList &CC1Args)
const {
2570 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2571 DriverArgs.hasArg(options::OPT_nostdincxx))
2577 getDriver().SysRoot +
"/usr/include/c++/v1");
2581 getDriver().SysRoot +
"/usr/include/c++/stdc++");
2583 getDriver().SysRoot +
"/usr/include/c++/stdc++/backward");
2586 if (Triple.startswith(
"amd64"))
2592 "/usr/include/c++/stdc++/" +
2599 ArgStringList &CmdArgs)
const {
2602 CmdArgs.push_back(
"-lc++");
2603 CmdArgs.push_back(
"-lc++abi");
2604 CmdArgs.push_back(
"-lpthread");
2607 CmdArgs.push_back(
"-lstdc++");
2615 const ArgList &Args)
2620 if ((Triple.getArch() == llvm::Triple::x86 ||
2621 Triple.getArch() == llvm::Triple::ppc) &&
2629 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2630 StringRef
Value = A->getValue();
2631 if (Value ==
"libstdc++")
2633 if (Value ==
"libc++")
2636 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
2638 if (
getTriple().getOSMajorVersion() >= 10)
2644 ArgStringList &CC1Args)
const {
2645 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2646 DriverArgs.hasArg(options::OPT_nostdincxx))
2652 getDriver().SysRoot +
"/usr/include/c++/v1");
2656 getDriver().SysRoot +
"/usr/include/c++/4.2");
2658 getDriver().SysRoot +
"/usr/include/c++/4.2/backward");
2672 case llvm::Triple::GNUEABIHF:
2673 case llvm::Triple::GNUEABI:
2674 case llvm::Triple::EABI:
2688 const bool IsX86 =
getTriple().getArch() == llvm::Triple::x86;
2689 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
2690 const bool IsMIPS64 =
getTriple().getArch() == llvm::Triple::mips64 ||
2691 getTriple().getArch() == llvm::Triple::mips64el;
2693 Res |= SanitizerKind::Address;
2694 Res |= SanitizerKind::Vptr;
2695 if (IsX86_64 || IsMIPS64) {
2696 Res |= SanitizerKind::Leak;
2697 Res |= SanitizerKind::Thread;
2699 if (IsX86 || IsX86_64) {
2700 Res |= SanitizerKind::SafeStack;
2716 switch (Triple.getArch()) {
2717 case llvm::Triple::x86:
2720 case llvm::Triple::arm:
2721 case llvm::Triple::armeb:
2722 case llvm::Triple::thumb:
2723 case llvm::Triple::thumbeb:
2724 switch (Triple.getEnvironment()) {
2725 case llvm::Triple::EABI:
2726 case llvm::Triple::GNUEABI:
2729 case llvm::Triple::EABIHF:
2730 case llvm::Triple::GNUEABIHF:
2738 case llvm::Triple::mips64:
2739 case llvm::Triple::mips64el:
2745 case llvm::Triple::ppc:
2748 case llvm::Triple::sparc:
2766 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
2767 StringRef
Value = A->getValue();
2768 if (Value ==
"libstdc++")
2770 if (Value ==
"libc++")
2773 getDriver().
Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
2776 unsigned Major, Minor, Micro;
2777 getTriple().getOSVersion(Major, Minor, Micro);
2778 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
2780 case llvm::Triple::aarch64:
2781 case llvm::Triple::arm:
2782 case llvm::Triple::armeb:
2783 case llvm::Triple::thumb:
2784 case llvm::Triple::thumbeb:
2785 case llvm::Triple::ppc:
2786 case llvm::Triple::ppc64:
2787 case llvm::Triple::ppc64le:
2788 case llvm::Triple::x86:
2789 case llvm::Triple::x86_64:
2799 ArgStringList &CC1Args)
const {
2800 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2801 DriverArgs.hasArg(options::OPT_nostdincxx))
2807 getDriver().SysRoot +
"/usr/include/c++/");
2811 getDriver().SysRoot +
"/usr/include/g++");
2813 getDriver().SysRoot +
"/usr/include/g++/backward");
2835 const ArgList &Args)
2905 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
2906 llvm::MemoryBuffer::getFile(
"/etc/lsb-release");
2908 StringRef Data = File.get()->getBuffer();
2910 Data.split(Lines,
"\n");
2912 for (
const StringRef
Line : Lines)
2914 Version = llvm::StringSwitch<Distro>(
Line.substr(17))
2935 File = llvm::MemoryBuffer::getFile(
"/etc/redhat-release");
2937 StringRef Data = File.get()->getBuffer();
2938 if (Data.startswith(
"Fedora release"))
2940 if (Data.startswith(
"Red Hat Enterprise Linux") ||
2941 Data.startswith(
"CentOS")) {
2942 if (Data.find(
"release 7") != StringRef::npos)
2944 else if (Data.find(
"release 6") != StringRef::npos)
2946 else if (Data.find(
"release 5") != StringRef::npos)
2948 else if (Data.find(
"release 4") != StringRef::npos)
2954 File = llvm::MemoryBuffer::getFile(
"/etc/debian_version");
2956 StringRef Data = File.get()->getBuffer();
2959 else if (Data.startswith(
"squeeze/sid") || Data[0] ==
'6')
2961 else if (Data.startswith(
"wheezy/sid") || Data[0] ==
'7')
2963 else if (Data.startswith(
"jessie/sid") || Data[0] ==
'8')
2965 else if (Data.startswith(
"stretch/sid") || Data[0] ==
'9')
2970 if (llvm::sys::fs::exists(
"/etc/SuSE-release"))
2973 if (llvm::sys::fs::exists(
"/etc/exherbo-release"))
2976 if (llvm::sys::fs::exists(
"/etc/arch-release"))
2989 StringRef SysRoot) {
2990 llvm::Triple::EnvironmentType TargetEnvironment = TargetTriple.getEnvironment();
2994 switch (TargetTriple.getArch()) {
3002 case llvm::Triple::arm:
3003 case llvm::Triple::thumb:
3004 if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
3005 if (llvm::sys::fs::exists(SysRoot +
"/lib/arm-linux-gnueabihf"))
3006 return "arm-linux-gnueabihf";
3008 if (llvm::sys::fs::exists(SysRoot +
"/lib/arm-linux-gnueabi"))
3009 return "arm-linux-gnueabi";
3012 case llvm::Triple::armeb:
3013 case llvm::Triple::thumbeb:
3014 if (TargetEnvironment == llvm::Triple::GNUEABIHF) {
3015 if (llvm::sys::fs::exists(SysRoot +
"/lib/armeb-linux-gnueabihf"))
3016 return "armeb-linux-gnueabihf";
3018 if (llvm::sys::fs::exists(SysRoot +
"/lib/armeb-linux-gnueabi"))
3019 return "armeb-linux-gnueabi";
3022 case llvm::Triple::x86:
3023 if (llvm::sys::fs::exists(SysRoot +
"/lib/i386-linux-gnu"))
3024 return "i386-linux-gnu";
3026 case llvm::Triple::x86_64:
3028 if (TargetEnvironment != llvm::Triple::GNUX32 &&
3029 llvm::sys::fs::exists(SysRoot +
"/lib/x86_64-linux-gnu"))
3030 return "x86_64-linux-gnu";
3032 case llvm::Triple::aarch64:
3033 if (llvm::sys::fs::exists(SysRoot +
"/lib/aarch64-linux-gnu"))
3034 return "aarch64-linux-gnu";
3036 case llvm::Triple::aarch64_be:
3037 if (llvm::sys::fs::exists(SysRoot +
"/lib/aarch64_be-linux-gnu"))
3038 return "aarch64_be-linux-gnu";
3040 case llvm::Triple::mips:
3041 if (llvm::sys::fs::exists(SysRoot +
"/lib/mips-linux-gnu"))
3042 return "mips-linux-gnu";
3044 case llvm::Triple::mipsel:
3045 if (llvm::sys::fs::exists(SysRoot +
"/lib/mipsel-linux-gnu"))
3046 return "mipsel-linux-gnu";
3048 case llvm::Triple::mips64:
3049 if (llvm::sys::fs::exists(SysRoot +
"/lib/mips64-linux-gnu"))
3050 return "mips64-linux-gnu";
3051 if (llvm::sys::fs::exists(SysRoot +
"/lib/mips64-linux-gnuabi64"))
3052 return "mips64-linux-gnuabi64";
3054 case llvm::Triple::mips64el:
3055 if (llvm::sys::fs::exists(SysRoot +
"/lib/mips64el-linux-gnu"))
3056 return "mips64el-linux-gnu";
3057 if (llvm::sys::fs::exists(SysRoot +
"/lib/mips64el-linux-gnuabi64"))
3058 return "mips64el-linux-gnuabi64";
3060 case llvm::Triple::ppc:
3061 if (llvm::sys::fs::exists(SysRoot +
"/lib/powerpc-linux-gnuspe"))
3062 return "powerpc-linux-gnuspe";
3063 if (llvm::sys::fs::exists(SysRoot +
"/lib/powerpc-linux-gnu"))
3064 return "powerpc-linux-gnu";
3066 case llvm::Triple::ppc64:
3067 if (llvm::sys::fs::exists(SysRoot +
"/lib/powerpc64-linux-gnu"))
3068 return "powerpc64-linux-gnu";
3070 case llvm::Triple::ppc64le:
3071 if (llvm::sys::fs::exists(SysRoot +
"/lib/powerpc64le-linux-gnu"))
3072 return "powerpc64le-linux-gnu";
3074 case llvm::Triple::sparc:
3075 if (llvm::sys::fs::exists(SysRoot +
"/lib/sparc-linux-gnu"))
3076 return "sparc-linux-gnu";
3078 case llvm::Triple::sparcv9:
3079 if (llvm::sys::fs::exists(SysRoot +
"/lib/sparc64-linux-gnu"))
3080 return "sparc64-linux-gnu";
3083 return TargetTriple.str();
3087 if (llvm::sys::fs::exists(Path))
3088 Paths.push_back(Path.str());
3091 static StringRef
getOSLibDir(
const llvm::Triple &Triple,
const ArgList &Args) {
3098 return Triple.isArch32Bit() ?
"lib" :
"lib64";
3110 if (Triple.getArch() == llvm::Triple::x86 ||
3111 Triple.getArch() == llvm::Triple::ppc)
3114 if (Triple.getArch() == llvm::Triple::x86_64 &&
3115 Triple.getEnvironment() == llvm::Triple::GNUX32)
3118 return Triple.isArch32Bit() ?
"lib" :
"lib64";
3125 llvm::Triple::ArchType Arch = Triple.getArch();
3126 std::string SysRoot = computeSysRoot();
3150 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
3153 const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::Android;
3156 if (IsMips && !SysRoot.empty())
3157 ExtraOpts.push_back(
"--sysroot=" + SysRoot);
3164 if (!IsMips && !IsAndroid) {
3167 ExtraOpts.push_back(
"--hash-style=gnu");
3171 ExtraOpts.push_back(
"--hash-style=both");
3183 ExtraOpts.push_back(
"--enable-new-dtags");
3192 const std::string OSLibDir =
getOSLibDir(Triple, Args);
3224 addPathIfExists(LibPath +
"/../" + GCCTriple.str() +
"/lib/../" + OSLibDir +
3237 if (StringRef(LibPath).startswith(SysRoot)) {
3248 if (StringRef(D.
Dir).startswith(SysRoot)) {
3262 "/../../" + OSLibDir,
3283 if (StringRef(LibPath).startswith(SysRoot))
3292 if (StringRef(D.
Dir).startswith(SysRoot))
3307 std::string Linux::computeSysRoot()
const {
3312 return std::string();
3323 (InstallDir +
"/../../../../" + TripleStr +
"/libc" + Multilib.
osSuffix())
3326 if (llvm::sys::fs::exists(Path))
3329 Path = (InstallDir +
"/../../../../sysroot" + Multilib.
osSuffix()).str();
3331 if (llvm::sys::fs::exists(Path))
3334 return std::string();
3338 ArgStringList &CC1Args)
const {
3340 std::string SysRoot = computeSysRoot();
3342 if (DriverArgs.hasArg(options::OPT_nostdinc))
3345 if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
3348 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
3350 llvm::sys::path::append(P,
"include");
3354 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
3358 StringRef CIncludeDirs(C_INCLUDE_DIRS);
3359 if (CIncludeDirs !=
"") {
3361 CIncludeDirs.split(dirs,
":");
3362 for (StringRef dir : dirs) {
3364 llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) :
"";
3380 for (
const auto &Path : IncludePaths)
3386 const StringRef X86_64MultiarchIncludeDirs[] = {
3387 "/usr/include/x86_64-linux-gnu",
3392 "/usr/include/i686-linux-gnu/64",
"/usr/include/i486-linux-gnu/64"};
3393 const StringRef X86MultiarchIncludeDirs[] = {
3394 "/usr/include/i386-linux-gnu",
3399 "/usr/include/x86_64-linux-gnu/32",
"/usr/include/i686-linux-gnu",
3400 "/usr/include/i486-linux-gnu"};
3401 const StringRef AArch64MultiarchIncludeDirs[] = {
3402 "/usr/include/aarch64-linux-gnu"};
3403 const StringRef ARMMultiarchIncludeDirs[] = {
3404 "/usr/include/arm-linux-gnueabi"};
3405 const StringRef ARMHFMultiarchIncludeDirs[] = {
3406 "/usr/include/arm-linux-gnueabihf"};
3407 const StringRef MIPSMultiarchIncludeDirs[] = {
"/usr/include/mips-linux-gnu"};
3408 const StringRef MIPSELMultiarchIncludeDirs[] = {
3409 "/usr/include/mipsel-linux-gnu"};
3410 const StringRef MIPS64MultiarchIncludeDirs[] = {
3411 "/usr/include/mips64-linux-gnu",
"/usr/include/mips64-linux-gnuabi64"};
3412 const StringRef MIPS64ELMultiarchIncludeDirs[] = {
3413 "/usr/include/mips64el-linux-gnu",
3414 "/usr/include/mips64el-linux-gnuabi64"};
3415 const StringRef PPCMultiarchIncludeDirs[] = {
3416 "/usr/include/powerpc-linux-gnu"};
3417 const StringRef PPC64MultiarchIncludeDirs[] = {
3418 "/usr/include/powerpc64-linux-gnu"};
3419 const StringRef PPC64LEMultiarchIncludeDirs[] = {
3420 "/usr/include/powerpc64le-linux-gnu"};
3421 const StringRef SparcMultiarchIncludeDirs[] = {
3422 "/usr/include/sparc-linux-gnu"};
3423 const StringRef Sparc64MultiarchIncludeDirs[] = {
3424 "/usr/include/sparc64-linux-gnu"};
3427 case llvm::Triple::x86_64:
3428 MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
3430 case llvm::Triple::x86:
3431 MultiarchIncludeDirs = X86MultiarchIncludeDirs;
3433 case llvm::Triple::aarch64:
3434 case llvm::Triple::aarch64_be:
3435 MultiarchIncludeDirs = AArch64MultiarchIncludeDirs;
3437 case llvm::Triple::arm:
3438 if (
getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
3439 MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs;
3441 MultiarchIncludeDirs = ARMMultiarchIncludeDirs;
3443 case llvm::Triple::mips:
3444 MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;
3446 case llvm::Triple::mipsel:
3447 MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;
3449 case llvm::Triple::mips64:
3450 MultiarchIncludeDirs = MIPS64MultiarchIncludeDirs;
3452 case llvm::Triple::mips64el:
3453 MultiarchIncludeDirs = MIPS64ELMultiarchIncludeDirs;
3455 case llvm::Triple::ppc:
3456 MultiarchIncludeDirs = PPCMultiarchIncludeDirs;
3458 case llvm::Triple::ppc64:
3459 MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;
3461 case llvm::Triple::ppc64le:
3462 MultiarchIncludeDirs = PPC64LEMultiarchIncludeDirs;
3464 case llvm::Triple::sparc:
3465 MultiarchIncludeDirs = SparcMultiarchIncludeDirs;
3467 case llvm::Triple::sparcv9:
3468 MultiarchIncludeDirs = Sparc64MultiarchIncludeDirs;
3473 for (StringRef Dir : MultiarchIncludeDirs) {
3474 if (llvm::sys::fs::exists(SysRoot + Dir)) {
3492 bool Linux::addLibStdCXXIncludePaths(
3493 Twine
Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
3494 StringRef TargetMultiarchTriple, Twine IncludeSuffix,
3495 const ArgList &DriverArgs, ArgStringList &CC1Args) {
3496 if (!llvm::sys::fs::exists(Base + Suffix))
3504 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
3505 llvm::sys::fs::exists(Base + Suffix +
"/" + GCCTriple + IncludeSuffix)) {
3507 Base + Suffix +
"/" + GCCTriple + IncludeSuffix);
3515 Base +
"/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
3517 Base +
"/" + TargetMultiarchTriple + Suffix);
3525 ArgStringList &CC1Args)
const {
3526 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3527 DriverArgs.hasArg(options::OPT_nostdincxx))
3532 const std::string LibCXXIncludePathCandidates[] = {
3542 for (
const auto &IncludePath : LibCXXIncludePathCandidates) {
3543 if (!llvm::sys::fs::exists(IncludePath))
3564 const std::string GCCMultiarchTriple =
3566 const std::string TargetMultiarchTriple =
3571 if (addLibStdCXXIncludePaths(LibDir.str() +
"/../include",
3572 "/c++/" + Version.
Text, TripleStr,
3573 GCCMultiarchTriple, TargetMultiarchTriple,
3579 const std::string LibStdCXXIncludePathCandidates[] = {
3582 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr +
"." +
3584 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr,
3586 LibDir.str() +
"/../" + TripleStr.str() +
"/include/c++/" + Version.
Text,
3589 LibDir.str() +
"/../include/c++",
3592 for (
const auto &IncludePath : LibStdCXXIncludePathCandidates) {
3593 if (addLibStdCXXIncludePaths(IncludePath,
"", TripleStr,
3604 const bool IsX86 =
getTriple().getArch() == llvm::Triple::x86;
3605 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
3606 const bool IsMIPS64 =
getTriple().getArch() == llvm::Triple::mips64 ||
3607 getTriple().getArch() == llvm::Triple::mips64el;
3608 const bool IsPowerPC64 =
getTriple().getArch() == llvm::Triple::ppc64 ||
3609 getTriple().getArch() == llvm::Triple::ppc64le;
3611 Res |= SanitizerKind::Address;
3612 Res |= SanitizerKind::KernelAddress;
3613 Res |= SanitizerKind::Vptr;
3614 if (IsX86_64 || IsMIPS64) {
3615 Res |= SanitizerKind::DataFlow;
3616 Res |= SanitizerKind::Leak;
3617 Res |= SanitizerKind::Thread;
3619 if (IsX86_64 || IsMIPS64 || IsPowerPC64)
3620 Res |= SanitizerKind::Memory;
3621 if (IsX86 || IsX86_64) {
3622 Res |= SanitizerKind::Function;
3623 Res |= SanitizerKind::SafeStack;
3631 const ArgList &Args)
3641 if (llvm::sys::fs::exists(
"/usr/lib/gcc47"))
3660 const ArgList &Args)
3661 :
Linux(D, Triple, Args) {}
3665 llvm::opt::ArgStringList &CC1Args)
const {
3667 CC1Args.push_back(
"-fcuda-is-device");
3670 llvm::opt::DerivedArgList *
3672 const char *BoundArch)
const {
3673 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
3676 for (Arg *A : Args) {
3677 if (A->getOption().matches(options::OPT_Xarch__)) {
3679 if (A->getValue(0) != StringRef(BoundArch))
3682 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
3683 unsigned Prev = Index;
3684 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
3694 if (!XarchArg || Index > Prev + 1) {
3695 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
3696 << A->getAsString(Args);
3699 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
3700 << A->getAsString(Args);
3703 XarchArg->setBaseArg(A);
3704 A = XarchArg.release();
3705 DAL->AddSynthesizedArg(A);
3710 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_march_EQ), BoundArch);
3737 ArgStringList &CC1Args)
const {
3738 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
3739 DriverArgs.hasArg(options::OPT_nostdlibinc))
3741 if (
const char *cl_include_dir = getenv(
"XCC_C_INCLUDE_PATH")) {
3743 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,
'\0'};
3744 StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
3751 ArgStringList &CC1Args)
const {
3752 CC1Args.push_back(
"-nostdsysteminc");
3756 ArgStringList &CC1Args)
const {
3757 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
3758 DriverArgs.hasArg(options::OPT_nostdlibinc) ||
3759 DriverArgs.hasArg(options::OPT_nostdincxx))
3761 if (
const char *cl_include_dir = getenv(
"XCC_CPLUS_INCLUDE_PATH")) {
3763 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,
'\0'};
3764 StringRef(cl_include_dir).split(Dirs, StringRef(EnvPathSeparatorStr));
3771 ArgStringList &CmdArgs)
const {
3782 return Compiler.get();
3786 return Assembler.get();
3793 const ArgList &Args)
3804 llvm_unreachable(
"SHAVEToolChain can't getTool");
3809 llvm_unreachable(
"SHAVEToolChain can't buildLinker");
3815 llvm_unreachable(
"SHAVEToolChain can't buildAssembler");
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. Always starts with a '/', unless empty.
ID lookupTypeForExtension(const char *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. Always starts with a '/'...
Defines types useful for describing an Objective-C runtime.
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)
Multilib & flag(StringRef F)
Add a flag to the flags list.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant. Always starts with a...
ActionClass getKind() const
std::string getAsString() const
Retrieve a string representation of the version number.
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
MultilibSet & setIncludeDirsCallback(IncludeDirsFunc F)
MultilibSet Multilibs
The set of multilibs that the detected installation supports.
llvm::Optional< Multilib > BiarchSibling
MatchFinder::MatchCallback * Callback
Defines version macros and version-related utility functions for Clang.
bool needsUbsanRt() const
void push_back(const Multilib &M)
Add a completed Multilib to the set.
std::string InstalledDir
The path to the installed clang directory, if any.
bool hasSubscripting() const
Does this runtime directly support the subscripting methods?
Multilib SelectedMultilib
The primary multilib appropriate for the given flags.
The basic abstraction for the target Objective-C runtime.
std::string SysRoot
sysroot, if present
bool isDefault() const
Check whether the default is selected.
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.