19 #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/TargetParser.h"
32 #include "llvm/Support/VirtualFileSystem.h"
33 #include <system_error>
37 using namespace clang;
54 ArgStringList &CmdArgs) {
55 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
56 StringRef CPUArg(A->getValue());
57 if (CPUArg.equals_insensitive(
"krait"))
58 CmdArgs.push_back(
"-mcpu=cortex-a15");
59 else if (CPUArg.equals_insensitive(
"kryo"))
60 CmdArgs.push_back(
"-mcpu=cortex-a57");
62 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
70 const char *LinkingOutput)
const {
71 const Driver &D = getToolChain().getDriver();
72 ArgStringList CmdArgs;
74 for (
const auto &A : Args) {
82 A->render(Args, CmdArgs);
86 RenderExtraToolArgs(JA, CmdArgs);
89 if (getToolChain().getTriple().isOSDarwin()) {
90 CmdArgs.push_back(
"-arch");
92 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
100 switch (getToolChain().getArch()) {
103 case llvm::Triple::x86:
104 case llvm::Triple::ppc:
105 case llvm::Triple::ppcle:
106 CmdArgs.push_back(
"-m32");
108 case llvm::Triple::x86_64:
109 case llvm::Triple::ppc64:
110 case llvm::Triple::ppc64le:
111 CmdArgs.push_back(
"-m64");
113 case llvm::Triple::sparcel:
114 CmdArgs.push_back(
"-EL");
119 CmdArgs.push_back(
"-o");
122 assert(Output.
isNothing() &&
"Unexpected output");
123 CmdArgs.push_back(
"-fsyntax-only");
126 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
136 for (
const auto &II : Inputs) {
139 D.
Diag(clang::diag::err_drv_no_linker_llvm_support)
140 << getToolChain().getTripleString();
141 else if (II.getType() == types::TY_AST)
142 D.
Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
143 else if (II.getType() == types::TY_ModuleFile)
144 D.
Diag(diag::err_drv_no_module_support)
145 << getToolChain().getTripleString();
148 CmdArgs.push_back(
"-x");
153 CmdArgs.push_back(II.getFilename());
155 const Arg &A = II.getInputArg();
158 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
159 CmdArgs.push_back(
"-lstdc++");
164 A.render(Args, CmdArgs);
170 if (!customGCCName.empty())
171 GCCName = customGCCName.c_str();
177 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
178 C.addCommand(std::make_unique<Command>(JA, *
this,
180 Exec, CmdArgs, Inputs, Output));
184 const JobAction &JA, ArgStringList &CmdArgs)
const {
185 CmdArgs.push_back(
"-E");
189 ArgStringList &CmdArgs)
const {
190 const Driver &D = getToolChain().getDriver();
194 case types::TY_LLVM_IR:
195 case types::TY_LTO_IR:
196 case types::TY_LLVM_BC:
197 case types::TY_LTO_BC:
198 CmdArgs.push_back(
"-c");
202 case types::TY_Object:
203 CmdArgs.push_back(
"-c");
205 case types::TY_PP_Asm:
206 CmdArgs.push_back(
"-S");
208 case types::TY_Nothing:
209 CmdArgs.push_back(
"-fsyntax-only");
217 ArgStringList &CmdArgs)
const {
226 const ArgList &Args) {
227 bool IsBigEndian =
false;
228 switch (Triple.getArch()) {
229 case llvm::Triple::armeb:
230 case llvm::Triple::thumbeb:
233 case llvm::Triple::arm:
234 case llvm::Triple::thumb:
235 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
236 options::OPT_mbig_endian))
237 IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
245 static const char *
getLDMOption(
const llvm::Triple &T,
const ArgList &Args) {
246 switch (T.getArch()) {
247 case llvm::Triple::x86:
251 case llvm::Triple::aarch64:
252 return "aarch64linux";
253 case llvm::Triple::aarch64_be:
254 return "aarch64linuxb";
255 case llvm::Triple::arm:
256 case llvm::Triple::thumb:
257 case llvm::Triple::armeb:
258 case llvm::Triple::thumbeb:
259 return isArmBigEndian(T, Args) ?
"armelfb_linux_eabi" :
"armelf_linux_eabi";
260 case llvm::Triple::m68k:
262 case llvm::Triple::ppc:
264 return "elf32ppclinux";
266 case llvm::Triple::ppcle:
268 return "elf32lppclinux";
270 case llvm::Triple::ppc64:
272 case llvm::Triple::ppc64le:
274 case llvm::Triple::riscv32:
275 return "elf32lriscv";
276 case llvm::Triple::riscv64:
277 return "elf64lriscv";
278 case llvm::Triple::sparc:
279 case llvm::Triple::sparcel:
280 return "elf32_sparc";
281 case llvm::Triple::sparcv9:
282 return "elf64_sparc";
283 case llvm::Triple::loongarch32:
284 return "elf32loongarch";
285 case llvm::Triple::loongarch64:
286 return "elf64loongarch";
287 case llvm::Triple::mips:
288 return "elf32btsmip";
289 case llvm::Triple::mipsel:
290 return "elf32ltsmip";
291 case llvm::Triple::mips64:
293 T.getEnvironment() == llvm::Triple::GNUABIN32)
294 return "elf32btsmipn32";
295 return "elf64btsmip";
296 case llvm::Triple::mips64el:
298 T.getEnvironment() == llvm::Triple::GNUABIN32)
299 return "elf32ltsmipn32";
300 return "elf64ltsmip";
301 case llvm::Triple::systemz:
303 case llvm::Triple::x86_64:
305 return "elf32_x86_64";
307 case llvm::Triple::ve:
309 case llvm::Triple::csky:
310 return "cskyelf_linux";
317 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) ||
318 Args.hasArg(options::OPT_r) || Args.hasArg(options::OPT_static_pie))
321 Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
325 return A->getOption().matches(options::OPT_pie);
329 bool HasStaticPIE = Args.hasArg(options::OPT_static_pie);
332 if (HasStaticPIE && Args.hasArg(options::OPT_nopie)) {
334 const llvm::opt::OptTable &Opts = D.
getOpts();
335 StringRef StaticPIEName = Opts.getOptionName(options::OPT_static_pie);
336 StringRef NoPIEName = Opts.getOptionName(options::OPT_nopie);
337 D.
Diag(diag::err_drv_cannot_mix_options) << StaticPIEName << NoPIEName;
343 return Args.hasArg(options::OPT_static) &&
344 !Args.hasArg(options::OPT_static_pie);
350 const char *LinkingOutput)
const {
351 const Driver &D = getToolChain().getDriver();
354 Args.ClaimAllArgs(options::OPT_g_Group);
356 Args.ClaimAllArgs(options::OPT_emit_llvm);
359 Args.ClaimAllArgs(options::OPT_w);
361 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
364 ArgStringList CmdArgs;
366 CmdArgs.push_back(
"rcsD");
369 for (
const auto &II : Inputs) {
370 if (II.isFilename()) {
371 CmdArgs.push_back(II.getFilename());
378 if (Output.
isFilename() && llvm::sys::fs::exists(OutputFileName)) {
380 D.
Diag(diag::err_drv_unable_to_remove_file) << EC.message();
385 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
386 C.addCommand(std::make_unique<Command>(JA, *
this,
388 Exec, CmdArgs, Inputs, Output));
395 const char *LinkingOutput)
const {
404 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
413 const bool HasCRTBeginEndFiles =
417 ArgStringList CmdArgs;
420 Args.ClaimAllArgs(options::OPT_g_Group);
422 Args.ClaimAllArgs(options::OPT_emit_llvm);
425 Args.ClaimAllArgs(options::OPT_w);
428 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
431 CmdArgs.push_back(
"-pie");
434 CmdArgs.push_back(
"-static");
435 CmdArgs.push_back(
"-pie");
436 CmdArgs.push_back(
"--no-dynamic-linker");
437 CmdArgs.push_back(
"-z");
438 CmdArgs.push_back(
"text");
441 if (Args.hasArg(options::OPT_rdynamic))
442 CmdArgs.push_back(
"-export-dynamic");
444 if (Args.hasArg(options::OPT_s))
445 CmdArgs.push_back(
"-s");
447 if (Triple.isARM() || Triple.isThumb() || Triple.isAArch64()) {
451 IsBigEndian = IsBigEndian || Arch == llvm::Triple::aarch64_be;
452 CmdArgs.push_back(IsBigEndian ?
"-EB" :
"-EL");
457 if (Arch == llvm::Triple::aarch64 && isAndroid) {
459 if (CPU.empty() || CPU ==
"generic" || CPU ==
"cortex-a53")
460 CmdArgs.push_back(
"--fix-cortex-a53-843419");
465 CmdArgs.push_back(
"--eh-frame-hdr");
468 CmdArgs.push_back(
"-m");
469 CmdArgs.push_back(LDMOption);
471 D.
Diag(diag::err_target_unknown_triple) << Triple.str();
474 if (Triple.isRISCV())
475 CmdArgs.push_back(
"-X");
477 if (Args.hasArg(options::OPT_shared))
478 CmdArgs.push_back(
"-shared");
481 CmdArgs.push_back(
"-static");
483 if (Args.hasArg(options::OPT_rdynamic))
484 CmdArgs.push_back(
"-export-dynamic");
486 if (!Args.hasArg(options::OPT_shared) && !IsStaticPIE &&
487 !Args.hasArg(options::OPT_r)) {
488 CmdArgs.push_back(
"-dynamic-linker");
489 CmdArgs.push_back(Args.MakeArgString(Twine(D.
DyldPrefix) +
494 CmdArgs.push_back(
"-o");
497 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles,
499 if (!isAndroid && !IsIAMCU) {
500 const char *crt1 =
nullptr;
501 if (!Args.hasArg(options::OPT_shared)) {
502 if (Args.hasArg(options::OPT_pg))
506 else if (IsStaticPIE)
518 CmdArgs.push_back(
"-z");
519 CmdArgs.push_back(
"max-page-size=0x4000000");
524 else if (HasCRTBeginEndFiles) {
534 const char *crtbegin;
535 if (Args.hasArg(options::OPT_shared))
536 crtbegin = isAndroid ?
"crtbegin_so.o" :
"crtbeginS.o";
538 crtbegin = isAndroid ?
"crtbegin_static.o" :
"crtbeginT.o";
539 else if (IsPIE || IsStaticPIE)
540 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbeginS.o";
542 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbegin.o";
545 CmdArgs.push_back(Args.MakeArgString(
P));
552 Args.AddAllArgs(CmdArgs, options::OPT_L);
553 Args.AddAllArgs(CmdArgs, options::OPT_u);
558 assert(!Inputs.empty() &&
"Must have at least one input.");
563 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
564 CmdArgs.push_back(
"--no-demangle");
574 getToolChain().addProfileRTLibs(Args, CmdArgs);
577 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
580 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
581 !Args.hasArg(options::OPT_static);
582 if (OnlyLibstdcxxStatic)
583 CmdArgs.push_back(
"-Bstatic");
585 if (OnlyLibstdcxxStatic)
586 CmdArgs.push_back(
"-Bdynamic");
588 CmdArgs.push_back(
"-lm");
592 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
601 CmdArgs.push_back(
"-lm");
604 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_r)) {
605 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
607 CmdArgs.push_back(
"--start-group");
609 if (NeedsSanitizerDeps)
615 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
616 Args.hasArg(options::OPT_pthreads);
619 bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&
620 !Args.hasArg(options::OPT_static);
636 if (getToolChain().getTriple().getArch() == llvm::Triple::sparc) {
637 CmdArgs.push_back(
"--push-state");
638 CmdArgs.push_back(
"--as-needed");
639 CmdArgs.push_back(
"-latomic");
640 CmdArgs.push_back(
"--pop-state");
643 if (WantPthread && !isAndroid)
644 CmdArgs.push_back(
"-lpthread");
646 if (Args.hasArg(options::OPT_fsplit_stack))
647 CmdArgs.push_back(
"--wrap=pthread_create");
649 if (!Args.hasArg(options::OPT_nolibc))
650 CmdArgs.push_back(
"-lc");
654 CmdArgs.push_back(
"-lgloss");
657 CmdArgs.push_back(
"--end-group");
663 CmdArgs.push_back(
"--as-needed");
664 CmdArgs.push_back(
"-lsoftfp");
665 CmdArgs.push_back(
"--no-as-needed");
669 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
670 if (HasCRTBeginEndFiles) {
681 if (Args.hasArg(options::OPT_shared))
682 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
683 else if (IsPIE || IsStaticPIE)
684 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
686 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
689 CmdArgs.push_back(Args.MakeArgString(
P));
696 Args.AddAllArgs(CmdArgs, options::OPT_T);
699 C.addCommand(std::make_unique<Command>(JA, *
this,
701 Exec, CmdArgs, Inputs, Output));
709 const char *LinkingOutput)
const {
710 const auto &D = getToolChain().getDriver();
714 ArgStringList CmdArgs;
716 llvm::Reloc::Model RelocationModel;
719 const char *DefaultAssembler =
"as";
720 std::tie(RelocationModel, PICLevel, IsPIE) =
723 if (
const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
724 if (A->getOption().getID() == options::OPT_gz) {
725 CmdArgs.push_back(
"--compress-debug-sections");
727 StringRef
Value = A->getValue();
730 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
732 D.Diag(diag::err_drv_unsupported_option_argument)
733 << A->getSpelling() <<
Value;
738 switch (getToolChain().getArch()) {
743 case llvm::Triple::x86:
744 CmdArgs.push_back(
"--32");
746 case llvm::Triple::x86_64:
747 if (getToolChain().getTriple().isX32())
748 CmdArgs.push_back(
"--x32");
750 CmdArgs.push_back(
"--64");
752 case llvm::Triple::ppc: {
753 CmdArgs.push_back(
"-a32");
754 CmdArgs.push_back(
"-mppc");
755 CmdArgs.push_back(
"-mbig-endian");
757 getCPUName(D, Args, getToolChain().getTriple())));
760 case llvm::Triple::ppcle: {
761 CmdArgs.push_back(
"-a32");
762 CmdArgs.push_back(
"-mppc");
763 CmdArgs.push_back(
"-mlittle-endian");
765 getCPUName(D, Args, getToolChain().getTriple())));
768 case llvm::Triple::ppc64: {
769 CmdArgs.push_back(
"-a64");
770 CmdArgs.push_back(
"-mppc64");
771 CmdArgs.push_back(
"-mbig-endian");
773 getCPUName(D, Args, getToolChain().getTriple())));
776 case llvm::Triple::ppc64le: {
777 CmdArgs.push_back(
"-a64");
778 CmdArgs.push_back(
"-mppc64");
779 CmdArgs.push_back(
"-mlittle-endian");
781 getCPUName(D, Args, getToolChain().getTriple())));
784 case llvm::Triple::riscv32:
785 case llvm::Triple::riscv64: {
787 CmdArgs.push_back(
"-mabi");
788 CmdArgs.push_back(ABIName.data());
790 CmdArgs.push_back(
"-march");
791 CmdArgs.push_back(MArchName.data());
792 if (!Args.hasFlag(options::OPT_mrelax, options::OPT_mno_relax,
true))
793 Args.addOptOutFlag(CmdArgs, options::OPT_mrelax, options::OPT_mno_relax);
796 case llvm::Triple::sparc:
797 case llvm::Triple::sparcel: {
798 CmdArgs.push_back(
"-32");
805 case llvm::Triple::sparcv9: {
806 CmdArgs.push_back(
"-64");
813 case llvm::Triple::arm:
814 case llvm::Triple::armeb:
815 case llvm::Triple::thumb:
816 case llvm::Triple::thumbeb: {
817 const llvm::Triple &Triple2 = getToolChain().getTriple();
819 switch (Triple2.getSubArch()) {
820 case llvm::Triple::ARMSubArch_v7:
821 CmdArgs.push_back(
"-mfpu=neon");
823 case llvm::Triple::ARMSubArch_v8:
824 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
832 case arm::FloatABI::Soft:
833 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=soft"));
835 case arm::FloatABI::SoftFP:
836 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=softfp"));
838 case arm::FloatABI::Hard:
839 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=hard"));
843 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
846 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
849 case llvm::Triple::aarch64:
850 case llvm::Triple::aarch64_be: {
852 getToolChain().getArch() == llvm::Triple::aarch64_be ?
"-EB" :
"-EL");
853 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
858 case llvm::Triple::mips:
859 case llvm::Triple::mipsel:
860 case llvm::Triple::mips64:
861 case llvm::Triple::mips64el: {
867 CmdArgs.push_back(
"-march");
868 CmdArgs.push_back(CPUName.data());
870 CmdArgs.push_back(
"-mabi");
871 CmdArgs.push_back(ABIName.data());
875 if (RelocationModel == llvm::Reloc::Static)
876 CmdArgs.push_back(
"-mno-shared");
880 if (ABIName !=
"64" && !Args.hasArg(options::OPT_mno_abicalls))
881 CmdArgs.push_back(
"-call_nonpic");
883 if (getToolChain().getTriple().isLittleEndian())
884 CmdArgs.push_back(
"-EL");
886 CmdArgs.push_back(
"-EB");
888 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
889 if (StringRef(A->getValue()) ==
"2008")
890 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
894 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
895 options::OPT_mfp64)) {
897 A->render(Args, CmdArgs);
899 Args, getToolChain().getTriple(), CPUName, ABIName,
901 getToolChain().getTriple())))
902 CmdArgs.push_back(
"-mfpxx");
907 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
908 if (A->getOption().matches(options::OPT_mips16)) {
910 A->render(Args, CmdArgs);
913 CmdArgs.push_back(
"-no-mips16");
917 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
918 options::OPT_mno_micromips);
919 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
920 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
922 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
925 if (A->getOption().matches(options::OPT_mmsa))
926 CmdArgs.push_back(Args.MakeArgString(
"-mmsa"));
929 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
930 options::OPT_msoft_float);
932 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
933 options::OPT_msingle_float);
935 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
936 options::OPT_mno_odd_spreg);
941 case llvm::Triple::systemz: {
945 CmdArgs.push_back(Args.MakeArgString(
"-march=" + CPUName));
948 case llvm::Triple::ve:
949 DefaultAssembler =
"nas";
952 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
953 options::OPT_fdebug_prefix_map_EQ)) {
954 StringRef Map = A->getValue();
955 if (!Map.contains(
'='))
956 D.Diag(diag::err_drv_invalid_argument_to_option)
957 << Map << A->getOption().getName();
959 CmdArgs.push_back(Args.MakeArgString(
"--debug-prefix-map"));
960 CmdArgs.push_back(Args.MakeArgString(Map));
965 Args.AddAllArgs(CmdArgs, options::OPT_I);
966 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
968 CmdArgs.push_back(
"-o");
971 for (
const auto &II : Inputs)
972 CmdArgs.push_back(II.getFilename());
974 if (Arg *A = Args.getLastArg(options::OPT_g_Flag, options::OPT_gN_Group,
975 options::OPT_gdwarf_2, options::OPT_gdwarf_3,
976 options::OPT_gdwarf_4, options::OPT_gdwarf_5,
977 options::OPT_gdwarf))
978 if (!A->getOption().matches(options::OPT_g0)) {
979 Args.AddLastArg(CmdArgs, options::OPT_g_Flag);
982 CmdArgs.push_back(Args.MakeArgString(
"-gdwarf-" + Twine(DwarfVersion)));
986 Args.MakeArgString(getToolChain().GetProgramPath(DefaultAssembler));
987 C.addCommand(std::make_unique<Command>(JA, *
this,
989 Exec, CmdArgs, Inputs, Output));
994 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
995 getToolChain().getTriple().isOSLinux())
1002 class FilterNonExistent {
1004 llvm::vfs::FileSystem &VFS;
1007 FilterNonExistent(StringRef
Base, StringRef File, llvm::vfs::FileSystem &VFS)
1009 bool operator()(
const Multilib &M) {
1016 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1017 options::OPT_mfloat_abi_EQ);
1021 return A->getOption().matches(options::OPT_msoft_float) ||
1022 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
1023 A->getValue() == StringRef(
"soft"));
1027 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
1031 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1035 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
1036 return A && A->getOption().matches(options::OPT_mips16);
1040 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
1041 return A && A->getOption().matches(options::OPT_mmicromips);
1045 return Arch == llvm::Triple::msp430;
1049 return Multilib(commonSuffix, commonSuffix, commonSuffix);
1053 FilterNonExistent &NonExistent,
1060 auto MArchMicroMips =
1081 .includeSuffix(
"/64")
1088 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
1090 .
Either(SoftFloat, Nan2008, DefaultFloat)
1093 .
Either(BigEndian, LittleEndian)
1099 std::vector<std::string> Dirs({
"/include"});
1102 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1104 Dirs.push_back(
"/../../../../mips-linux-gnu/libc/usr/include");
1116 .includeSuffix(
"/64")
1124 DebianMipsMultilibs =
1130 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1131 if (CSMipsMultilibs.
size() < DebianMipsMultilibs.
size())
1132 std::iter_swap(Candidates, Candidates + 1);
1134 if (Candidate->select(Flags, Result.SelectedMultilib)) {
1135 if (Candidate == &DebianMipsMultilibs)
1137 Result.Multilibs = *Candidate;
1146 FilterNonExistent &NonExistent,
1158 Multilib(
"/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
1159 Multilib(
"/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
1165 Multilib().flag(
"+march=mips64r6"),
1166 Multilib(
"/32/mips-r1",
"",
"/mips-r1").flag(
"+march=mips32"),
1167 Multilib(
"/32/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
1168 Multilib(
"/32/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
1172 if (VFS.exists(Path +
"/mips-r6"))
1173 MS = &AndroidMipselMultilibs;
1174 else if (VFS.exists(Path +
"/32"))
1175 MS = &AndroidMips64elMultilibs;
1176 if (MS->
select(Flags, Result.SelectedMultilib)) {
1177 Result.Multilibs = *MS;
1184 FilterNonExistent &NonExistent,
1193 .flag(
"+march=mips32r2");
1195 auto MArchMipselR2 =
makeMultilib(
"/mipsel-r2-hard-musl")
1198 .
flag(
"+march=mips32r2");
1204 return std::vector<std::string>(
1205 {
"/../sysroot" + M.
osSuffix() +
"/usr/include"});
1208 if (MuslMipsMultilibs.
select(Flags, Result.SelectedMultilib)) {
1209 Result.Multilibs = MuslMipsMultilibs;
1216 FilterNonExistent &NonExistent,
1224 .
flag(
"-mmicromips")
1225 .
flag(
"+march=mips32");
1230 .
flag(
"+mmicromips");
1235 .
flag(
"+march=mips64r2");
1243 .
flag(
"-mmicromips")
1244 .
flag(
"+march=mips32r2");
1261 MtiMipsMultilibsV1 =
1263 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1275 .
Either(BigEndian, LittleEndian)
1281 std::vector<std::string> Dirs({
"/include"});
1283 Dirs.push_back(
"/../../../../sysroot/uclibc/usr/include");
1285 Dirs.push_back(
"/../../../../sysroot/usr/include");
1295 .
flag(
"-msoft-float")
1300 .
flag(
"+msoft-float")
1301 .
flag(
"-mnan=2008");
1304 .
flag(
"-msoft-float")
1309 .
flag(
"+msoft-float")
1311 .
flag(
"-mmicromips");
1314 .
flag(
"-msoft-float")
1317 auto ElHardNan =
makeMultilib(
"/mipsel-r2-hard-nan2008")
1319 .
flag(
"-msoft-float")
1322 .
flag(
"-mmicromips");
1323 auto BeHardNanUclibc =
makeMultilib(
"/mips-r2-hard-nan2008-uclibc")
1325 .
flag(
"-msoft-float")
1328 auto ElHardNanUclibc =
makeMultilib(
"/mipsel-r2-hard-nan2008-uclibc")
1330 .
flag(
"-msoft-float")
1333 auto BeHardUclibc =
makeMultilib(
"/mips-r2-hard-uclibc")
1335 .
flag(
"-msoft-float")
1338 auto ElHardUclibc =
makeMultilib(
"/mipsel-r2-hard-uclibc")
1340 .
flag(
"-msoft-float")
1343 auto ElMicroHardNan =
makeMultilib(
"/micromipsel-r2-hard-nan2008")
1345 .
flag(
"-msoft-float")
1347 .
flag(
"+mmicromips");
1348 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r2-soft")
1350 .
flag(
"+msoft-float")
1352 .
flag(
"+mmicromips");
1361 MtiMipsMultilibsV2 =
1363 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1364 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1365 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1366 .Either(O32, N32, N64)
1369 return std::vector<std::string>({
"/../../../../sysroot" +
1371 "/../usr/include"});
1373 .setFilePathsCallback([](
const Multilib &M) {
1374 return std::vector<std::string>(
1375 {
"/../../../../mips-mti-linux-gnu/lib" + M.
gccSuffix()});
1378 for (
auto *Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1379 if (Candidate->select(Flags, Result.SelectedMultilib)) {
1380 Result.Multilibs = *Candidate;
1388 FilterNonExistent &NonExistent,
1404 .
Maybe(LittleEndian)
1407 return std::vector<std::string>(
1408 {
"/include",
"/../../../../sysroot/usr/include"});
1417 .
flag(
"-msoft-float")
1418 .
flag(
"-mmicromips");
1421 .
flag(
"+msoft-float")
1422 .
flag(
"-mmicromips");
1425 .
flag(
"-msoft-float")
1426 .
flag(
"-mmicromips");
1429 .
flag(
"+msoft-float")
1430 .
flag(
"-mmicromips");
1433 .
flag(
"-msoft-float")
1434 .
flag(
"+mmicromips");
1437 .
flag(
"+msoft-float")
1438 .
flag(
"+mmicromips");
1439 auto ElMicroHard =
makeMultilib(
"/micromipsel-r6-hard")
1441 .
flag(
"-msoft-float")
1442 .
flag(
"+mmicromips");
1443 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r6-soft")
1445 .
flag(
"+msoft-float")
1446 .
flag(
"+mmicromips");
1457 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1458 ElMicroHard, ElMicroSoft})
1459 .Either(O32, N32, N64)
1462 return std::vector<std::string>({
"/../../../../sysroot" +
1464 "/../usr/include"});
1466 .setFilePathsCallback([](
const Multilib &M) {
1467 return std::vector<std::string>(
1468 {
"/../../../../mips-img-linux-gnu/lib" + M.
gccSuffix()});
1471 for (
auto *Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1472 if (Candidate->select(Flags, Result.SelectedMultilib)) {
1473 Result.Multilibs = *Candidate;
1481 const llvm::Triple &TargetTriple,
1482 StringRef Path,
const ArgList &Args,
1484 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1490 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1498 CPUName ==
"mips32r5" || CPUName ==
"p5600",
1499 "march=mips32r2", Flags);
1503 CPUName ==
"mips64r5" || CPUName ==
"octeon" ||
1504 CPUName ==
"octeon+",
1505 "march=mips64r2", Flags);
1518 if (TargetTriple.isAndroid())
1522 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1523 TargetTriple.getOS() == llvm::Triple::Linux &&
1524 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1527 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1528 TargetTriple.getOS() == llvm::Triple::Linux &&
1529 TargetTriple.isGNUEnvironment())
1532 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1533 TargetTriple.getOS() == llvm::Triple::Linux &&
1534 TargetTriple.isGNUEnvironment())
1542 Result.Multilibs.push_back(Default);
1543 Result.Multilibs.FilterOut(NonExistent);
1545 if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
1554 const llvm::Triple &TargetTriple,
1555 StringRef Path,
const ArgList &Args,
1558 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1560 .
flag(
"+march=armv7-a")
1563 .
flag(
"-march=armv7-a")
1566 .
flag(
"+march=armv7-a")
1569 .
flag(
"-march=armv7-a")
1573 .
Either(ThumbMultilib, ArmV7Multilib,
1574 ArmV7ThumbMultilib, DefaultMultilib)
1578 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1579 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1580 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1581 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1582 bool IsThumbMode = IsThumbArch ||
1583 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb,
false) ||
1584 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1585 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1586 (llvm::ARM::parseArchVersion(Arch) == 7 ||
1587 (IsArmArch && Arch ==
"" && IsV7SubArch));
1591 if (AndroidArmMultilibs.
select(Flags, Result.SelectedMultilib))
1592 Result.Multilibs = AndroidArmMultilibs;
1596 const llvm::Triple &TargetTriple,
1597 StringRef Path,
const ArgList &Args,
1599 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1607 Result.Multilibs.push_back(WithoutExceptions);
1608 Result.Multilibs.push_back(WithExceptions);
1609 Result.Multilibs.FilterOut(NonExistent);
1613 options::OPT_fno_exceptions,
false),
1614 "exceptions", Flags);
1615 if (Result.Multilibs.select(Flags, Result.SelectedMultilib))
1622 StringRef Path,
const ArgList &Args,
1624 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1627 std::optional<llvm::StringRef> Res =
1632 auto ARCHName = *Res;
1650 bool isBigEndian =
false;
1651 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
1652 options::OPT_mbig_endian))
1653 isBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
1675 .
Either({Arch801, Arch802, Arch803, Arch804, Arch805, Arch807,
1676 Arch810, Arch810v, Arch860, Arch860v})
1677 .Either(HardFloat, SoftFpFloat, SoftFloat)
1680 if (CSKYMultilibs.
select(Flags, Result.SelectedMultilib))
1681 Result.Multilibs = CSKYMultilibs;
1685 const llvm::Triple &TargetTriple,
1686 StringRef Path,
const ArgList &Args,
1688 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1689 struct RiscvMultilib {
1695 constexpr RiscvMultilib RISCVMultilibSet[] = {
1696 {
"rv32i",
"ilp32"}, {
"rv32im",
"ilp32"}, {
"rv32iac",
"ilp32"},
1697 {
"rv32imac",
"ilp32"}, {
"rv32imafc",
"ilp32f"}, {
"rv64imac",
"lp64"},
1698 {
"rv64imafdc",
"lp64d"}};
1700 std::vector<Multilib> Ms;
1701 for (
auto Element : RISCVMultilibSet) {
1704 makeMultilib((Twine(Element.march) +
"/" + Twine(Element.mabi)).str())
1705 .
flag(Twine(
"+march=", Element.march).str())
1706 .
flag(Twine(
"+mabi=", Element.mabi).str()));
1713 return std::vector<std::string>(
1715 "/../../../../riscv64-unknown-elf/lib" + M.
gccSuffix(),
1716 "/../../../../riscv32-unknown-elf/lib" + M.
gccSuffix()});
1721 llvm::StringSet<> Added_ABIs;
1724 for (
auto Element : RISCVMultilibSet) {
1726 Twine(
"march=", Element.march).str().c_str(), Flags);
1727 if (!Added_ABIs.count(Element.mabi)) {
1728 Added_ABIs.insert(Element.mabi);
1730 Twine(
"mabi=", Element.mabi).str().c_str(), Flags);
1734 if (RISCVMultilibs.
select(Flags, Result.SelectedMultilib))
1735 Result.Multilibs = RISCVMultilibs;
1739 const llvm::Triple &TargetTriple, StringRef Path,
1741 if (TargetTriple.getOS() == llvm::Triple::UnknownOS)
1744 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1755 .
Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1756 .FilterOut(NonExistent);
1759 bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1771 if (RISCVMultilibs.
select(Flags, Result.SelectedMultilib))
1772 Result.Multilibs = RISCVMultilibs;
1776 const llvm::Triple &TargetTriple,
1777 StringRef Path,
const ArgList &Args,
1778 bool NeedsBiarchSuffix,
1789 StringRef Suff64 =
"/64";
1791 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1792 switch (TargetTriple.getArch()) {
1793 case llvm::Triple::x86:
1794 case llvm::Triple::x86_64:
1797 case llvm::Triple::sparc:
1798 case llvm::Triple::sparcv9:
1799 Suff64 =
"/sparcv9";
1808 .includeSuffix(Suff64)
1814 .includeSuffix(
"/32")
1820 .includeSuffix(
"/x32")
1826 FilterNonExistent NonExistent(
1827 Path, TargetTriple.isOSIAMCU() ?
"/libgcc.a" :
"/crtbegin.o", D.
getVFS());
1832 const bool IsX32 = TargetTriple.isX32();
1833 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1835 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1837 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1840 if (TargetTriple.isArch32Bit())
1841 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1843 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1845 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1849 Default.flag(
"+m32").flag(
"-m64").flag(
"-mx32");
1850 else if (Want == WANT64)
1851 Default.flag(
"-m32").flag(
"+m64").flag(
"-mx32");
1852 else if (Want == WANTX32)
1853 Default.flag(
"-m32").flag(
"-m64").flag(
"+mx32");
1857 Result.Multilibs.push_back(
Default);
1858 Result.Multilibs.push_back(Alt64);
1859 Result.Multilibs.push_back(Alt32);
1860 Result.Multilibs.push_back(Altx32);
1862 Result.Multilibs.FilterOut(NonExistent);
1869 if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
1872 if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
1873 Result.SelectedMultilib == Altx32)
1874 Result.BiarchSibling =
Default;
1886 StringRef RHSPatchSuffix)
const {
1887 if (Major != RHSMajor)
1888 return Major < RHSMajor;
1889 if (Minor != RHSMinor) {
1896 return Minor < RHSMinor;
1898 if (Patch != RHSPatch) {
1907 return Patch < RHSPatch;
1909 if (PatchSuffix != RHSPatchSuffix) {
1911 if (RHSPatchSuffix.empty())
1913 if (PatchSuffix.empty())
1917 return PatchSuffix < RHSPatchSuffix;
1929 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1930 std::pair<StringRef, StringRef>
First = VersionText.split(
'.');
1931 std::pair<StringRef, StringRef> Second =
First.second.split(
'.');
1933 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1934 if (
First.first.getAsInteger(10, GoodVersion.
Major) || GoodVersion.
Major < 0)
1937 if (
First.second.empty())
1939 StringRef MinorStr = Second.first;
1940 if (Second.second.empty()) {
1941 if (
size_t EndNumber = MinorStr.find_first_not_of(
"0123456789")) {
1943 MinorStr = MinorStr.slice(0, EndNumber);
1946 if (MinorStr.getAsInteger(10, GoodVersion.
Minor) || GoodVersion.
Minor < 0)
1948 GoodVersion.
MinorStr = MinorStr.str();
1961 StringRef PatchText = Second.second;
1962 if (!PatchText.empty()) {
1963 if (
size_t EndNumber = PatchText.find_first_not_of(
"0123456789")) {
1965 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.
Patch) ||
1966 GoodVersion.
Patch < 0)
1976 llvm::StringRef SysRoot) {
1977 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
1979 return A->getValue();
1984 if (!SysRoot.empty())
1987 return GCC_INSTALL_PREFIX;
2000 const llvm::Triple &TargetTriple,
const ArgList &Args,
2002 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
2003 ? TargetTriple.get64BitArchVariant()
2004 : TargetTriple.get32BitArchVariant();
2010 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
2011 CandidateTripleAliases, CandidateBiarchLibDirs,
2012 CandidateBiarchTripleAliases);
2016 Args.getLastArg(clang::driver::options::OPT_gcc_install_dir_EQ);
2017 A && A->getValue()[0]) {
2018 StringRef InstallDir = A->getValue();
2019 if (!ScanGCCForMultilibs(TargetTriple, Args, InstallDir,
false)) {
2020 D.
Diag(diag::err_drv_invalid_gcc_install_dir) << InstallDir;
2022 (void)InstallDir.consume_back(
"/");
2023 StringRef VersionText = llvm::sys::path::filename(InstallDir);
2024 StringRef TripleText =
2025 llvm::sys::path::filename(llvm::sys::path::parent_path(InstallDir));
2027 Version = GCCVersion::Parse(VersionText);
2028 GCCTriple.setTriple(TripleText);
2030 GCCParentLibPath = GCCInstallPath +
"/../../..";
2039 if (GCCToolchainDir !=
"") {
2040 if (GCCToolchainDir.back() ==
'/')
2041 GCCToolchainDir = GCCToolchainDir.drop_back();
2047 Prefixes.push_back(D.
SysRoot);
2048 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
2058 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
2070 GentooTestTriples.push_back(TargetTriple.str());
2072 GentooTestTriples.append(ExtraTripleAliases.begin(),
2073 ExtraTripleAliases.end());
2074 GentooTestTriples.append(CandidateTripleAliases.begin(),
2075 CandidateTripleAliases.end());
2076 if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
2077 CandidateBiarchTripleAliases))
2083 const GCCVersion VersionZero = GCCVersion::Parse(
"0.0.0");
2084 Version = VersionZero;
2087 if (!VFS.exists(Prefix))
2089 for (StringRef Suffix : CandidateLibDirs) {
2090 const std::string LibDir = concat(Prefix, Suffix);
2091 if (!VFS.exists(LibDir))
2094 bool GCCDirExists = VFS.exists(LibDir +
"/gcc");
2095 bool GCCCrossDirExists = VFS.exists(LibDir +
"/gcc-cross");
2097 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, TargetTriple.str(),
2098 false, GCCDirExists, GCCCrossDirExists);
2100 for (StringRef Candidate : ExtraTripleAliases)
2101 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
false,
2102 GCCDirExists, GCCCrossDirExists);
2103 for (StringRef Candidate : CandidateTripleAliases)
2104 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
false,
2105 GCCDirExists, GCCCrossDirExists);
2107 for (StringRef Suffix : CandidateBiarchLibDirs) {
2109 if (!VFS.exists(LibDir))
2111 bool GCCDirExists = VFS.exists(LibDir +
"/gcc");
2112 bool GCCCrossDirExists = VFS.exists(LibDir +
"/gcc-cross");
2113 for (StringRef Candidate : CandidateBiarchTripleAliases)
2114 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
true,
2115 GCCDirExists, GCCCrossDirExists);
2119 if (Version > VersionZero)
2125 for (
const auto &InstallPath : CandidateGCCInstallPaths)
2126 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
2128 if (!GCCInstallPath.empty())
2129 OS <<
"Selected GCC installation: " << GCCInstallPath <<
"\n";
2131 for (
const auto &
Multilib : Multilibs)
2132 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
2134 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
2135 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
2139 if (BiarchSibling) {
2146 void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
2148 StringRef SysRoot) {
2149 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2156 std::string PrefixDir = concat(SysRoot,
"/usr/gcc");
2158 for (llvm::vfs::directory_iterator LI = D.
getVFS().dir_begin(PrefixDir, EC),
2160 !EC && LI !=
LE; LI = LI.increment(EC)) {
2161 StringRef VersionText = llvm::sys::path::filename(LI->path());
2162 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2168 std::string CandidatePrefix = PrefixDir +
"/" + VersionText.str();
2169 std::string CandidateLibPath = CandidatePrefix +
"/lib/gcc";
2170 if (!D.
getVFS().exists(CandidateLibPath))
2173 Prefixes.push_back(CandidatePrefix);
2180 if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux &&
2181 D.
getVFS().exists(
"/opt/rh")) {
2184 Prefixes.push_back(
"/opt/rh/gcc-toolset-12/root/usr");
2185 Prefixes.push_back(
"/opt/rh/gcc-toolset-11/root/usr");
2186 Prefixes.push_back(
"/opt/rh/gcc-toolset-10/root/usr");
2187 Prefixes.push_back(
"/opt/rh/devtoolset-12/root/usr");
2188 Prefixes.push_back(
"/opt/rh/devtoolset-11/root/usr");
2189 Prefixes.push_back(
"/opt/rh/devtoolset-10/root/usr");
2190 Prefixes.push_back(
"/opt/rh/devtoolset-9/root/usr");
2191 Prefixes.push_back(
"/opt/rh/devtoolset-8/root/usr");
2192 Prefixes.push_back(
"/opt/rh/devtoolset-7/root/usr");
2193 Prefixes.push_back(
"/opt/rh/devtoolset-6/root/usr");
2194 Prefixes.push_back(
"/opt/rh/devtoolset-4/root/usr");
2195 Prefixes.push_back(
"/opt/rh/devtoolset-3/root/usr");
2196 Prefixes.push_back(
"/opt/rh/devtoolset-2/root/usr");
2200 Prefixes.push_back(concat(SysRoot,
"/usr"));
2203 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
2204 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
2218 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
2219 static const char *
const AArch64Triples[] = {
2220 "aarch64-none-linux-gnu",
"aarch64-linux-gnu",
"aarch64-redhat-linux",
2221 "aarch64-suse-linux"};
2222 static const char *
const AArch64beLibDirs[] = {
"/lib"};
2223 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu",
2224 "aarch64_be-linux-gnu"};
2226 static const char *
const ARMLibDirs[] = {
"/lib"};
2227 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi"};
2228 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
2229 "armv7hl-redhat-linux-gnueabi",
2230 "armv6hl-suse-linux-gnueabi",
2231 "armv7hl-suse-linux-gnueabi"};
2232 static const char *
const ARMebLibDirs[] = {
"/lib"};
2233 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi"};
2234 static const char *
const ARMebHFTriples[] = {
2235 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
2237 static const char *
const AVRLibDirs[] = {
"/lib"};
2238 static const char *
const AVRTriples[] = {
"avr"};
2240 static const char *
const CSKYLibDirs[] = {
"/lib"};
2241 static const char *
const CSKYTriples[] = {
2242 "csky-linux-gnuabiv2",
"csky-linux-uclibcabiv2",
"csky-elf-noneabiv2"};
2244 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
2245 static const char *
const X86_64Triples[] = {
2246 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
2247 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
2248 "x86_64-redhat-linux",
"x86_64-suse-linux",
2249 "x86_64-manbo-linux-gnu",
"x86_64-linux-gnu",
2250 "x86_64-slackware-linux",
"x86_64-unknown-linux",
2251 "x86_64-amazon-linux"};
2252 static const char *
const X32Triples[] = {
"x86_64-linux-gnux32",
2253 "x86_64-pc-linux-gnux32"};
2254 static const char *
const X32LibDirs[] = {
"/libx32",
"/lib"};
2255 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
2256 static const char *
const X86Triples[] = {
2257 "i586-linux-gnu",
"i686-linux-gnu",
"i686-pc-linux-gnu",
2258 "i386-redhat-linux6E",
"i686-redhat-linux",
"i386-redhat-linux",
2259 "i586-suse-linux",
"i686-montavista-linux",
"i686-gnu",
2262 static const char *
const LoongArch64LibDirs[] = {
"/lib64",
"/lib"};
2263 static const char *
const LoongArch64Triples[] = {
2264 "loongarch64-linux-gnu",
"loongarch64-unknown-linux-gnu"};
2266 static const char *
const M68kLibDirs[] = {
"/lib"};
2267 static const char *
const M68kTriples[] = {
2268 "m68k-linux-gnu",
"m68k-unknown-linux-gnu",
"m68k-suse-linux"};
2270 static const char *
const MIPSLibDirs[] = {
"/libo32",
"/lib"};
2271 static const char *
const MIPSTriples[] = {
2272 "mips-linux-gnu",
"mips-mti-linux",
"mips-mti-linux-gnu",
2273 "mips-img-linux-gnu",
"mipsisa32r6-linux-gnu"};
2274 static const char *
const MIPSELLibDirs[] = {
"/libo32",
"/lib"};
2275 static const char *
const MIPSELTriples[] = {
2276 "mipsel-linux-gnu",
"mips-img-linux-gnu",
"mipsisa32r6el-linux-gnu"};
2278 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
2279 static const char *
const MIPS64Triples[] = {
2280 "mips64-linux-gnu",
"mips-mti-linux-gnu",
2281 "mips-img-linux-gnu",
"mips64-linux-gnuabi64",
2282 "mipsisa64r6-linux-gnu",
"mipsisa64r6-linux-gnuabi64"};
2283 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
2284 static const char *
const MIPS64ELTriples[] = {
2285 "mips64el-linux-gnu",
"mips-mti-linux-gnu",
2286 "mips-img-linux-gnu",
"mips64el-linux-gnuabi64",
2287 "mipsisa64r6el-linux-gnu",
"mipsisa64r6el-linux-gnuabi64"};
2289 static const char *
const MIPSN32LibDirs[] = {
"/lib32"};
2290 static const char *
const MIPSN32Triples[] = {
"mips64-linux-gnuabin32",
2291 "mipsisa64r6-linux-gnuabin32"};
2292 static const char *
const MIPSN32ELLibDirs[] = {
"/lib32"};
2293 static const char *
const MIPSN32ELTriples[] = {
2294 "mips64el-linux-gnuabin32",
"mipsisa64r6el-linux-gnuabin32"};
2296 static const char *
const MSP430LibDirs[] = {
"/lib"};
2297 static const char *
const MSP430Triples[] = {
"msp430-elf"};
2299 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
2300 static const char *
const PPCTriples[] = {
2301 "powerpc-linux-gnu",
"powerpc-unknown-linux-gnu",
"powerpc-linux-gnuspe",
2304 "powerpc64-suse-linux",
"powerpc-montavista-linuxspe"};
2305 static const char *
const PPCLELibDirs[] = {
"/lib32",
"/lib"};
2306 static const char *
const PPCLETriples[] = {
"powerpcle-linux-gnu",
2307 "powerpcle-unknown-linux-gnu",
2308 "powerpcle-linux-musl"};
2310 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
2311 static const char *
const PPC64Triples[] = {
2312 "powerpc64-linux-gnu",
"powerpc64-unknown-linux-gnu",
2313 "powerpc64-suse-linux",
"ppc64-redhat-linux"};
2314 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
2315 static const char *
const PPC64LETriples[] = {
2316 "powerpc64le-linux-gnu",
"powerpc64le-unknown-linux-gnu",
2317 "powerpc64le-none-linux-gnu",
"powerpc64le-suse-linux",
2318 "ppc64le-redhat-linux"};
2320 static const char *
const RISCV32LibDirs[] = {
"/lib32",
"/lib"};
2321 static const char *
const RISCV32Triples[] = {
"riscv32-unknown-linux-gnu",
2322 "riscv32-linux-gnu",
2323 "riscv32-unknown-elf"};
2324 static const char *
const RISCV64LibDirs[] = {
"/lib64",
"/lib"};
2325 static const char *
const RISCV64Triples[] = {
"riscv64-unknown-linux-gnu",
2326 "riscv64-linux-gnu",
2327 "riscv64-unknown-elf"};
2329 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
2330 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
2331 "sparcv8-linux-gnu"};
2332 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
2333 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
2334 "sparcv9-linux-gnu"};
2336 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
2337 static const char *
const SystemZTriples[] = {
2338 "s390x-linux-gnu",
"s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
2339 "s390x-suse-linux",
"s390x-redhat-linux"};
2345 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2346 static const char *
const SolarisLibDirs[] = {
"/lib"};
2347 static const char *
const SolarisSparcV8Triples[] = {
2348 "sparc-sun-solaris2.11",
"sparc-sun-solaris2.12"};
2349 static const char *
const SolarisSparcV9Triples[] = {
2350 "sparcv9-sun-solaris2.11",
"sparcv9-sun-solaris2.12"};
2351 static const char *
const SolarisX86Triples[] = {
"i386-pc-solaris2.11",
2352 "i386-pc-solaris2.12"};
2353 static const char *
const SolarisX86_64Triples[] = {
"x86_64-pc-solaris2.11",
2354 "x86_64-pc-solaris2.12"};
2355 LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2356 BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2357 switch (TargetTriple.getArch()) {
2358 case llvm::Triple::x86:
2359 TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
2360 BiarchTripleAliases.append(begin(SolarisX86_64Triples),
2361 end(SolarisX86_64Triples));
2363 case llvm::Triple::x86_64:
2364 TripleAliases.append(begin(SolarisX86_64Triples),
2365 end(SolarisX86_64Triples));
2366 BiarchTripleAliases.append(begin(SolarisX86Triples),
2367 end(SolarisX86Triples));
2369 case llvm::Triple::sparc:
2370 TripleAliases.append(begin(SolarisSparcV8Triples),
2371 end(SolarisSparcV8Triples));
2372 BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2373 end(SolarisSparcV9Triples));
2375 case llvm::Triple::sparcv9:
2376 TripleAliases.append(begin(SolarisSparcV9Triples),
2377 end(SolarisSparcV9Triples));
2378 BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2379 end(SolarisSparcV8Triples));
2388 if (TargetTriple.isAndroid()) {
2389 static const char *
const AArch64AndroidTriples[] = {
2390 "aarch64-linux-android"};
2391 static const char *
const ARMAndroidTriples[] = {
"arm-linux-androideabi"};
2392 static const char *
const MIPSELAndroidTriples[] = {
"mipsel-linux-android"};
2393 static const char *
const MIPS64ELAndroidTriples[] = {
2394 "mips64el-linux-android"};
2395 static const char *
const X86AndroidTriples[] = {
"i686-linux-android"};
2396 static const char *
const X86_64AndroidTriples[] = {
"x86_64-linux-android"};
2398 switch (TargetTriple.getArch()) {
2399 case llvm::Triple::aarch64:
2400 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2401 TripleAliases.append(begin(AArch64AndroidTriples),
2402 end(AArch64AndroidTriples));
2404 case llvm::Triple::arm:
2405 case llvm::Triple::thumb:
2406 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2407 TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2409 case llvm::Triple::mipsel:
2410 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2411 TripleAliases.append(begin(MIPSELAndroidTriples),
2412 end(MIPSELAndroidTriples));
2413 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2414 BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples),
2415 end(MIPS64ELAndroidTriples));
2417 case llvm::Triple::mips64el:
2418 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2419 TripleAliases.append(begin(MIPS64ELAndroidTriples),
2420 end(MIPS64ELAndroidTriples));
2421 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2422 BiarchTripleAliases.append(begin(MIPSELAndroidTriples),
2423 end(MIPSELAndroidTriples));
2425 case llvm::Triple::x86_64:
2426 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2427 TripleAliases.append(begin(X86_64AndroidTriples),
2428 end(X86_64AndroidTriples));
2429 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2430 BiarchTripleAliases.append(begin(X86AndroidTriples),
2431 end(X86AndroidTriples));
2433 case llvm::Triple::x86:
2434 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2435 TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
2436 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2437 BiarchTripleAliases.append(begin(X86_64AndroidTriples),
2438 end(X86_64AndroidTriples));
2447 switch (TargetTriple.getArch()) {
2448 case llvm::Triple::aarch64:
2449 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2450 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2451 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2452 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2454 case llvm::Triple::aarch64_be:
2455 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2456 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2457 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2458 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2460 case llvm::Triple::arm:
2461 case llvm::Triple::thumb:
2462 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2463 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2464 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2466 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2469 case llvm::Triple::armeb:
2470 case llvm::Triple::thumbeb:
2471 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2472 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2473 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2475 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2478 case llvm::Triple::avr:
2479 LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs));
2480 TripleAliases.append(begin(AVRTriples), end(AVRTriples));
2482 case llvm::Triple::csky:
2483 LibDirs.append(begin(CSKYLibDirs), end(CSKYLibDirs));
2484 TripleAliases.append(begin(CSKYTriples), end(CSKYTriples));
2486 case llvm::Triple::x86_64:
2487 if (TargetTriple.isX32()) {
2488 LibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2489 TripleAliases.append(begin(X32Triples), end(X32Triples));
2490 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2491 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2493 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2494 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2495 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2496 BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
2498 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2499 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2501 case llvm::Triple::x86:
2502 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2505 if (!TargetTriple.isOSIAMCU()) {
2506 TripleAliases.append(begin(X86Triples), end(X86Triples));
2507 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2508 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2509 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2510 BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
2514 case llvm::Triple::loongarch64:
2515 LibDirs.append(begin(LoongArch64LibDirs), end(LoongArch64LibDirs));
2516 TripleAliases.append(begin(LoongArch64Triples), end(LoongArch64Triples));
2518 case llvm::Triple::m68k:
2519 LibDirs.append(begin(M68kLibDirs), end(M68kLibDirs));
2520 TripleAliases.append(begin(M68kTriples), end(M68kTriples));
2522 case llvm::Triple::mips:
2523 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2524 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2525 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2526 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2527 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2528 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2530 case llvm::Triple::mipsel:
2531 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2532 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2533 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2534 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2535 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2536 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2537 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2539 case llvm::Triple::mips64:
2540 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2541 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2542 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2543 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2544 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2545 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2547 case llvm::Triple::mips64el:
2548 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2549 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2550 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2551 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2552 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2553 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2554 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2556 case llvm::Triple::msp430:
2557 LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2558 TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2560 case llvm::Triple::ppc:
2561 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2562 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2563 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2564 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2566 case llvm::Triple::ppcle:
2567 LibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs));
2568 TripleAliases.append(begin(PPCLETriples), end(PPCLETriples));
2569 BiarchLibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2570 BiarchTripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2572 case llvm::Triple::ppc64:
2573 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2574 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2575 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2576 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2578 case llvm::Triple::ppc64le:
2579 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2580 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2581 BiarchLibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs));
2582 BiarchTripleAliases.append(begin(PPCLETriples), end(PPCLETriples));
2584 case llvm::Triple::riscv32:
2585 LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2586 TripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2587 BiarchLibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2588 BiarchTripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2590 case llvm::Triple::riscv64:
2591 LibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2592 TripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2593 BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2594 BiarchTripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2596 case llvm::Triple::sparc:
2597 case llvm::Triple::sparcel:
2598 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2599 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2600 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2601 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2603 case llvm::Triple::sparcv9:
2604 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2605 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2606 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2607 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2609 case llvm::Triple::systemz:
2610 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2611 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2621 TripleAliases.push_back(TargetTriple.str());
2624 if (TargetTriple.str() != BiarchTriple.str())
2625 BiarchTripleAliases.push_back(BiarchTriple.str());
2628 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2629 const llvm::Triple &TargetTriple,
const ArgList &Args,
2630 StringRef Path,
bool NeedsBiarchSuffix) {
2631 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2640 }
else if (TargetTriple.isCSKY()) {
2642 }
else if (TargetTriple.isMIPS()) {
2645 }
else if (TargetTriple.isRISCV()) {
2649 }
else if (TargetArch == llvm::Triple::avr) {
2652 NeedsBiarchSuffix, Detected)) {
2663 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2664 const llvm::Triple &TargetTriple,
const ArgList &Args,
2665 const std::string &LibDir, StringRef CandidateTriple,
2666 bool NeedsBiarchSuffix,
bool GCCDirExists,
bool GCCCrossDirExists) {
2669 struct GCCLibSuffix {
2674 StringRef ReversePath;
2679 {
"gcc/" + CandidateTriple.str(),
"../..", GCCDirExists},
2682 {
"gcc-cross/" + CandidateTriple.str(),
"../..", GCCCrossDirExists},
2688 {CandidateTriple.str(),
"..",
2689 TargetTriple.getVendor() == llvm::Triple::Freescale ||
2690 TargetTriple.getVendor() == llvm::Triple::OpenEmbedded}};
2696 StringRef LibSuffix = Suffix.LibSuffix;
2698 for (llvm::vfs::directory_iterator
2699 LI = D.
getVFS().dir_begin(LibDir +
"/" + LibSuffix, EC),
2701 !EC && LI !=
LE; LI = LI.increment(EC)) {
2702 StringRef VersionText = llvm::sys::path::filename(LI->path());
2703 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2704 if (CandidateVersion.Major != -1)
2705 if (!CandidateGCCInstallPaths.insert(
std::string(LI->path())).second)
2707 if (CandidateVersion.isOlderThan(4, 1, 1))
2709 if (CandidateVersion <= Version)
2712 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
2716 Version = CandidateVersion;
2717 GCCTriple.setTriple(CandidateTriple);
2721 GCCInstallPath = (LibDir +
"/" + LibSuffix +
"/" + VersionText).str();
2722 GCCParentLibPath = (GCCInstallPath +
"/../" + Suffix.ReversePath).str();
2728 bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
2729 const llvm::Triple &TargetTriple,
const ArgList &Args,
2735 for (StringRef CandidateTriple : CandidateTriples) {
2736 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
2740 for (StringRef CandidateTriple : CandidateBiarchTriples) {
2741 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple,
true))
2747 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2748 const llvm::Triple &TargetTriple,
const ArgList &Args,
2749 StringRef CandidateTriple,
bool NeedsBiarchSuffix) {
2750 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
File =
2751 D.
getVFS().getBufferForFile(concat(D.
SysRoot, GentooConfigDir,
2752 "/config-" + CandidateTriple.str()));
2755 File.get()->getBuffer().split(Lines,
"\n");
2756 for (StringRef
Line : Lines) {
2759 if (!
Line.consume_front(
"CURRENT="))
2762 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
2763 D.
getVFS().getBufferForFile(
2765 std::pair<StringRef, StringRef> ActiveVersion =
Line.rsplit(
'-');
2778 ConfigFile.get()->getBuffer().split(ConfigLines,
"\n");
2779 for (StringRef ConfLine : ConfigLines) {
2780 ConfLine = ConfLine.trim();
2781 if (ConfLine.consume_front(
"LDPATH=")) {
2783 ConfLine.consume_back(
"\"");
2784 ConfLine.consume_front(
"\"");
2786 ConfLine.split(GentooScanPaths,
':', -1,
false);
2791 std::string basePath =
"/usr/lib/gcc/" + ActiveVersion.first.str() +
"/"
2792 + ActiveVersion.second.str();
2793 GentooScanPaths.push_back(StringRef(basePath));
2796 for (
const auto &GentooScanPath : GentooScanPaths) {
2798 if (D.
getVFS().exists(GentooPath +
"/crtbegin.o")) {
2799 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2803 Version = GCCVersion::Parse(ActiveVersion.second);
2804 GCCInstallPath = GentooPath;
2805 GCCParentLibPath = GentooPath +
std::string(
"/../../..");
2806 GCCTriple.setTriple(ActiveVersion.first);
2818 const ArgList &Args)
2819 :
ToolChain(D, Triple, Args), GCCInstallation(D),
2820 CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {
2833 return Preprocess.get();
2837 return Compile.get();
2859 case llvm::Triple::aarch64:
2860 case llvm::Triple::ppc:
2861 case llvm::Triple::ppcle:
2862 case llvm::Triple::ppc64:
2863 case llvm::Triple::ppc64le:
2864 case llvm::Triple::x86:
2865 case llvm::Triple::x86_64:
2874 case llvm::Triple::x86_64:
2876 case llvm::Triple::mips64:
2877 case llvm::Triple::mips64el:
2894 case llvm::Triple::aarch64:
2895 case llvm::Triple::aarch64_be:
2896 case llvm::Triple::amdgcn:
2897 case llvm::Triple::arm:
2898 case llvm::Triple::armeb:
2899 case llvm::Triple::avr:
2900 case llvm::Triple::bpfel:
2901 case llvm::Triple::bpfeb:
2902 case llvm::Triple::csky:
2903 case llvm::Triple::hexagon:
2904 case llvm::Triple::lanai:
2905 case llvm::Triple::loongarch32:
2906 case llvm::Triple::loongarch64:
2907 case llvm::Triple::m68k:
2908 case llvm::Triple::mips:
2909 case llvm::Triple::mipsel:
2910 case llvm::Triple::mips64:
2911 case llvm::Triple::mips64el:
2912 case llvm::Triple::msp430:
2913 case llvm::Triple::ppc:
2914 case llvm::Triple::ppcle:
2915 case llvm::Triple::ppc64:
2916 case llvm::Triple::ppc64le:
2917 case llvm::Triple::r600:
2918 case llvm::Triple::riscv32:
2919 case llvm::Triple::riscv64:
2920 case llvm::Triple::sparc:
2921 case llvm::Triple::sparcel:
2922 case llvm::Triple::sparcv9:
2923 case llvm::Triple::systemz:
2924 case llvm::Triple::thumb:
2925 case llvm::Triple::thumbeb:
2926 case llvm::Triple::ve:
2927 case llvm::Triple::x86:
2928 case llvm::Triple::x86_64:
2996 LibPath +
"/../" + GCCTriple.str() +
"/lib/../" + OSLibDir +
3009 if (StringRef(LibPath).startswith(SysRoot))
3030 ArgStringList &CC1Args)
const {
3038 Twine(LibPath) +
"/../" + GCCTriple.str() +
"/include");
3049 ArgStringList &CC1Args)
const {
3050 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdincxx,
3051 options::OPT_nostdlibinc))
3067 llvm::opt::ArgStringList &CC1Args)
const {
3074 if (Version.empty())
3079 if (D.
getVFS().exists(TargetDir))
3090 if (AddIncludePath(
getDriver().Dir +
"/../include"))
3095 if (AddIncludePath(
concat(SysRoot,
"/usr/local/include")))
3097 if (AddIncludePath(
concat(SysRoot,
"/usr/include")))
3102 Twine IncludeSuffix,
3103 const llvm::opt::ArgList &DriverArgs,
3104 llvm::opt::ArgStringList &CC1Args,
3105 bool DetectDebian)
const {
3106 if (!
getVFS().exists(IncludeDir))
3114 llvm::sys::path::parent_path(llvm::sys::path::parent_path(Dir));
3116 (Include +
"/" + Triple + Dir.substr(Include.size()) + IncludeSuffix)
3118 if (DetectDebian && !
getVFS().exists(Path))
3127 else if (!Triple.empty())
3129 IncludeDir +
"/" + Triple + IncludeSuffix);
3136 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
3137 StringRef DebianMultiarch)
const {
3151 LibDir.str() +
"/../" + TripleStr +
"/include/c++/" + Version.
Text,
3159 Version.
Text +
"/include/c++/",
3167 DriverArgs, CC1Args,
true))
3178 const std::string LibStdCXXIncludePathCandidates[] = {
3181 InstallDir.str() +
"/include/g++-v" + Version.
Text,
3182 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr +
"." +
3184 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr,
3187 for (
const auto &IncludePath : LibStdCXXIncludePathCandidates) {
3197 llvm::opt::ArgStringList &CC1Args)
const {
3204 llvm::opt::DerivedArgList *
3213 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
3218 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_shared));
3219 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_fPIC));
3223 for (
auto *A : Args) {
3228 case options::OPT_shared:
3229 case options::OPT_dynamic:
3230 case options::OPT_static:
3231 case options::OPT_fPIC:
3232 case options::OPT_fno_PIC:
3233 case options::OPT_fpic:
3234 case options::OPT_fno_pic:
3235 case options::OPT_fPIE:
3236 case options::OPT_fno_PIE:
3237 case options::OPT_fpie:
3238 case options::OPT_fno_pie:
3247 void Generic_ELF::anchor() {}
3250 ArgStringList &CC1Args,
3252 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
3253 options::OPT_fno_use_init_array,
true))
3254 CC1Args.push_back(
"-fno-use-init-array");