18#include "clang/Config/config.h"
26#include "llvm/ADT/StringSet.h"
27#include "llvm/ADT/Twine.h"
28#include "llvm/Option/ArgList.h"
29#include "llvm/Support/CodeGen.h"
30#include "llvm/Support/Path.h"
31#include "llvm/Support/VirtualFileSystem.h"
32#include "llvm/TargetParser/RISCVISAInfo.h"
33#include "llvm/TargetParser/TargetParser.h"
34#include <system_error>
55 ArgStringList &CmdArgs) {
56 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
57 StringRef CPUArg(A->getValue());
58 if (CPUArg.equals_insensitive(
"krait"))
59 CmdArgs.push_back(
"-mcpu=cortex-a15");
60 else if (CPUArg.equals_insensitive(
"kryo"))
61 CmdArgs.push_back(
"-mcpu=cortex-a57");
63 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
71 const char *LinkingOutput)
const {
73 ArgStringList CmdArgs;
75 for (
const auto &A : Args) {
83 A->render(Args, CmdArgs);
91 CmdArgs.push_back(
"-arch");
93 Args.MakeArgString(
getToolChain().getDefaultUniversalArchName()));
104 case llvm::Triple::x86:
105 case llvm::Triple::ppc:
106 case llvm::Triple::ppcle:
107 CmdArgs.push_back(
"-m32");
109 case llvm::Triple::x86_64:
110 case llvm::Triple::ppc64:
111 case llvm::Triple::ppc64le:
112 CmdArgs.push_back(
"-m64");
114 case llvm::Triple::sparcel:
115 CmdArgs.push_back(
"-EL");
121 CmdArgs.push_back(
"-o");
124 CmdArgs.push_back(
"-fsyntax-only");
127 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
137 for (
const auto &II : Inputs) {
140 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
142 else if (II.getType() == types::TY_AST)
144 else if (II.getType() == types::TY_ModuleFile)
145 D.Diag(diag::err_drv_no_module_support)
149 CmdArgs.push_back(
"-x");
154 CmdArgs.push_back(II.getFilename());
156 const Arg &A = II.getInputArg();
159 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
160 CmdArgs.push_back(
"-lstdc++");
165 A.render(Args, CmdArgs);
169 const std::string &customGCCName =
D.getCCCGenericGCCName();
171 if (!customGCCName.empty())
172 GCCName = customGCCName.c_str();
173 else if (
D.CCCIsCXX()) {
178 const char *Exec = Args.MakeArgString(
getToolChain().GetProgramPath(GCCName));
179 C.addCommand(std::make_unique<Command>(JA, *
this,
181 Exec, CmdArgs, Inputs, Output));
185 const JobAction &JA, ArgStringList &CmdArgs)
const {
186 CmdArgs.push_back(
"-E");
190 ArgStringList &CmdArgs)
const {
191 const Driver &
D = getToolChain().getDriver();
195 case types::TY_LLVM_IR:
196 case types::TY_LTO_IR:
197 case types::TY_LLVM_BC:
198 case types::TY_LTO_BC:
199 CmdArgs.push_back(
"-c");
203 case types::TY_Object:
204 CmdArgs.push_back(
"-c");
206 case types::TY_PP_Asm:
207 CmdArgs.push_back(
"-S");
209 case types::TY_Nothing:
210 CmdArgs.push_back(
"-fsyntax-only");
213 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.
getType());
218 ArgStringList &CmdArgs)
const {
223 return Args.hasArg(options::OPT_static) &&
224 !Args.hasArg(options::OPT_static_pie);
230 const char *LinkingOutput)
const {
231 const Driver &
D = getToolChain().getDriver();
234 Args.ClaimAllArgs(options::OPT_g_Group);
236 Args.ClaimAllArgs(options::OPT_emit_llvm);
239 Args.ClaimAllArgs(options::OPT_w);
241 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
244 ArgStringList CmdArgs;
246 CmdArgs.push_back(
"rcsD");
249 for (
const auto &II : Inputs) {
250 if (II.isFilename()) {
251 CmdArgs.push_back(II.getFilename());
258 if (Output.
isFilename() && llvm::sys::fs::exists(OutputFileName)) {
259 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
260 D.Diag(diag::err_drv_unable_to_remove_file) << EC.message();
265 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
266 C.addCommand(std::make_unique<Command>(JA, *
this,
268 Exec, CmdArgs, Inputs, Output));
275 const char *LinkingOutput)
const {
283 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
292 const bool HasCRTBeginEndFiles =
296 ArgStringList CmdArgs;
299 Args.ClaimAllArgs(options::OPT_g_Group);
301 Args.ClaimAllArgs(options::OPT_emit_llvm);
304 Args.ClaimAllArgs(options::OPT_w);
306 if (!
D.SysRoot.empty())
307 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" +
D.SysRoot));
309 if (Args.hasArg(options::OPT_s))
310 CmdArgs.push_back(
"-s");
312 if (Triple.isARM() || Triple.isThumb()) {
316 CmdArgs.push_back(IsBigEndian ?
"-EB" :
"-EL");
317 }
else if (Triple.isAArch64()) {
318 CmdArgs.push_back(
Arch == llvm::Triple::aarch64_be ?
"-EB" :
"-EL");
323 if (
Arch == llvm::Triple::aarch64 && (isAndroid || isOHOSFamily) &&
324 Args.hasFlag(options::OPT_mfix_cortex_a53_843419,
325 options::OPT_mno_fix_cortex_a53_843419,
true)) {
327 if (CPU.empty() || CPU ==
"generic" || CPU ==
"cortex-a53")
328 CmdArgs.push_back(
"--fix-cortex-a53-843419");
333 CmdArgs.push_back(
"--eh-frame-hdr");
336 CmdArgs.push_back(
"-m");
337 CmdArgs.push_back(LDMOption);
339 D.Diag(diag::err_target_unknown_triple) << Triple.str();
343 if (Triple.isLoongArch() || Triple.isRISCV()) {
344 CmdArgs.push_back(
"-X");
345 if (Args.hasArg(options::OPT_mno_relax))
346 CmdArgs.push_back(
"--no-relax");
349 const bool IsShared = Args.hasArg(options::OPT_shared);
351 CmdArgs.push_back(
"-shared");
354 CmdArgs.push_back(
"-static");
355 CmdArgs.push_back(
"-pie");
356 CmdArgs.push_back(
"--no-dynamic-linker");
357 CmdArgs.push_back(
"-z");
358 CmdArgs.push_back(
"text");
360 CmdArgs.push_back(
"-static");
361 }
else if (!Args.hasArg(options::OPT_r)) {
362 if (Args.hasArg(options::OPT_rdynamic))
363 CmdArgs.push_back(
"-export-dynamic");
365 IsPIE = Args.hasFlag(options::OPT_pie, options::OPT_no_pie,
368 CmdArgs.push_back(
"-pie");
369 CmdArgs.push_back(
"-dynamic-linker");
370 CmdArgs.push_back(Args.MakeArgString(Twine(
D.DyldPrefix) +
375 CmdArgs.push_back(
"-o");
378 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles,
380 if (!isAndroid && !IsIAMCU) {
381 const char *crt1 =
nullptr;
382 if (!Args.hasArg(options::OPT_shared)) {
383 if (Args.hasArg(options::OPT_pg))
387 else if (IsStaticPIE)
399 CmdArgs.push_back(
"-z");
400 CmdArgs.push_back(
"max-page-size=0x4000000");
405 else if (HasCRTBeginEndFiles) {
415 const char *crtbegin;
416 if (Args.hasArg(options::OPT_shared))
417 crtbegin = isAndroid ?
"crtbegin_so.o" :
"crtbeginS.o";
419 crtbegin = isAndroid ?
"crtbegin_static.o" :
"crtbeginT.o";
420 else if (IsPIE || IsStaticPIE)
421 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbeginS.o";
423 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbegin.o";
426 CmdArgs.push_back(Args.MakeArgString(
P));
432 if (isAndroid && Args.hasFlag(options::OPT_fandroid_pad_segment,
433 options::OPT_fno_android_pad_segment,
false))
438 Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_u});
446 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
447 CmdArgs.push_back(
"--no-demangle");
457 getToolChain().addProfileRTLibs(Args, CmdArgs);
460 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
463 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
464 !Args.hasArg(options::OPT_static);
465 if (OnlyLibstdcxxStatic)
466 CmdArgs.push_back(
"-Bstatic");
468 if (OnlyLibstdcxxStatic)
469 CmdArgs.push_back(
"-Bdynamic");
471 CmdArgs.push_back(
"-lm");
475 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
481 if (
D.IsFlangMode() &&
482 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
485 CmdArgs.push_back(
"-lm");
488 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_r)) {
489 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
491 CmdArgs.push_back(
"--start-group");
493 if (NeedsSanitizerDeps)
499 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
500 Args.hasArg(options::OPT_pthreads);
503 bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&
504 !Args.hasArg(options::OPT_static);
520 if (getToolChain().getTriple().getArch() == llvm::Triple::sparc) {
521 CmdArgs.push_back(
"--push-state");
522 CmdArgs.push_back(
"--as-needed");
523 CmdArgs.push_back(
"-latomic");
524 CmdArgs.push_back(
"--pop-state");
529 if (WantPthread && !isAndroid && !isOHOSFamily)
530 CmdArgs.push_back(
"-lpthread");
532 if (Args.hasArg(options::OPT_fsplit_stack))
533 CmdArgs.push_back(
"--wrap=pthread_create");
535 if (!Args.hasArg(options::OPT_nolibc))
536 CmdArgs.push_back(
"-lc");
540 CmdArgs.push_back(
"-lgloss");
543 CmdArgs.push_back(
"--end-group");
549 CmdArgs.push_back(
"--as-needed");
550 CmdArgs.push_back(
"-lsoftfp");
551 CmdArgs.push_back(
"--no-as-needed");
555 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
556 if (HasCRTBeginEndFiles) {
567 if (Args.hasArg(options::OPT_shared))
568 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
569 else if (IsPIE || IsStaticPIE)
570 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
572 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
575 CmdArgs.push_back(Args.MakeArgString(
P));
582 Args.addAllArgs(CmdArgs, {options::OPT_T, options::OPT_t});
585 C.addCommand(std::make_unique<Command>(JA, *
this,
587 Exec, CmdArgs, Inputs, Output));
595 const char *LinkingOutput)
const {
596 const auto &
D = getToolChain().getDriver();
600 ArgStringList CmdArgs;
602 llvm::Reloc::Model RelocationModel;
605 const char *DefaultAssembler =
"as";
608 if (getToolChain().getTriple().isOSSolaris())
609 DefaultAssembler =
"gas";
610 std::tie(RelocationModel, PICLevel, IsPIE) =
613 if (
const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
614 if (A->getOption().getID() == options::OPT_gz) {
615 CmdArgs.push_back(
"--compress-debug-sections");
617 StringRef
Value = A->getValue();
620 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
622 D.Diag(diag::err_drv_unsupported_option_argument)
623 << A->getSpelling() <<
Value;
628 switch (getToolChain().getArch()) {
633 case llvm::Triple::x86:
634 CmdArgs.push_back(
"--32");
636 case llvm::Triple::x86_64:
637 if (getToolChain().getTriple().isX32())
638 CmdArgs.push_back(
"--x32");
640 CmdArgs.push_back(
"--64");
642 case llvm::Triple::ppc: {
643 CmdArgs.push_back(
"-a32");
644 CmdArgs.push_back(
"-mppc");
645 CmdArgs.push_back(
"-mbig-endian");
650 case llvm::Triple::ppcle: {
651 CmdArgs.push_back(
"-a32");
652 CmdArgs.push_back(
"-mppc");
653 CmdArgs.push_back(
"-mlittle-endian");
658 case llvm::Triple::ppc64: {
659 CmdArgs.push_back(
"-a64");
660 CmdArgs.push_back(
"-mppc64");
661 CmdArgs.push_back(
"-mbig-endian");
666 case llvm::Triple::ppc64le: {
667 CmdArgs.push_back(
"-a64");
668 CmdArgs.push_back(
"-mppc64");
669 CmdArgs.push_back(
"-mlittle-endian");
674 case llvm::Triple::riscv32:
675 case llvm::Triple::riscv64: {
677 CmdArgs.push_back(
"-mabi");
678 CmdArgs.push_back(ABIName.data());
679 std::string MArchName =
681 CmdArgs.push_back(
"-march");
682 CmdArgs.push_back(Args.MakeArgString(MArchName));
683 if (!Args.hasFlag(options::OPT_mrelax, options::OPT_mno_relax,
true))
684 Args.addOptOutFlag(CmdArgs, options::OPT_mrelax, options::OPT_mno_relax);
687 case llvm::Triple::sparc:
688 case llvm::Triple::sparcel: {
689 CmdArgs.push_back(
"-32");
690 std::string CPU =
getCPUName(
D, Args, getToolChain().getTriple());
696 case llvm::Triple::sparcv9: {
697 CmdArgs.push_back(
"-64");
698 std::string CPU =
getCPUName(
D, Args, getToolChain().getTriple());
704 case llvm::Triple::arm:
705 case llvm::Triple::armeb:
706 case llvm::Triple::thumb:
707 case llvm::Triple::thumbeb: {
708 const llvm::Triple &Triple2 = getToolChain().getTriple();
710 switch (Triple2.getSubArch()) {
711 case llvm::Triple::ARMSubArch_v7:
712 CmdArgs.push_back(
"-mfpu=neon");
714 case llvm::Triple::ARMSubArch_v8:
715 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
724 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=soft"));
727 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=softfp"));
730 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=hard"));
734 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
737 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
741 if (Arg *A = Args.getLastArgNoClaim(options::OPT_mabi_EQ))
742 A->ignoreTargetSpecific();
745 case llvm::Triple::aarch64:
746 case llvm::Triple::aarch64_be: {
748 getToolChain().getArch() == llvm::Triple::aarch64_be ?
"-EB" :
"-EL");
749 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
755 case llvm::Triple::loongarch64: {
758 CmdArgs.push_back(Args.MakeArgString(
"-mabi=" + ABIName));
761 case llvm::Triple::mips:
762 case llvm::Triple::mipsel:
763 case llvm::Triple::mips64:
764 case llvm::Triple::mips64el: {
770 CmdArgs.push_back(
"-march");
771 CmdArgs.push_back(CPUName.data());
773 CmdArgs.push_back(
"-mabi");
774 CmdArgs.push_back(ABIName.data());
778 if (RelocationModel == llvm::Reloc::Static)
779 CmdArgs.push_back(
"-mno-shared");
783 if (ABIName !=
"64" && !Args.hasArg(options::OPT_mno_abicalls))
784 CmdArgs.push_back(
"-call_nonpic");
786 if (getToolChain().getTriple().isLittleEndian())
787 CmdArgs.push_back(
"-EL");
789 CmdArgs.push_back(
"-EB");
791 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
792 if (StringRef(A->getValue()) ==
"2008")
793 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
797 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
798 options::OPT_mfp64)) {
800 A->render(Args, CmdArgs);
802 Args, getToolChain().getTriple(), CPUName, ABIName,
804 getToolChain().getTriple())))
805 CmdArgs.push_back(
"-mfpxx");
810 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
811 if (A->getOption().matches(options::OPT_mips16)) {
813 A->render(Args, CmdArgs);
816 CmdArgs.push_back(
"-no-mips16");
820 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
821 options::OPT_mno_micromips);
822 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
823 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
825 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
828 if (A->getOption().matches(options::OPT_mmsa))
829 CmdArgs.push_back(Args.MakeArgString(
"-mmsa"));
832 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
833 options::OPT_msoft_float);
835 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
836 options::OPT_msingle_float);
838 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
839 options::OPT_mno_odd_spreg);
844 case llvm::Triple::systemz: {
847 std::string CPUName =
849 CmdArgs.push_back(Args.MakeArgString(
"-march=" + CPUName));
852 case llvm::Triple::ve:
853 DefaultAssembler =
"nas";
856 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
857 options::OPT_fdebug_prefix_map_EQ)) {
858 StringRef Map = A->getValue();
859 if (!Map.contains(
'='))
860 D.Diag(diag::err_drv_invalid_argument_to_option)
861 << Map << A->getOption().getName();
863 CmdArgs.push_back(Args.MakeArgString(
"--debug-prefix-map"));
864 CmdArgs.push_back(Args.MakeArgString(Map));
869 Args.AddAllArgs(CmdArgs, options::OPT_I);
870 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
872 CmdArgs.push_back(
"-o");
875 for (
const auto &II : Inputs)
876 CmdArgs.push_back(II.getFilename());
878 if (Arg *A = Args.getLastArg(options::OPT_g_Flag, options::OPT_gN_Group,
879 options::OPT_gdwarf_2, options::OPT_gdwarf_3,
880 options::OPT_gdwarf_4, options::OPT_gdwarf_5,
881 options::OPT_gdwarf))
882 if (!A->getOption().matches(options::OPT_g0)) {
883 Args.AddLastArg(CmdArgs, options::OPT_g_Flag);
886 CmdArgs.push_back(Args.MakeArgString(
"-gdwarf-" + Twine(DwarfVersion)));
890 Args.MakeArgString(getToolChain().GetProgramPath(DefaultAssembler));
891 C.addCommand(std::make_unique<Command>(JA, *
this,
893 Exec, CmdArgs, Inputs, Output));
898 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
899 getToolChain().getTriple().isOSLinux())
906class FilterNonExistent {
908 llvm::vfs::FileSystem &VFS;
911 FilterNonExistent(StringRef
Base, StringRef
File, llvm::vfs::FileSystem &VFS)
913 bool operator()(
const Multilib &M) {
920 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
921 options::OPT_mfloat_abi_EQ);
925 return A->getOption().matches(options::OPT_msoft_float) ||
926 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
927 A->getValue() == StringRef(
"soft"));
931 return Arch == llvm::Triple::arm ||
Arch == llvm::Triple::thumb;
935 return Arch == llvm::Triple::mipsel ||
Arch == llvm::Triple::mips64el;
939 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
940 return A && A->getOption().matches(options::OPT_mips16);
944 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
945 return A && A->getOption().matches(options::OPT_mmicromips);
949 return Arch == llvm::Triple::msp430;
954 FilterNonExistent &NonExistent,
961 auto MArchMicroMips =
965 .
flag(
"-mips16",
true)
966 .
flag(
"-mmicromips",
true);
975 .
flag(
"-msoft-float",
true)
976 .
flag(
"-mnan=2008",
true);
987 .includeSuffix(
"/64")
989 .flag(
"-mabi=n32",
true)
994 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
996 .
Either(SoftFloat, Nan2008, DefaultFloat)
999 .
Either(BigEndian, LittleEndian)
1006 std::vector<std::string> Dirs({
"/include"});
1009 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1011 Dirs.push_back(
"/../../../../mips-linux-gnu/libc/usr/include");
1024 .includeSuffix(
"/64")
1027 .flag(
"-mabi=n32",
true);
1033 .flag(
"-mabi=n32",
true);
1036 .
Either(M32, M64, MAbiN32)
1043 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1044 if (CSMipsMultilibs.
size() < DebianMipsMultilibs.
size())
1045 std::iter_swap(Candidates, Candidates + 1);
1047 if (Candidate->select(
D, Flags,
Result.SelectedMultilibs)) {
1048 if (Candidate == &DebianMipsMultilibs)
1050 Result.Multilibs = *Candidate;
1059 FilterNonExistent &NonExistent,
1068 .flag(
"-march=mips32r2");
1073 .
flag(
"-march=mips32r2");
1076 .
Either(MArchMipsR2, MArchMipselR2)
1081 return std::vector<std::string>(
1082 {
"/../sysroot" + M.
osSuffix() +
"/usr/include"});
1085 if (MuslMipsMultilibs.
select(
D, Flags,
Result.SelectedMultilibs)) {
1086 Result.Multilibs = MuslMipsMultilibs;
1094 FilterNonExistent &NonExistent,
1102 .
flag(
"-mmicromips",
true)
1103 .
flag(
"-march=mips32");
1108 .
flag(
"-mmicromips");
1113 .
flag(
"-march=mips64r2");
1118 .
flag(
"-march=mips64r2",
true);
1123 .
flag(
"-mmicromips",
true)
1124 .
flag(
"-march=mips32r2");
1132 .
flag(
"-mabi=n32",
true)
1133 .
flag(
"-m32",
true);
1145 MtiMipsMultilibsV1 =
1147 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1159 .
Either(BigEndian, LittleEndian)
1166 std::vector<std::string> Dirs({
"/include"});
1168 Dirs.push_back(
"/../../../../sysroot/uclibc/usr/include");
1170 Dirs.push_back(
"/../../../../sysroot/usr/include");
1180 .
flag(
"-msoft-float",
true)
1181 .
flag(
"-mnan=2008",
true)
1182 .
flag(
"-muclibc",
true);
1185 .
flag(
"-msoft-float")
1186 .
flag(
"-mnan=2008",
true);
1189 .
flag(
"-msoft-float",
true)
1190 .
flag(
"-mnan=2008",
true)
1191 .
flag(
"-muclibc",
true);
1194 .
flag(
"-msoft-float")
1195 .
flag(
"-mnan=2008",
true)
1196 .
flag(
"-mmicromips",
true);
1199 .
flag(
"-msoft-float",
true)
1201 .
flag(
"-muclibc",
true);
1204 .
flag(
"-msoft-float",
true)
1206 .
flag(
"-muclibc",
true)
1207 .
flag(
"-mmicromips",
true);
1208 auto BeHardNanUclibc =
MultilibBuilder(
"/mips-r2-hard-nan2008-uclibc")
1210 .
flag(
"-msoft-float",
true)
1213 auto ElHardNanUclibc =
MultilibBuilder(
"/mipsel-r2-hard-nan2008-uclibc")
1215 .
flag(
"-msoft-float",
true)
1220 .
flag(
"-msoft-float",
true)
1221 .
flag(
"-mnan=2008",
true)
1225 .
flag(
"-msoft-float",
true)
1226 .
flag(
"-mnan=2008",
true)
1230 .
flag(
"-msoft-float",
true)
1232 .
flag(
"-mmicromips");
1235 .
flag(
"-msoft-float")
1236 .
flag(
"-mnan=2008",
true)
1237 .
flag(
"-mmicromips");
1241 .flag(
"-mabi=n32",
true)
1242 .flag(
"-mabi=n64",
true);
1246 .flag(
"-mabi=n64",
true);
1249 .flag(
"-mabi=n32",
true)
1252 MtiMipsMultilibsV2 =
1254 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1255 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1256 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1257 .Either(O32, N32, N64)
1261 return std::vector<std::string>({
"/../../../../sysroot" +
1263 "/../usr/include"});
1265 .setFilePathsCallback([](
const Multilib &M) {
1266 return std::vector<std::string>(
1267 {
"/../../../../mips-mti-linux-gnu/lib" + M.
gccSuffix()});
1270 for (
auto *Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1271 if (Candidate->select(
D, Flags,
Result.SelectedMultilibs)) {
1272 Result.Multilibs = *Candidate;
1281 FilterNonExistent &NonExistent,
1288 .
flag(
"-m32",
true);
1295 .
flag(
"-mabi=n32",
true)
1296 .
flag(
"-m32",
true);
1302 .
Maybe(LittleEndian)
1306 return std::vector<std::string>(
1307 {
"/include",
"/../../../../sysroot/usr/include"});
1316 .
flag(
"-msoft-float",
true)
1317 .
flag(
"-mmicromips",
true);
1320 .
flag(
"-msoft-float")
1321 .
flag(
"-mmicromips",
true);
1324 .
flag(
"-msoft-float",
true)
1325 .
flag(
"-mmicromips",
true);
1328 .
flag(
"-msoft-float")
1329 .
flag(
"-mmicromips",
true);
1332 .
flag(
"-msoft-float",
true)
1333 .
flag(
"-mmicromips");
1336 .
flag(
"-msoft-float")
1337 .
flag(
"-mmicromips");
1340 .
flag(
"-msoft-float",
true)
1341 .
flag(
"-mmicromips");
1344 .
flag(
"-msoft-float")
1345 .
flag(
"-mmicromips");
1349 .flag(
"-mabi=n32",
true)
1350 .flag(
"-mabi=n64",
true);
1354 .flag(
"-mabi=n64",
true);
1357 .flag(
"-mabi=n32",
true)
1362 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1363 ElMicroHard, ElMicroSoft})
1364 .Either(O32, N32, N64)
1368 return std::vector<std::string>({
"/../../../../sysroot" +
1370 "/../usr/include"});
1372 .setFilePathsCallback([](
const Multilib &M) {
1373 return std::vector<std::string>(
1374 {
"/../../../../mips-img-linux-gnu/lib" + M.
gccSuffix()});
1377 for (
auto *Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1378 if (Candidate->select(
D, Flags,
Result.SelectedMultilibs)) {
1379 Result.Multilibs = *Candidate;
1387 const llvm::Triple &TargetTriple,
1388 StringRef
Path,
const ArgList &Args,
1390 FilterNonExistent NonExistent(
Path,
"/crtbegin.o",
D.getVFS());
1396 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1404 CPUName ==
"mips32r5" || CPUName ==
"p5600",
1405 "-march=mips32r2", Flags);
1409 CPUName ==
"mips64r5" || CPUName ==
"octeon" ||
1410 CPUName ==
"octeon+",
1411 "-march=mips64r2", Flags);
1414 "-march=mips64r6", Flags);
1426 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1427 TargetTriple.getOS() == llvm::Triple::Linux &&
1428 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1431 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1432 TargetTriple.getOS() == llvm::Triple::Linux &&
1433 TargetTriple.isGNUEnvironment())
1436 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1437 TargetTriple.getOS() == llvm::Triple::Linux &&
1438 TargetTriple.isGNUEnvironment())
1447 Result.Multilibs.FilterOut(NonExistent);
1449 if (
Result.Multilibs.select(
D, Flags,
Result.SelectedMultilibs)) {
1458 const llvm::Triple &TargetTriple,
1459 StringRef
Path,
const ArgList &Args,
1462 FilterNonExistent NonExistent(
Path,
"/crtbegin.o",
D.getVFS());
1464 .
flag(
"-march=armv7-a")
1465 .
flag(
"-mthumb",
true);
1467 .
flag(
"-march=armv7-a",
true)
1473 .
flag(
"-march=armv7-a",
true)
1474 .
flag(
"-mthumb",
true);
1477 .
Either(ThumbMultilib, ArmV7Multilib, ArmV7ThumbMultilib,
1483 llvm::StringRef
Arch = Args.getLastArgValue(options::OPT_march_EQ);
1484 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1485 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1486 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1487 bool IsThumbMode = IsThumbArch ||
1488 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb,
false) ||
1489 (IsArmArch && llvm::ARM::parseArchISA(
Arch) == llvm::ARM::ISAKind::THUMB);
1490 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1491 (llvm::ARM::parseArchVersion(
Arch) == 7 ||
1492 (IsArmArch &&
Arch ==
"" && IsV7SubArch));
1493 addMultilibFlag(IsArmV7Mode,
"-march=armv7-a", Flags);
1494 addMultilibFlag(IsThumbMode,
"-mthumb", Flags);
1496 if (AndroidArmMultilibs.
select(
D, Flags,
Result.SelectedMultilibs))
1497 Result.Multilibs = AndroidArmMultilibs;
1501 const llvm::Triple &TargetTriple,
1502 StringRef
Path,
const ArgList &Args,
1504 FilterNonExistent NonExistent(
Path,
"/crtbegin.o",
D.getVFS());
1516 Result.Multilibs.FilterOut(NonExistent);
1519 addMultilibFlag(Args.hasFlag(options::OPT_fexceptions,
1520 options::OPT_fno_exceptions,
false),
1521 "-exceptions", Flags);
1522 if (
Result.Multilibs.select(
D, Flags,
Result.SelectedMultilibs))
1529 StringRef
Path,
const ArgList &Args,
1531 FilterNonExistent NonExistent(
Path,
"/crtbegin.o",
D.getVFS());
1534 std::optional<llvm::StringRef> Res =
1539 auto ARCHName = *Res;
1547 addMultilibFlag(ARCHName ==
"ck801",
"-march=ck801", Flags);
1548 addMultilibFlag(ARCHName ==
"ck802",
"-march=ck802", Flags);
1549 addMultilibFlag(ARCHName ==
"ck803",
"-march=ck803", Flags);
1550 addMultilibFlag(ARCHName ==
"ck804",
"-march=ck804", Flags);
1551 addMultilibFlag(ARCHName ==
"ck805",
"-march=ck805", Flags);
1552 addMultilibFlag(ARCHName ==
"ck807",
"-march=ck807", Flags);
1553 addMultilibFlag(ARCHName ==
"ck810",
"-march=ck810", Flags);
1554 addMultilibFlag(ARCHName ==
"ck810v",
"-march=ck810v", Flags);
1555 addMultilibFlag(ARCHName ==
"ck860",
"-march=ck860", Flags);
1556 addMultilibFlag(ARCHName ==
"ck860v",
"-march=ck860v", Flags);
1558 bool isBigEndian =
false;
1559 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
1560 options::OPT_mbig_endian))
1561 isBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
1562 addMultilibFlag(isBigEndian,
"-EB", Flags);
1583 .
Either({Arch801, Arch802, Arch803, Arch804, Arch805, Arch807,
1584 Arch810, Arch810v, Arch860, Arch860v})
1585 .Either(HardFloat, SoftFpFloat, SoftFloat)
1589 if (CSKYMultilibs.
select(
D, Flags,
Result.SelectedMultilibs))
1590 Result.Multilibs = CSKYMultilibs;
1608 if (RISCVMultilibSet.
select(
D, Flags, SelectedMultilibs))
1612 std::vector<MultilibBuilder> NewMultilibs;
1615 llvm::RISCVISAInfo::parseArchString(
1619 if (llvm::errorToBool(ParseResult.takeError()))
1622 auto &ISAInfo = *ParseResult;
1624 addMultilibFlag(ISAInfo->getXLen() == 32,
"-m32", NewFlags);
1625 addMultilibFlag(ISAInfo->getXLen() == 64,
"-m64", NewFlags);
1628 for (StringRef Flag : Flags) {
1629 if (Flag.starts_with(
"!march=") || Flag.starts_with(
"-march="))
1632 NewFlags.push_back(Flag.str());
1635 llvm::StringSet<> AllArchExts;
1638 for (
const auto &M : RISCVMultilibSet) {
1643 for (StringRef Flag : M.flags()) {
1645 if (!Flag.consume_front(
"-march=")) {
1646 NewMultilib.
flag(Flag);
1652 llvm::RISCVISAInfo::parseArchString(
1656 if (llvm::errorToBool(MLConfigParseResult.takeError())) {
1662 auto &MLConfigISAInfo = *MLConfigParseResult;
1664 for (
auto &MLConfigArchExt : MLConfigISAInfo->getExtensions()) {
1665 auto ExtName = MLConfigArchExt.first;
1666 NewMultilib.
flag(Twine(
"-", ExtName).str());
1668 if (AllArchExts.insert(ExtName).second) {
1669 addMultilibFlag(ISAInfo->hasExtension(ExtName),
1670 Twine(
"-", ExtName).str(), NewFlags);
1675 if (MLConfigISAInfo->getXLen() == 32) {
1676 NewMultilib.
flag(
"-m32");
1677 NewMultilib.
flag(
"-m64",
true);
1679 NewMultilib.
flag(
"-m32",
true);
1680 NewMultilib.
flag(
"-m64");
1685 if (!MLConfigISAInfo->hasExtension(
"a"))
1686 NewMultilib.
flag(
"-a",
true);
1692 NewMultilibs.emplace_back(NewMultilib);
1700 if (NewRISCVMultilibs.
select(
D, NewFlags, SelectedMultilibs))
1701 for (
const Multilib &NewSelectedM : SelectedMultilibs)
1702 for (
const auto &M : RISCVMultilibSet)
1704 if (M.gccSuffix() == NewSelectedM.gccSuffix())
1711 const llvm::Triple &TargetTriple,
1712 StringRef
Path,
const ArgList &Args,
1714 FilterNonExistent NonExistent(
Path,
"/crtbegin.o",
D.getVFS());
1715 struct RiscvMultilib {
1721 constexpr RiscvMultilib RISCVMultilibSet[] = {
1722 {
"rv32i",
"ilp32"}, {
"rv32im",
"ilp32"}, {
"rv32iac",
"ilp32"},
1723 {
"rv32imac",
"ilp32"}, {
"rv32imafc",
"ilp32f"}, {
"rv64imac",
"lp64"},
1724 {
"rv64imafdc",
"lp64d"}};
1726 std::vector<MultilibBuilder> Ms;
1727 for (
auto Element : RISCVMultilibSet) {
1731 (Twine(Element.march) +
"/" + Twine(Element.mabi)).str())
1732 .
flag(Twine(
"-march=", Element.march).str())
1733 .
flag(Twine(
"-mabi=", Element.mabi).str()));
1741 return std::vector<std::string>(
1743 "/../../../../riscv64-unknown-elf/lib" + M.
gccSuffix(),
1744 "/../../../../riscv32-unknown-elf/lib" + M.
gccSuffix()});
1748 llvm::StringSet<> Added_ABIs;
1751 for (
auto Element : RISCVMultilibSet) {
1752 addMultilibFlag(MArch == Element.march,
1753 Twine(
"-march=", Element.march).str().c_str(), Flags);
1754 if (!Added_ABIs.count(Element.mabi)) {
1755 Added_ABIs.insert(Element.mabi);
1756 addMultilibFlag(ABIName == Element.mabi,
1757 Twine(
"-mabi=", Element.mabi).str().c_str(), Flags);
1762 Result.SelectedMultilibs))
1763 Result.Multilibs = RISCVMultilibs;
1767 const llvm::Triple &TargetTriple, StringRef
Path,
1769 if (TargetTriple.getOS() == llvm::Triple::UnknownOS)
1772 FilterNonExistent NonExistent(
Path,
"/crtbegin.o",
D.getVFS());
1787 .
Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1792 bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1795 addMultilibFlag(!IsRV64,
"-m32", Flags);
1796 addMultilibFlag(IsRV64,
"-m64", Flags);
1797 addMultilibFlag(ABIName ==
"ilp32",
"-mabi=ilp32", Flags);
1798 addMultilibFlag(ABIName ==
"ilp32f",
"-mabi=ilp32f", Flags);
1799 addMultilibFlag(ABIName ==
"ilp32d",
"-mabi=ilp32d", Flags);
1800 addMultilibFlag(ABIName ==
"lp64",
"-mabi=lp64", Flags);
1801 addMultilibFlag(ABIName ==
"lp64f",
"-mabi=lp64f", Flags);
1802 addMultilibFlag(ABIName ==
"lp64d",
"-mabi=lp64d", Flags);
1804 if (RISCVMultilibs.
select(
D, Flags,
Result.SelectedMultilibs))
1805 Result.Multilibs = RISCVMultilibs;
1809 const llvm::Triple &TargetTriple,
1810 StringRef
Path,
const ArgList &Args,
1811 bool NeedsBiarchSuffix,
1822 StringRef Suff64 =
"/64";
1824 if (TargetTriple.isOSSolaris()) {
1825 switch (TargetTriple.getArch()) {
1826 case llvm::Triple::x86:
1827 case llvm::Triple::x86_64:
1830 case llvm::Triple::sparc:
1831 case llvm::Triple::sparcv9:
1832 Suff64 =
"/sparcv9";
1841 .includeSuffix(Suff64)
1844 .flag(
"-mx32",
true)
1848 .includeSuffix(
"/32")
1851 .flag(
"-mx32",
true)
1855 .includeSuffix(
"/x32")
1862 .includeSuffix(
"/sparcv8plus")
1868 FilterNonExistent NonExistent(
1869 Path, TargetTriple.isOSIAMCU() ?
"/libgcc.a" :
"/crtbegin.o",
D.getVFS());
1874 const bool IsX32 = TargetTriple.isX32();
1875 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1877 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32sparc))
1879 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1881 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1883 else if (TargetTriple.isArch64Bit() && !NonExistent(Alt32sparc))
1886 if (TargetTriple.isArch32Bit())
1887 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1889 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1891 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1895 DefaultBuilder.
flag(
"-m32")
1897 .
flag(
"-mx32",
true);
1898 else if (Want == WANT64)
1899 DefaultBuilder.
flag(
"-m32",
true)
1901 .
flag(
"-mx32",
true);
1902 else if (Want == WANTX32)
1903 DefaultBuilder.
flag(
"-m32",
true)
1912 Result.Multilibs.push_back(Alt64);
1913 Result.Multilibs.push_back(Alt32);
1914 Result.Multilibs.push_back(Altx32);
1915 Result.Multilibs.push_back(Alt32sparc);
1917 Result.Multilibs.FilterOut(NonExistent);
1920 addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32,
"-m64", Flags);
1921 addMultilibFlag(TargetTriple.isArch32Bit(),
"-m32", Flags);
1922 addMultilibFlag(TargetTriple.isArch64Bit() && IsX32,
"-mx32", Flags);
1924 if (!
Result.Multilibs.select(
D, Flags,
Result.SelectedMultilibs))
1927 if (
Result.SelectedMultilibs.back() == Alt64 ||
1928 Result.SelectedMultilibs.back() == Alt32 ||
1929 Result.SelectedMultilibs.back() == Altx32 ||
1930 Result.SelectedMultilibs.back() == Alt32sparc)
1943 StringRef RHSPatchSuffix)
const {
1944 if (Major != RHSMajor)
1945 return Major < RHSMajor;
1946 if (Minor != RHSMinor) {
1953 return Minor < RHSMinor;
1955 if (Patch != RHSPatch) {
1964 return Patch < RHSPatch;
1966 if (PatchSuffix != RHSPatchSuffix) {
1968 if (RHSPatchSuffix.empty())
1970 if (PatchSuffix.empty())
1974 return PatchSuffix < RHSPatchSuffix;
1986 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1987 std::pair<StringRef, StringRef>
First = VersionText.split(
'.');
1988 std::pair<StringRef, StringRef> Second =
First.second.split(
'.');
1990 StringRef MajorStr =
First.first;
1991 StringRef MinorStr = Second.first;
1992 StringRef PatchStr = Second.second;
1994 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
2010 auto TryParseLastNumber = [&](StringRef Segment,
int &Number,
2011 std::string &OutStr) ->
bool {
2015 if (
size_t EndNumber = Segment.find_first_not_of(
"0123456789")) {
2016 StringRef NumberStr = Segment.slice(0, EndNumber);
2017 if (NumberStr.getAsInteger(10, Number) || Number < 0)
2020 GoodVersion.
PatchSuffix = Segment.substr(EndNumber);
2025 auto TryParseNumber = [](StringRef Segment,
int &Number) ->
bool {
2026 if (Segment.getAsInteger(10, Number) || Number < 0)
2031 if (MinorStr.empty()) {
2033 if (!TryParseLastNumber(MajorStr, GoodVersion.
Major, GoodVersion.
MajorStr))
2038 if (!TryParseNumber(MajorStr, GoodVersion.
Major))
2042 if (PatchStr.empty()) {
2044 if (!TryParseLastNumber(MinorStr, GoodVersion.
Minor, GoodVersion.
MinorStr))
2049 if (!TryParseNumber(MinorStr, GoodVersion.
Minor))
2054 std::string DummyStr;
2055 TryParseLastNumber(PatchStr, GoodVersion.
Patch, DummyStr);
2060 llvm::StringRef SysRoot) {
2061 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
2063 return A->getValue();
2068 if (!SysRoot.empty())
2071 return GCC_INSTALL_PREFIX;
2084 const llvm::Triple &TargetTriple,
const ArgList &Args) {
2085 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
2086 ? TargetTriple.get64BitArchVariant()
2087 : TargetTriple.get32BitArchVariant();
2094 CandidateTripleAliases.push_back(TargetTriple.str());
2095 std::string TripleNoVendor, BiarchTripleNoVendor;
2096 if (TargetTriple.getVendor() == llvm::Triple::UnknownVendor) {
2097 StringRef OSEnv = TargetTriple.getOSAndEnvironmentName();
2098 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32)
2099 OSEnv =
"linux-gnu";
2100 TripleNoVendor = (TargetTriple.getArchName().str() +
'-' + OSEnv).str();
2101 CandidateTripleAliases.push_back(TripleNoVendor);
2102 if (BiarchVariantTriple.getArch() != llvm::Triple::UnknownArch) {
2103 BiarchTripleNoVendor =
2104 (BiarchVariantTriple.getArchName().str() +
'-' + OSEnv).str();
2105 CandidateBiarchTripleAliases.push_back(BiarchTripleNoVendor);
2109 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
2110 CandidateTripleAliases, CandidateBiarchLibDirs,
2111 CandidateBiarchTripleAliases);
2115 Args.getLastArg(clang::driver::options::OPT_gcc_install_dir_EQ);
2116 A && A->getValue()[0]) {
2117 StringRef InstallDir = A->getValue();
2118 if (!ScanGCCForMultilibs(TargetTriple, Args, InstallDir,
false)) {
2119 D.Diag(diag::err_drv_invalid_gcc_install_dir) << InstallDir;
2121 (void)InstallDir.consume_back(
"/");
2122 StringRef VersionText = llvm::sys::path::filename(InstallDir);
2123 StringRef TripleText =
2124 llvm::sys::path::filename(llvm::sys::path::parent_path(InstallDir));
2126 SelectedInstallation.Version = GCCVersion::Parse(VersionText);
2127 SelectedInstallation.GCCTriple.setTriple(TripleText);
2128 SelectedInstallation.GCCInstallPath = std::string(InstallDir);
2129 SelectedInstallation.GCCParentLibPath =
2130 SelectedInstallation.GCCInstallPath +
"/../../..";
2139 Args.getLastArg(clang::driver::options::OPT_gcc_triple_EQ)) {
2140 StringRef GCCTriple = A->getValue();
2141 CandidateTripleAliases.clear();
2142 CandidateTripleAliases.push_back(GCCTriple);
2148 if (GCCToolchainDir !=
"") {
2149 if (GCCToolchainDir.back() ==
'/')
2150 GCCToolchainDir = GCCToolchainDir.drop_back();
2152 Prefixes.push_back(std::string(GCCToolchainDir));
2155 if (!
D.SysRoot.empty()) {
2156 Prefixes.push_back(
D.SysRoot);
2157 AddDefaultGCCPrefixes(TargetTriple, Prefixes,
D.SysRoot);
2161 Prefixes.push_back(
D.Dir +
"/..");
2165 if (
D.SysRoot.empty()) {
2167 AddDefaultGCCPrefixes(TargetTriple, Prefixes,
D.SysRoot);
2179 GentooTestTriples.push_back(TargetTriple.str());
2180 GentooTestTriples.append(CandidateTripleAliases.begin(),
2181 CandidateTripleAliases.end());
2182 if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
2183 CandidateBiarchTripleAliases))
2189 const GCCVersion VersionZero = GCCVersion::Parse(
"0.0.0");
2190 SelectedInstallation.Version = VersionZero;
2191 for (
const std::string &Prefix : Prefixes) {
2192 auto &VFS =
D.getVFS();
2193 if (!VFS.exists(Prefix))
2195 for (StringRef Suffix : CandidateLibDirs) {
2196 const std::string LibDir = concat(Prefix, Suffix);
2197 if (!VFS.exists(LibDir))
2200 bool GCCDirExists = VFS.exists(LibDir +
"/gcc");
2201 bool GCCCrossDirExists = VFS.exists(LibDir +
"/gcc-cross");
2202 for (StringRef Candidate : CandidateTripleAliases)
2203 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
false,
2204 GCCDirExists, GCCCrossDirExists);
2206 for (StringRef Suffix : CandidateBiarchLibDirs) {
2207 const std::string LibDir = Prefix + Suffix.str();
2208 if (!VFS.exists(LibDir))
2210 bool GCCDirExists = VFS.exists(LibDir +
"/gcc");
2211 bool GCCCrossDirExists = VFS.exists(LibDir +
"/gcc-cross");
2212 for (StringRef Candidate : CandidateBiarchTripleAliases)
2213 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
true,
2214 GCCDirExists, GCCCrossDirExists);
2218 if (SelectedInstallation.Version > VersionZero)
2224 for (
const auto &InstallPath : CandidateGCCInstallPaths)
2225 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
2227 if (!SelectedInstallation.GCCInstallPath.empty())
2228 OS <<
"Selected GCC installation: " << SelectedInstallation.GCCInstallPath
2231 for (
const auto &
Multilib : Multilibs)
2232 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
2234 if (Multilibs.size() != 0 ||
2235 !SelectedInstallation.SelectedMultilib.
isDefault())
2236 OS <<
"Selected multilib: " << SelectedInstallation.SelectedMultilib
2241 if (BiarchSibling) {
2248void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
2250 StringRef SysRoot) {
2252 if (TargetTriple.isOSHaiku()) {
2253 Prefixes.push_back(concat(SysRoot,
"/boot/system/develop/tools"));
2257 if (TargetTriple.isOSSolaris()) {
2265 std::string PrefixDir = concat(SysRoot,
"/usr/gcc");
2267 for (llvm::vfs::directory_iterator LI =
D.getVFS().dir_begin(PrefixDir, EC),
2269 !EC && LI != LE; LI = LI.increment(EC)) {
2270 StringRef VersionText = llvm::sys::path::filename(LI->path());
2271 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2274 if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
2277 std::string CandidatePrefix = PrefixDir +
"/" + VersionText.str();
2278 std::string CandidateLibPath = CandidatePrefix +
"/lib/gcc";
2279 if (!
D.getVFS().exists(CandidateLibPath))
2282 SolarisPrefixes.emplace_back(
2283 std::make_pair(CandidateVersion, CandidatePrefix));
2286 std::sort(SolarisPrefixes.rbegin(), SolarisPrefixes.rend());
2287 for (
auto p : SolarisPrefixes)
2288 Prefixes.emplace_back(p.second);
2294 if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux &&
2295 D.getVFS().exists(
"/opt/rh")) {
2298 Prefixes.push_back(
"/opt/rh/gcc-toolset-12/root/usr");
2299 Prefixes.push_back(
"/opt/rh/gcc-toolset-11/root/usr");
2300 Prefixes.push_back(
"/opt/rh/gcc-toolset-10/root/usr");
2301 Prefixes.push_back(
"/opt/rh/devtoolset-12/root/usr");
2302 Prefixes.push_back(
"/opt/rh/devtoolset-11/root/usr");
2303 Prefixes.push_back(
"/opt/rh/devtoolset-10/root/usr");
2304 Prefixes.push_back(
"/opt/rh/devtoolset-9/root/usr");
2305 Prefixes.push_back(
"/opt/rh/devtoolset-8/root/usr");
2306 Prefixes.push_back(
"/opt/rh/devtoolset-7/root/usr");
2307 Prefixes.push_back(
"/opt/rh/devtoolset-6/root/usr");
2308 Prefixes.push_back(
"/opt/rh/devtoolset-4/root/usr");
2309 Prefixes.push_back(
"/opt/rh/devtoolset-3/root/usr");
2310 Prefixes.push_back(
"/opt/rh/devtoolset-2/root/usr");
2314 Prefixes.push_back(concat(SysRoot,
"/usr"));
2317 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
2318 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
2332 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
2333 static const char *
const AArch64Triples[] = {
2334 "aarch64-none-linux-gnu",
"aarch64-redhat-linux",
"aarch64-suse-linux"};
2335 static const char *
const AArch64beLibDirs[] = {
"/lib"};
2336 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu"};
2338 static const char *
const ARMLibDirs[] = {
"/lib"};
2339 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi"};
2340 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
2341 "armv7hl-redhat-linux-gnueabi",
2342 "armv6hl-suse-linux-gnueabi",
2343 "armv7hl-suse-linux-gnueabi"};
2344 static const char *
const ARMebLibDirs[] = {
"/lib"};
2345 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi"};
2346 static const char *
const ARMebHFTriples[] = {
2347 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
2349 static const char *
const AVRLibDirs[] = {
"/lib"};
2350 static const char *
const AVRTriples[] = {
"avr"};
2352 static const char *
const CSKYLibDirs[] = {
"/lib"};
2353 static const char *
const CSKYTriples[] = {
2354 "csky-linux-gnuabiv2",
"csky-linux-uclibcabiv2",
"csky-elf-noneabiv2"};
2356 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
2357 static const char *
const X86_64Triples[] = {
2358 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
2359 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
2360 "x86_64-redhat-linux",
"x86_64-suse-linux",
2361 "x86_64-manbo-linux-gnu",
"x86_64-slackware-linux",
2362 "x86_64-unknown-linux",
"x86_64-amazon-linux"};
2363 static const char *
const X32Triples[] = {
"x86_64-linux-gnux32",
2364 "x86_64-pc-linux-gnux32"};
2365 static const char *
const X32LibDirs[] = {
"/libx32",
"/lib"};
2366 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
2367 static const char *
const X86Triples[] = {
2368 "i586-linux-gnu",
"i686-linux-gnu",
"i686-pc-linux-gnu",
2369 "i386-redhat-linux6E",
"i686-redhat-linux",
"i386-redhat-linux",
2370 "i586-suse-linux",
"i686-montavista-linux",
2373 static const char *
const LoongArch64LibDirs[] = {
"/lib64",
"/lib"};
2374 static const char *
const LoongArch64Triples[] = {
2375 "loongarch64-linux-gnu",
"loongarch64-unknown-linux-gnu"};
2377 static const char *
const M68kLibDirs[] = {
"/lib"};
2378 static const char *
const M68kTriples[] = {
"m68k-unknown-linux-gnu",
2381 static const char *
const MIPSLibDirs[] = {
"/libo32",
"/lib"};
2382 static const char *
const MIPSTriples[] = {
2383 "mips-linux-gnu",
"mips-mti-linux",
"mips-mti-linux-gnu",
2384 "mips-img-linux-gnu",
"mipsisa32r6-linux-gnu"};
2385 static const char *
const MIPSELLibDirs[] = {
"/libo32",
"/lib"};
2386 static const char *
const MIPSELTriples[] = {
"mipsel-linux-gnu",
2387 "mips-img-linux-gnu"};
2389 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
2390 static const char *
const MIPS64Triples[] = {
2391 "mips-mti-linux-gnu",
"mips-img-linux-gnu",
"mips64-linux-gnuabi64",
2392 "mipsisa64r6-linux-gnu",
"mipsisa64r6-linux-gnuabi64"};
2393 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
2394 static const char *
const MIPS64ELTriples[] = {
2395 "mips-mti-linux-gnu",
"mips-img-linux-gnu",
"mips64el-linux-gnuabi64",
2396 "mipsisa64r6el-linux-gnu",
"mipsisa64r6el-linux-gnuabi64"};
2398 static const char *
const MIPSN32LibDirs[] = {
"/lib32"};
2399 static const char *
const MIPSN32Triples[] = {
"mips64-linux-gnuabin32",
2400 "mipsisa64r6-linux-gnuabin32"};
2401 static const char *
const MIPSN32ELLibDirs[] = {
"/lib32"};
2402 static const char *
const MIPSN32ELTriples[] = {
2403 "mips64el-linux-gnuabin32",
"mipsisa64r6el-linux-gnuabin32"};
2405 static const char *
const MSP430LibDirs[] = {
"/lib"};
2406 static const char *
const MSP430Triples[] = {
"msp430-elf"};
2408 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
2409 static const char *
const PPCTriples[] = {
2410 "powerpc-unknown-linux-gnu",
2413 "powerpc64-suse-linux",
"powerpc-montavista-linuxspe"};
2414 static const char *
const PPCLELibDirs[] = {
"/lib32",
"/lib"};
2415 static const char *
const PPCLETriples[] = {
"powerpcle-unknown-linux-gnu",
2416 "powerpcle-linux-musl"};
2418 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
2419 static const char *
const PPC64Triples[] = {
"powerpc64-unknown-linux-gnu",
2420 "powerpc64-suse-linux",
2421 "ppc64-redhat-linux"};
2422 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
2423 static const char *
const PPC64LETriples[] = {
2424 "powerpc64le-unknown-linux-gnu",
"powerpc64le-none-linux-gnu",
2425 "powerpc64le-suse-linux",
"ppc64le-redhat-linux"};
2427 static const char *
const RISCV32LibDirs[] = {
"/lib32",
"/lib"};
2428 static const char *
const RISCV32Triples[] = {
"riscv32-unknown-linux-gnu",
2429 "riscv32-unknown-elf"};
2430 static const char *
const RISCV64LibDirs[] = {
"/lib64",
"/lib"};
2431 static const char *
const RISCV64Triples[] = {
"riscv64-unknown-linux-gnu",
2432 "riscv64-unknown-elf"};
2434 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
2435 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
2436 "sparcv8-linux-gnu"};
2437 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
2438 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
2439 "sparcv9-linux-gnu"};
2441 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
2442 static const char *
const SystemZTriples[] = {
2443 "s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
"s390x-suse-linux",
2444 "s390x-redhat-linux"};
2449 if (TargetTriple.isOSSolaris()) {
2450 static const char *
const SolarisLibDirs[] = {
"/lib"};
2451 static const char *
const SolarisSparcV8Triples[] = {
2452 "sparc-sun-solaris2.11"};
2453 static const char *
const SolarisSparcV9Triples[] = {
2454 "sparcv9-sun-solaris2.11"};
2455 static const char *
const SolarisX86Triples[] = {
"i386-pc-solaris2.11"};
2456 static const char *
const SolarisX86_64Triples[] = {
"x86_64-pc-solaris2.11"};
2457 LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2458 BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2459 switch (TargetTriple.getArch()) {
2460 case llvm::Triple::x86:
2461 TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
2462 BiarchTripleAliases.append(begin(SolarisX86_64Triples),
2463 end(SolarisX86_64Triples));
2465 case llvm::Triple::x86_64:
2466 TripleAliases.append(begin(SolarisX86_64Triples),
2467 end(SolarisX86_64Triples));
2468 BiarchTripleAliases.append(begin(SolarisX86Triples),
2469 end(SolarisX86Triples));
2471 case llvm::Triple::sparc:
2472 TripleAliases.append(begin(SolarisSparcV8Triples),
2473 end(SolarisSparcV8Triples));
2474 BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2475 end(SolarisSparcV9Triples));
2477 case llvm::Triple::sparcv9:
2478 TripleAliases.append(begin(SolarisSparcV9Triples),
2479 end(SolarisSparcV9Triples));
2480 BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2481 end(SolarisSparcV8Triples));
2490 if (TargetTriple.isAndroid()) {
2491 static const char *
const AArch64AndroidTriples[] = {
2492 "aarch64-linux-android"};
2493 static const char *
const ARMAndroidTriples[] = {
"arm-linux-androideabi"};
2494 static const char *
const X86AndroidTriples[] = {
"i686-linux-android"};
2495 static const char *
const X86_64AndroidTriples[] = {
"x86_64-linux-android"};
2497 switch (TargetTriple.getArch()) {
2498 case llvm::Triple::aarch64:
2499 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2500 TripleAliases.append(begin(AArch64AndroidTriples),
2501 end(AArch64AndroidTriples));
2503 case llvm::Triple::arm:
2504 case llvm::Triple::thumb:
2505 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2506 TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2508 case llvm::Triple::x86_64:
2509 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2510 TripleAliases.append(begin(X86_64AndroidTriples),
2511 end(X86_64AndroidTriples));
2512 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2513 BiarchTripleAliases.append(begin(X86AndroidTriples),
2514 end(X86AndroidTriples));
2516 case llvm::Triple::x86:
2517 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2518 TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
2519 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2520 BiarchTripleAliases.append(begin(X86_64AndroidTriples),
2521 end(X86_64AndroidTriples));
2530 if (TargetTriple.isOSHurd()) {
2531 switch (TargetTriple.getArch()) {
2532 case llvm::Triple::x86_64:
2533 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2534 TripleAliases.push_back(
"x86_64-gnu");
2536 case llvm::Triple::x86:
2537 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2538 TripleAliases.push_back(
"i686-gnu");
2547 if (TargetTriple.isWindowsCygwinEnvironment()) {
2548 LibDirs.push_back(
"/lib");
2549 switch (TargetTriple.getArch()) {
2550 case llvm::Triple::x86_64:
2551 TripleAliases.append({
"x86_64-pc-cygwin",
"x86_64-pc-msys"});
2553 case llvm::Triple::x86:
2554 TripleAliases.append({
"i686-pc-cygwin",
"i686-pc-msys"});
2563 switch (TargetTriple.getArch()) {
2564 case llvm::Triple::aarch64:
2565 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2566 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2567 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2568 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2570 case llvm::Triple::aarch64_be:
2571 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2572 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2573 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2574 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2576 case llvm::Triple::arm:
2577 case llvm::Triple::thumb:
2578 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2579 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF ||
2580 TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHFT64 ||
2581 TargetTriple.getEnvironment() == llvm::Triple::MuslEABIHF ||
2582 TargetTriple.getEnvironment() == llvm::Triple::EABIHF) {
2583 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2585 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2588 case llvm::Triple::armeb:
2589 case llvm::Triple::thumbeb:
2590 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2591 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF ||
2592 TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHFT64 ||
2593 TargetTriple.getEnvironment() == llvm::Triple::MuslEABIHF ||
2594 TargetTriple.getEnvironment() == llvm::Triple::EABIHF) {
2595 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2597 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2600 case llvm::Triple::avr:
2601 LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs));
2602 TripleAliases.append(begin(AVRTriples), end(AVRTriples));
2604 case llvm::Triple::csky:
2605 LibDirs.append(begin(CSKYLibDirs), end(CSKYLibDirs));
2606 TripleAliases.append(begin(CSKYTriples), end(CSKYTriples));
2608 case llvm::Triple::x86_64:
2609 if (TargetTriple.isX32()) {
2610 LibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2611 TripleAliases.append(begin(X32Triples), end(X32Triples));
2612 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2613 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2615 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2616 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2617 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2618 BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
2620 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2621 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2623 case llvm::Triple::x86:
2624 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2627 if (!TargetTriple.isOSIAMCU()) {
2628 TripleAliases.append(begin(X86Triples), end(X86Triples));
2629 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2630 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2631 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2632 BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
2636 case llvm::Triple::loongarch64:
2637 LibDirs.append(begin(LoongArch64LibDirs), end(LoongArch64LibDirs));
2638 TripleAliases.append(begin(LoongArch64Triples), end(LoongArch64Triples));
2640 case llvm::Triple::m68k:
2641 LibDirs.append(begin(M68kLibDirs), end(M68kLibDirs));
2642 TripleAliases.append(begin(M68kTriples), end(M68kTriples));
2644 case llvm::Triple::mips:
2645 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2646 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2647 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2648 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2649 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2650 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2652 case llvm::Triple::mipsel:
2653 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2654 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2655 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2656 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2657 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2658 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2659 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2661 case llvm::Triple::mips64:
2662 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2663 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2664 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2665 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2666 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2667 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2669 case llvm::Triple::mips64el:
2670 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2671 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2672 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2673 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2674 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2675 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2676 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2678 case llvm::Triple::msp430:
2679 LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2680 TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2682 case llvm::Triple::ppc:
2683 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2684 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2685 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2686 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2688 case llvm::Triple::ppcle:
2689 LibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs));
2690 TripleAliases.append(begin(PPCLETriples), end(PPCLETriples));
2691 BiarchLibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2692 BiarchTripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2694 case llvm::Triple::ppc64:
2695 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2696 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2697 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2698 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2700 case llvm::Triple::ppc64le:
2701 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2702 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2703 BiarchLibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs));
2704 BiarchTripleAliases.append(begin(PPCLETriples), end(PPCLETriples));
2706 case llvm::Triple::riscv32:
2707 LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2708 TripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2709 BiarchLibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2710 BiarchTripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2712 case llvm::Triple::riscv64:
2713 LibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2714 TripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2715 BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2716 BiarchTripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2718 case llvm::Triple::sparc:
2719 case llvm::Triple::sparcel:
2720 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2721 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2722 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2723 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2725 case llvm::Triple::sparcv9:
2726 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2727 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2728 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2729 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2731 case llvm::Triple::systemz:
2732 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2733 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2742 if (TargetTriple.str() != BiarchTriple.str())
2743 BiarchTripleAliases.push_back(BiarchTriple.str());
2746bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2747 const llvm::Triple &TargetTriple,
const ArgList &Args,
2748 StringRef
Path,
bool NeedsBiarchSuffix) {
2749 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2758 }
else if (TargetTriple.isCSKY()) {
2760 }
else if (TargetTriple.isMIPS()) {
2763 }
else if (TargetTriple.isRISCV()) {
2767 }
else if (TargetArch == llvm::Triple::avr) {
2770 NeedsBiarchSuffix, Detected)) {
2775 SelectedInstallation.SelectedMultilib =
2777 : Detected.SelectedMultilibs.back();
2783bool Generic_GCC::GCCInstallationDetector::SelectGCCInstallationDirectory(
2785 const ArgList &Args,
2787 if (Installations.empty())
2790 SelectedInstallation =
2791 *max_element(Installations, [](
const auto &
Max,
const auto &I) {
2792 return I.Version >
Max.Version;
2799 const GCCInstallCandidate *InstallWithIncludes =
nullptr;
2800 for (
const auto &I : Installations) {
2801 if ((!InstallWithIncludes || I.Version > InstallWithIncludes->Version) &&
2802 GCCInstallationHasLibStdcxxIncludePaths(I, Args))
2803 InstallWithIncludes = &I;
2806 if (InstallWithIncludes && SelectedInstallation.
GCCInstallPath !=
2807 InstallWithIncludes->GCCInstallPath)
2808 D.Diag(diag::warn_drv_gcc_install_dir_libstdcxx)
2809 << InstallWithIncludes->GCCInstallPath
2819void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2820 const llvm::Triple &TargetTriple,
const ArgList &Args,
2821 const std::string &LibDir, StringRef CandidateTriple,
2822 bool NeedsBiarchSuffix,
bool GCCDirExists,
bool GCCCrossDirExists) {
2825 struct GCCLibSuffix {
2827 std::string LibSuffix;
2830 StringRef ReversePath;
2835 {
"gcc/" + CandidateTriple.str(),
"../..", GCCDirExists},
2838 {
"gcc-cross/" + CandidateTriple.str(),
"../..", GCCCrossDirExists},
2844 {CandidateTriple.str(),
"..",
2845 TargetTriple.getVendor() == llvm::Triple::Freescale ||
2846 TargetTriple.getVendor() == llvm::Triple::OpenEmbedded}};
2853 StringRef LibSuffix = Suffix.LibSuffix;
2855 for (llvm::vfs::directory_iterator
2856 LI =
D.getVFS().dir_begin(LibDir +
"/" + LibSuffix, EC),
2858 !EC && LI != LE; LI = LI.increment(EC)) {
2859 StringRef VersionText = llvm::sys::path::filename(LI->path());
2860 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2861 if (CandidateVersion.Major != -1)
2862 if (!CandidateGCCInstallPaths.insert(std::string(LI->path())).second)
2864 if (CandidateVersion.isOlderThan(4, 1, 1))
2866 if (CandidateVersion <= SelectedInstallation.
Version && IsValid)
2869 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
2873 GCCInstallCandidate Installation;
2874 Installation.Version = CandidateVersion;
2875 Installation.GCCTriple.setTriple(CandidateTriple);
2879 Installation.GCCInstallPath =
2880 (LibDir +
"/" + LibSuffix +
"/" + VersionText).str();
2881 Installation.GCCParentLibPath =
2882 (Installation.GCCInstallPath +
"/../" + Suffix.ReversePath).str();
2883 Installation.SelectedMultilib = getMultilib();
2885 Installations.push_back(Installation);
2890 SelectGCCInstallationDirectory(Installations, Args, SelectedInstallation);
2893bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
2894 const llvm::Triple &TargetTriple,
const ArgList &Args,
2897 if (!
D.getVFS().exists(concat(
D.SysRoot, GentooConfigDir)))
2900 for (StringRef CandidateTriple : CandidateTriples) {
2901 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
2905 for (StringRef CandidateTriple : CandidateBiarchTriples) {
2906 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple,
true))
2912bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2913 const llvm::Triple &TargetTriple,
const ArgList &Args,
2914 StringRef CandidateTriple,
bool NeedsBiarchSuffix) {
2915 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
File =
2916 D.getVFS().getBufferForFile(concat(
D.SysRoot, GentooConfigDir,
2917 "/config-" + CandidateTriple.str()));
2920 File.get()->getBuffer().split(Lines,
"\n");
2921 for (StringRef
Line : Lines) {
2924 if (!
Line.consume_front(
"CURRENT="))
2927 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
2928 D.getVFS().getBufferForFile(
2929 concat(
D.SysRoot, GentooConfigDir,
"/" +
Line));
2930 std::pair<StringRef, StringRef> ActiveVersion =
Line.rsplit(
'-');
2943 ConfigFile.get()->getBuffer().split(ConfigLines,
"\n");
2944 for (StringRef ConfLine : ConfigLines) {
2945 ConfLine = ConfLine.trim();
2946 if (ConfLine.consume_front(
"LDPATH=")) {
2948 ConfLine.consume_back(
"\"");
2949 ConfLine.consume_front(
"\"");
2951 ConfLine.split(GentooScanPaths,
':', -1,
false);
2956 std::string basePath =
"/usr/lib/gcc/" + ActiveVersion.first.str() +
"/"
2957 + ActiveVersion.second.str();
2958 GentooScanPaths.push_back(StringRef(basePath));
2961 for (
const auto &GentooScanPath : GentooScanPaths) {
2962 std::string GentooPath = concat(
D.SysRoot, GentooScanPath);
2963 if (
D.getVFS().exists(GentooPath +
"/crtbegin.o")) {
2964 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2968 SelectedInstallation.
Version =
2969 GCCVersion::Parse(ActiveVersion.second);
2972 GentooPath + std::string(
"/../../..");
2973 SelectedInstallation.
GCCTriple.setTriple(ActiveVersion.first);
2985 const ArgList &Args)
2987 CudaInstallation(
D, Triple, Args), RocmInstallation(
D, Triple, Args),
2988 SYCLInstallation(
D, Triple, Args) {
2999 return Preprocess.get();
3003 return Compile.get();
3025 case llvm::Triple::aarch64:
3026 case llvm::Triple::aarch64_be:
3027 case llvm::Triple::ppc:
3028 case llvm::Triple::ppcle:
3029 case llvm::Triple::ppc64:
3030 case llvm::Triple::ppc64le:
3031 case llvm::Triple::riscv32:
3032 case llvm::Triple::riscv64:
3033 case llvm::Triple::x86:
3034 case llvm::Triple::x86_64:
3043 case llvm::Triple::x86_64:
3045 case llvm::Triple::mips64:
3046 case llvm::Triple::mips64el:
3063 case llvm::Triple::nvptx:
3064 case llvm::Triple::nvptx64:
3065 case llvm::Triple::xcore:
3088 const std::string &SysRoot,
3089 const std::string &OSLibDir,
3090 const std::string &MultiarchTriple,
3096 const std::string &LibPath =
3135 LibPath +
"/../" + GCCTriple.str() +
"/lib/../" + OSLibDir +
3148 if (StringRef(LibPath).starts_with(SysRoot))
3149 addPathIfExists(
D, LibPath +
"/../" + OSLibDir, Paths);
3154 const std::string &SysRoot,
3155 const std::string &OSLibDir,
3158 const std::string &LibPath =
3169 ArgStringList &CC1Args)
const {
3177 Twine(LibPath) +
"/../" + GCCTriple.str() +
3189 ArgStringList &CC1Args)
const {
3190 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdincxx,
3191 options::OPT_nostdlibinc))
3206 ArgStringList &CC1Args)
const {
3212 llvm::opt::ArgStringList &CC1Args)
const {
3215 if (SysRoot.empty())
3216 SysRoot = llvm::sys::path::get_separator();
3218 auto AddIncludePath = [&](StringRef
Path,
bool TargetDirRequired =
false) {
3220 if (Version.empty())
3224 bool TargetDirExists =
false;
3226 if (TargetIncludeDir) {
3228 llvm::sys::path::append(TargetDir,
"c++", Version);
3229 if (
D.getVFS().exists(TargetDir)) {
3231 TargetDirExists =
true;
3234 if (TargetDirRequired && !TargetDirExists)
3239 llvm::sys::path::append(GenericDir,
"c++", Version);
3248 llvm::sys::path::append(DriverIncludeDir,
"..",
"include");
3249 if (AddIncludePath(DriverIncludeDir,
3256 llvm::sys::path::append(UsrLocalIncludeDir,
"usr",
"local",
"include");
3257 if (AddIncludePath(UsrLocalIncludeDir))
3260 llvm::sys::path::append(UsrIncludeDir,
"usr",
"include");
3261 if (AddIncludePath(UsrIncludeDir))
3266 Twine IncludeDir, StringRef Triple,
3267 Twine IncludeSuffix,
3268 const llvm::opt::ArgList &DriverArgs,
3269 llvm::opt::ArgStringList &CC1Args,
3270 bool DetectDebian =
false) {
3272 if (!vfs.exists(IncludeDir))
3278 std::string Dir = IncludeDir.str();
3280 llvm::sys::path::parent_path(llvm::sys::path::parent_path(Dir));
3282 (Include +
"/" + Triple + Dir.substr(Include.size()) + IncludeSuffix)
3284 if (DetectDebian && !vfs.exists(
Path))
3293 else if (!Triple.empty())
3295 IncludeDir +
"/" + Triple + IncludeSuffix);
3302 Twine IncludeSuffix,
3303 const llvm::opt::ArgList &DriverArgs,
3304 llvm::opt::ArgStringList &CC1Args,
3305 bool DetectDebian)
const {
3306 return ::addLibStdCXXIncludePaths(
getVFS(), IncludeDir, Triple, IncludeSuffix,
3307 DriverArgs, CC1Args, DetectDebian);
3311 llvm::vfs::FileSystem &vfs,
const llvm::opt::ArgList &DriverArgs,
3312 llvm::opt::ArgStringList &CC1Args, StringRef DebianMultiarch)
const {
3319 StringRef TripleStr =
getTriple().str();
3326 LibDir.str() +
"/../" + TripleStr +
"/include/c++/" +
Version.
Text,
3334 LibDir.str() +
"/gcc/" + TripleStr +
"/" +
3337 DriverArgs, CC1Args))
3342 vfs, LibDir.str() +
"/../include/c++/" +
Version.
Text,
3349 vfs, LibDir.str() +
"/../include/c++/" +
Version.
Text, TripleStr,
3355 const std::string LibStdCXXIncludePathCandidates[] = {
3358 InstallDir.str() +
"/include/g++-v" +
Version.
Text,
3364 for (
const auto &IncludePath : LibStdCXXIncludePathCandidates) {
3373bool Generic_GCC::GCCInstallationDetector::
3374 GCCInstallationHasLibStdcxxIncludePaths(
3376 const llvm::opt::ArgList &DriverArgs)
const {
3377 StringRef DebianMultiarch =
3383 llvm::opt::ArgStringList dummyCC1Args;
3385 D.getVFS(), DriverArgs, dummyCC1Args, DebianMultiarch);
3389 const llvm::opt::ArgList &DriverArgs,
3390 llvm::opt::ArgStringList &CC1Args)
const {
3394 StringRef DebianMultiarch =
3398 getVFS(), DriverArgs, CC1Args, DebianMultiarch);
3403 llvm::opt::ArgStringList &CC1Args)
const {
3411llvm::opt::DerivedArgList *
3413 StringRef BoundArch,
3419 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
3423 const llvm::DenseSet<unsigned> OpenMPFiltered{
3424 options::OPT_shared, options::OPT_dynamic, options::OPT_static,
3425 options::OPT_fPIE, options::OPT_fno_PIE, options::OPT_fpie,
3426 options::OPT_fno_pie};
3427 for (
auto *A : Args)
3429 !OpenMPFiltered.contains(A->getOption().getID()))
3436 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_shared));
3437 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_fPIC));
3441 if (!BoundArch.empty()) {
3444 ? options::OPT_mcpu_EQ
3445 : options::OPT_march_EQ;
3447 DAL->AddJoinedArg(
nullptr, Opts.getOption(Opt), BoundArch);
3452void Generic_ELF::anchor() {}
3455 ArgStringList &CC1Args,
3457 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
3458 options::OPT_fno_use_init_array,
true))
3459 CC1Args.push_back(
"-fno-use-init-array");
static constexpr CPUSuffix Suffixes[]
static void findCSKYMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
static void findAndroidArmMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
static bool findMipsCsMultilibs(const Driver &D, const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static bool isArmOrThumbArch(llvm::Triple::ArchType Arch)
static bool selectRISCVMultilib(const Driver &D, const MultilibSet &RISCVMultilibSet, StringRef Arch, const Multilib::flags_list &Flags, llvm::SmallVectorImpl< Multilib > &SelectedMultilibs)
Extend the multi-lib re-use selection mechanism for RISC-V.
static void normalizeCPUNamesForAssembler(const ArgList &Args, ArgStringList &CmdArgs)
static bool findBiarchMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, bool NeedsBiarchSuffix, DetectedMultilibs &Result)
static bool isMips16(const ArgList &Args)
static llvm::StringRef getGCCToolchainDir(const ArgList &Args, llvm::StringRef SysRoot)
static bool findMSP430Multilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
static bool getStatic(const ArgList &Args)
static bool isMipsEL(llvm::Triple::ArchType Arch)
static bool findMipsMuslMultilibs(const Driver &D, const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static void findRISCVBareMetalMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
static bool isMSP430(llvm::Triple::ArchType Arch)
static bool isSoftFloatABI(const ArgList &Args)
static bool addLibStdCXXIncludePaths(llvm::vfs::FileSystem &vfs, Twine IncludeDir, StringRef Triple, Twine IncludeSuffix, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, bool DetectDebian=false)
static bool findMipsImgMultilibs(const Driver &D, const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static bool forwardToGCC(const Option &O)
static bool findMipsMtiMultilibs(const Driver &D, const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static bool isMicroMips(const ArgList &Args)
types::ID getType() const
bool isHostOffloading(unsigned int OKind) const
Check if this action have any offload kinds.
Compilation - A set of tasks to perform for a single driver invocation.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
const llvm::opt::OptTable & getOpts() const
This corresponds to a single GCC multilib, or a segment of one controlled by a command line flag.
MultilibBuilder & flag(StringRef Flag, bool Disallow=false)
Add a flag to the flags list Flag must be a flag accepted by the driver.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
Multilib makeMultilib() const
This class can be used to create a MultilibSet, and contains helper functions to add combinations of ...
MultilibSetBuilder & Maybe(const MultilibBuilder &M)
Add an optional Multilib segment.
MultilibSetBuilder & FilterOut(const char *Regex)
Filter out those Multilibs whose gccSuffix matches the given expression.
MultilibSetBuilder & Either(const MultilibBuilder &M1, const MultilibBuilder &M2)
Add a set of mutually incompatible Multilib segments.
MultilibSet makeMultilibSet() const
See also MultilibSetBuilder for combining multilibs into a set.
bool select(const Driver &D, const Multilib::flags_list &Flags, llvm::SmallVectorImpl< Multilib > &, llvm::SmallVector< StringRef > *=nullptr) const
Select compatible variants,.
MultilibSet & setFilePathsCallback(IncludeDirsFunc F)
MultilibSet & FilterOut(FilterCallback F)
Filter out some subset of the Multilibs using a user defined callback.
const IncludeDirsFunc & filePathsCallback() const
const IncludeDirsFunc & includeDirsCallback() const
MultilibSet & setIncludeDirsCallback(IncludeDirsFunc F)
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
std::vector< std::string > flags_list
const std::string & includeSuffix() const
Get the include directory suffix.
bool isDefault() const
Check whether the default is selected.
bool isLLVMIR(ID Id)
Is this LLVM IR.
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
bool canTypeBeUserSpecified(ID Id)
canTypeBeUserSpecified - Can this type be specified on the command line (by the type name); this is u...
bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const llvm::opt::ArgList &Args, DetectedMultilibs &Result)
The JSON file list parser is used to communicate input to InstallAPI.
@ Result
The result type of a method or function.
MultilibSet Multilibs
The set of multilibs that the detected installation supports.
std::optional< Multilib > BiarchSibling
On Biarch systems, this corresponds to the default multilib when targeting the non-default multilib.
llvm::SmallVector< Multilib > SelectedMultilibs
The multilibs appropriate for the given flags.
static constexpr ResponseFileSupport AtFileCurCP()