20#include "clang/Config/config.h"
28#include "llvm/ADT/StringSet.h"
29#include "llvm/ADT/Twine.h"
30#include "llvm/Option/ArgList.h"
31#include "llvm/Support/CodeGen.h"
32#include "llvm/Support/Path.h"
33#include "llvm/Support/VirtualFileSystem.h"
34#include "llvm/TargetParser/TargetParser.h"
35#include <system_error>
56 ArgStringList &CmdArgs) {
57 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
58 StringRef CPUArg(A->getValue());
59 if (CPUArg.equals_insensitive(
"krait"))
60 CmdArgs.push_back(
"-mcpu=cortex-a15");
61 else if (CPUArg.equals_insensitive(
"kryo"))
62 CmdArgs.push_back(
"-mcpu=cortex-a57");
64 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
72 const char *LinkingOutput)
const {
74 ArgStringList CmdArgs;
76 for (
const auto &A : Args) {
84 A->render(Args, CmdArgs);
92 CmdArgs.push_back(
"-arch");
94 Args.MakeArgString(
getToolChain().getDefaultUniversalArchName()));
105 case llvm::Triple::x86:
106 case llvm::Triple::ppc:
107 case llvm::Triple::ppcle:
108 CmdArgs.push_back(
"-m32");
110 case llvm::Triple::x86_64:
111 case llvm::Triple::ppc64:
112 case llvm::Triple::ppc64le:
113 CmdArgs.push_back(
"-m64");
115 case llvm::Triple::sparcel:
116 CmdArgs.push_back(
"-EL");
122 CmdArgs.push_back(
"-o");
125 CmdArgs.push_back(
"-fsyntax-only");
128 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
138 for (
const auto &II : Inputs) {
141 D.
Diag(clang::diag::err_drv_no_linker_llvm_support)
143 else if (II.getType() == types::TY_AST)
145 else if (II.getType() == types::TY_ModuleFile)
146 D.
Diag(diag::err_drv_no_module_support)
150 CmdArgs.push_back(
"-x");
155 CmdArgs.push_back(II.getFilename());
157 const Arg &A = II.getInputArg();
160 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
161 CmdArgs.push_back(
"-lstdc++");
166 A.render(Args, CmdArgs);
172 if (!customGCCName.empty())
173 GCCName = customGCCName.c_str();
179 const char *Exec = Args.MakeArgString(
getToolChain().GetProgramPath(GCCName));
180 C.addCommand(std::make_unique<Command>(JA, *
this,
182 Exec, CmdArgs, Inputs, Output));
186 const JobAction &JA, ArgStringList &CmdArgs)
const {
187 CmdArgs.push_back(
"-E");
191 ArgStringList &CmdArgs)
const {
192 const Driver &D = getToolChain().getDriver();
196 case types::TY_LLVM_IR:
197 case types::TY_LTO_IR:
198 case types::TY_LLVM_BC:
199 case types::TY_LTO_BC:
200 CmdArgs.push_back(
"-c");
204 case types::TY_Object:
205 CmdArgs.push_back(
"-c");
207 case types::TY_PP_Asm:
208 CmdArgs.push_back(
"-S");
210 case types::TY_Nothing:
211 CmdArgs.push_back(
"-fsyntax-only");
214 D.
Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.
getType());
219 ArgStringList &CmdArgs)
const {
223static const char *
getLDMOption(
const llvm::Triple &T,
const ArgList &Args) {
224 switch (T.getArch()) {
225 case llvm::Triple::x86:
229 case llvm::Triple::aarch64:
230 return "aarch64linux";
231 case llvm::Triple::aarch64_be:
232 return "aarch64linuxb";
233 case llvm::Triple::arm:
234 case llvm::Triple::thumb:
235 case llvm::Triple::armeb:
236 case llvm::Triple::thumbeb:
238 :
"armelf_linux_eabi";
239 case llvm::Triple::m68k:
241 case llvm::Triple::ppc:
243 return "elf32ppclinux";
245 case llvm::Triple::ppcle:
247 return "elf32lppclinux";
249 case llvm::Triple::ppc64:
251 case llvm::Triple::ppc64le:
253 case llvm::Triple::riscv32:
254 return "elf32lriscv";
255 case llvm::Triple::riscv64:
256 return "elf64lriscv";
257 case llvm::Triple::sparc:
258 case llvm::Triple::sparcel:
259 return "elf32_sparc";
260 case llvm::Triple::sparcv9:
261 return "elf64_sparc";
262 case llvm::Triple::loongarch32:
263 return "elf32loongarch";
264 case llvm::Triple::loongarch64:
265 return "elf64loongarch";
266 case llvm::Triple::mips:
267 return "elf32btsmip";
268 case llvm::Triple::mipsel:
269 return "elf32ltsmip";
270 case llvm::Triple::mips64:
272 T.getEnvironment() == llvm::Triple::GNUABIN32)
273 return "elf32btsmipn32";
274 return "elf64btsmip";
275 case llvm::Triple::mips64el:
277 T.getEnvironment() == llvm::Triple::GNUABIN32)
278 return "elf32ltsmipn32";
279 return "elf64ltsmip";
280 case llvm::Triple::systemz:
282 case llvm::Triple::x86_64:
284 return "elf32_x86_64";
286 case llvm::Triple::ve:
288 case llvm::Triple::csky:
289 return "cskyelf_linux";
296 bool HasStaticPIE = Args.hasArg(options::OPT_static_pie);
297 if (HasStaticPIE && Args.hasArg(options::OPT_no_pie)) {
299 const llvm::opt::OptTable &Opts = D.
getOpts();
300 StringRef StaticPIEName = Opts.getOptionName(options::OPT_static_pie);
301 StringRef NoPIEName = Opts.getOptionName(options::OPT_nopie);
302 D.
Diag(diag::err_drv_cannot_mix_options) << StaticPIEName << NoPIEName;
308 return Args.hasArg(options::OPT_static) &&
309 !Args.hasArg(options::OPT_static_pie);
315 const char *LinkingOutput)
const {
316 const Driver &D = getToolChain().getDriver();
319 Args.ClaimAllArgs(options::OPT_g_Group);
321 Args.ClaimAllArgs(options::OPT_emit_llvm);
324 Args.ClaimAllArgs(options::OPT_w);
326 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
329 ArgStringList CmdArgs;
331 CmdArgs.push_back(
"rcsD");
334 for (
const auto &II : Inputs) {
335 if (II.isFilename()) {
336 CmdArgs.push_back(II.getFilename());
343 if (Output.
isFilename() && llvm::sys::fs::exists(OutputFileName)) {
344 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
345 D.
Diag(diag::err_drv_unable_to_remove_file) << EC.message();
350 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
351 C.addCommand(std::make_unique<Command>(JA, *
this,
353 Exec, CmdArgs, Inputs, Output));
360 const char *LinkingOutput)
const {
368 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
377 const bool HasCRTBeginEndFiles =
381 ArgStringList CmdArgs;
384 Args.ClaimAllArgs(options::OPT_g_Group);
386 Args.ClaimAllArgs(options::OPT_emit_llvm);
389 Args.ClaimAllArgs(options::OPT_w);
392 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
394 if (Args.hasArg(options::OPT_s))
395 CmdArgs.push_back(
"-s");
397 if (Triple.isARM() || Triple.isThumb()) {
401 CmdArgs.push_back(IsBigEndian ?
"-EB" :
"-EL");
402 }
else if (Triple.isAArch64()) {
403 CmdArgs.push_back(Arch == llvm::Triple::aarch64_be ?
"-EB" :
"-EL");
408 if (Arch == llvm::Triple::aarch64 && (isAndroid || isOHOSFamily)) {
409 std::string CPU =
getCPUName(D, Args, Triple);
410 if (CPU.empty() || CPU ==
"generic" || CPU ==
"cortex-a53")
411 CmdArgs.push_back(
"--fix-cortex-a53-843419");
416 CmdArgs.push_back(
"--eh-frame-hdr");
419 CmdArgs.push_back(
"-m");
420 CmdArgs.push_back(LDMOption);
422 D.
Diag(diag::err_target_unknown_triple) << Triple.str();
425 if (Triple.isRISCV())
426 CmdArgs.push_back(
"-X");
428 const bool IsShared = Args.hasArg(options::OPT_shared);
430 CmdArgs.push_back(
"-shared");
433 CmdArgs.push_back(
"-static");
434 CmdArgs.push_back(
"-pie");
435 CmdArgs.push_back(
"--no-dynamic-linker");
436 CmdArgs.push_back(
"-z");
437 CmdArgs.push_back(
"text");
439 CmdArgs.push_back(
"-static");
440 }
else if (!Args.hasArg(options::OPT_r)) {
441 if (Args.hasArg(options::OPT_rdynamic))
442 CmdArgs.push_back(
"-export-dynamic");
444 IsPIE = Args.hasFlag(options::OPT_pie, options::OPT_no_pie,
447 CmdArgs.push_back(
"-pie");
448 CmdArgs.push_back(
"-dynamic-linker");
449 CmdArgs.push_back(Args.MakeArgString(Twine(D.
DyldPrefix) +
454 CmdArgs.push_back(
"-o");
457 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles,
459 if (!isAndroid && !IsIAMCU) {
460 const char *crt1 =
nullptr;
461 if (!Args.hasArg(options::OPT_shared)) {
462 if (Args.hasArg(options::OPT_pg))
466 else if (IsStaticPIE)
478 CmdArgs.push_back(
"-z");
479 CmdArgs.push_back(
"max-page-size=0x4000000");
484 else if (HasCRTBeginEndFiles) {
494 const char *crtbegin;
495 if (Args.hasArg(options::OPT_shared))
496 crtbegin = isAndroid ?
"crtbegin_so.o" :
"crtbeginS.o";
498 crtbegin = isAndroid ?
"crtbegin_static.o" :
"crtbeginT.o";
499 else if (IsPIE || IsStaticPIE)
500 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbeginS.o";
502 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbegin.o";
505 CmdArgs.push_back(Args.MakeArgString(
P));
512 Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_u});
517 assert(!Inputs.empty() &&
"Must have at least one input.");
519 auto Input = llvm::find_if(
521 if (Input == Inputs.end())
524 Input = Inputs.begin();
530 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
531 CmdArgs.push_back(
"--no-demangle");
541 getToolChain().addProfileRTLibs(Args, CmdArgs);
544 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
547 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
548 !Args.hasArg(options::OPT_static);
549 if (OnlyLibstdcxxStatic)
550 CmdArgs.push_back(
"-Bstatic");
552 if (OnlyLibstdcxxStatic)
553 CmdArgs.push_back(
"-Bdynamic");
555 CmdArgs.push_back(
"-lm");
559 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
568 CmdArgs.push_back(
"-lm");
571 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_r)) {
572 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
574 CmdArgs.push_back(
"--start-group");
576 if (NeedsSanitizerDeps)
582 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
583 Args.hasArg(options::OPT_pthreads);
586 bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&
587 !Args.hasArg(options::OPT_static);
603 if (getToolChain().getTriple().getArch() == llvm::Triple::sparc) {
604 CmdArgs.push_back(
"--push-state");
605 CmdArgs.push_back(
"--as-needed");
606 CmdArgs.push_back(
"-latomic");
607 CmdArgs.push_back(
"--pop-state");
612 if (WantPthread && !isAndroid && !isOHOSFamily)
613 CmdArgs.push_back(
"-lpthread");
615 if (Args.hasArg(options::OPT_fsplit_stack))
616 CmdArgs.push_back(
"--wrap=pthread_create");
618 if (!Args.hasArg(options::OPT_nolibc))
619 CmdArgs.push_back(
"-lc");
623 CmdArgs.push_back(
"-lgloss");
626 CmdArgs.push_back(
"--end-group");
632 CmdArgs.push_back(
"--as-needed");
633 CmdArgs.push_back(
"-lsoftfp");
634 CmdArgs.push_back(
"--no-as-needed");
638 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
639 if (HasCRTBeginEndFiles) {
650 if (Args.hasArg(options::OPT_shared))
651 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
652 else if (IsPIE || IsStaticPIE)
653 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
655 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
658 CmdArgs.push_back(Args.MakeArgString(
P));
665 Args.AddAllArgs(CmdArgs, options::OPT_T);
668 C.addCommand(std::make_unique<Command>(JA, *
this,
670 Exec, CmdArgs, Inputs, Output));
678 const char *LinkingOutput)
const {
679 const auto &D = getToolChain().getDriver();
683 ArgStringList CmdArgs;
685 llvm::Reloc::Model RelocationModel;
688 const char *DefaultAssembler =
"as";
691 if (getToolChain().getTriple().isOSSolaris())
692 DefaultAssembler =
"gas";
693 std::tie(RelocationModel, PICLevel, IsPIE) =
696 if (
const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
697 if (A->getOption().getID() == options::OPT_gz) {
698 CmdArgs.push_back(
"--compress-debug-sections");
700 StringRef
Value = A->getValue();
703 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
705 D.Diag(diag::err_drv_unsupported_option_argument)
706 << A->getSpelling() <<
Value;
711 switch (getToolChain().getArch()) {
716 case llvm::Triple::x86:
717 CmdArgs.push_back(
"--32");
719 case llvm::Triple::x86_64:
720 if (getToolChain().getTriple().isX32())
721 CmdArgs.push_back(
"--x32");
723 CmdArgs.push_back(
"--64");
725 case llvm::Triple::ppc: {
726 CmdArgs.push_back(
"-a32");
727 CmdArgs.push_back(
"-mppc");
728 CmdArgs.push_back(
"-mbig-endian");
730 getCPUName(D, Args, getToolChain().getTriple())));
733 case llvm::Triple::ppcle: {
734 CmdArgs.push_back(
"-a32");
735 CmdArgs.push_back(
"-mppc");
736 CmdArgs.push_back(
"-mlittle-endian");
738 getCPUName(D, Args, getToolChain().getTriple())));
741 case llvm::Triple::ppc64: {
742 CmdArgs.push_back(
"-a64");
743 CmdArgs.push_back(
"-mppc64");
744 CmdArgs.push_back(
"-mbig-endian");
746 getCPUName(D, Args, getToolChain().getTriple())));
749 case llvm::Triple::ppc64le: {
750 CmdArgs.push_back(
"-a64");
751 CmdArgs.push_back(
"-mppc64");
752 CmdArgs.push_back(
"-mlittle-endian");
754 getCPUName(D, Args, getToolChain().getTriple())));
757 case llvm::Triple::riscv32:
758 case llvm::Triple::riscv64: {
760 CmdArgs.push_back(
"-mabi");
761 CmdArgs.push_back(ABIName.data());
763 CmdArgs.push_back(
"-march");
764 CmdArgs.push_back(MArchName.data());
765 if (!Args.hasFlag(options::OPT_mrelax, options::OPT_mno_relax,
true))
766 Args.addOptOutFlag(CmdArgs, options::OPT_mrelax, options::OPT_mno_relax);
769 case llvm::Triple::sparc:
770 case llvm::Triple::sparcel: {
771 CmdArgs.push_back(
"-32");
772 std::string CPU =
getCPUName(D, Args, getToolChain().getTriple());
778 case llvm::Triple::sparcv9: {
779 CmdArgs.push_back(
"-64");
780 std::string CPU =
getCPUName(D, Args, getToolChain().getTriple());
786 case llvm::Triple::arm:
787 case llvm::Triple::armeb:
788 case llvm::Triple::thumb:
789 case llvm::Triple::thumbeb: {
790 const llvm::Triple &Triple2 = getToolChain().getTriple();
792 switch (Triple2.getSubArch()) {
793 case llvm::Triple::ARMSubArch_v7:
794 CmdArgs.push_back(
"-mfpu=neon");
796 case llvm::Triple::ARMSubArch_v8:
797 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
806 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=soft"));
809 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=softfp"));
812 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=hard"));
816 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
819 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
823 if (Arg *A = Args.getLastArgNoClaim(options::OPT_mabi_EQ))
824 A->ignoreTargetSpecific();
827 case llvm::Triple::aarch64:
828 case llvm::Triple::aarch64_be: {
830 getToolChain().getArch() == llvm::Triple::aarch64_be ?
"-EB" :
"-EL");
831 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
837 case llvm::Triple::loongarch64: {
840 CmdArgs.push_back(Args.MakeArgString(
"-mabi=" + ABIName));
843 case llvm::Triple::mips:
844 case llvm::Triple::mipsel:
845 case llvm::Triple::mips64:
846 case llvm::Triple::mips64el: {
852 CmdArgs.push_back(
"-march");
853 CmdArgs.push_back(CPUName.data());
855 CmdArgs.push_back(
"-mabi");
856 CmdArgs.push_back(ABIName.data());
860 if (RelocationModel == llvm::Reloc::Static)
861 CmdArgs.push_back(
"-mno-shared");
865 if (ABIName !=
"64" && !Args.hasArg(options::OPT_mno_abicalls))
866 CmdArgs.push_back(
"-call_nonpic");
868 if (getToolChain().getTriple().isLittleEndian())
869 CmdArgs.push_back(
"-EL");
871 CmdArgs.push_back(
"-EB");
873 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
874 if (StringRef(A->getValue()) ==
"2008")
875 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
879 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
880 options::OPT_mfp64)) {
882 A->render(Args, CmdArgs);
884 Args, getToolChain().getTriple(), CPUName, ABIName,
886 getToolChain().getTriple())))
887 CmdArgs.push_back(
"-mfpxx");
892 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
893 if (A->getOption().matches(options::OPT_mips16)) {
895 A->render(Args, CmdArgs);
898 CmdArgs.push_back(
"-no-mips16");
902 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
903 options::OPT_mno_micromips);
904 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
905 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
907 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
910 if (A->getOption().matches(options::OPT_mmsa))
911 CmdArgs.push_back(Args.MakeArgString(
"-mmsa"));
914 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
915 options::OPT_msoft_float);
917 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
918 options::OPT_msingle_float);
920 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
921 options::OPT_mno_odd_spreg);
926 case llvm::Triple::systemz: {
930 CmdArgs.push_back(Args.MakeArgString(
"-march=" + CPUName));
933 case llvm::Triple::ve:
934 DefaultAssembler =
"nas";
937 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
938 options::OPT_fdebug_prefix_map_EQ)) {
939 StringRef Map = A->getValue();
940 if (!Map.contains(
'='))
941 D.Diag(diag::err_drv_invalid_argument_to_option)
942 << Map << A->getOption().getName();
944 CmdArgs.push_back(Args.MakeArgString(
"--debug-prefix-map"));
945 CmdArgs.push_back(Args.MakeArgString(Map));
950 Args.AddAllArgs(CmdArgs, options::OPT_I);
951 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
953 CmdArgs.push_back(
"-o");
956 for (
const auto &II : Inputs)
957 CmdArgs.push_back(II.getFilename());
959 if (Arg *A = Args.getLastArg(options::OPT_g_Flag, options::OPT_gN_Group,
960 options::OPT_gdwarf_2, options::OPT_gdwarf_3,
961 options::OPT_gdwarf_4, options::OPT_gdwarf_5,
962 options::OPT_gdwarf))
963 if (!A->getOption().matches(options::OPT_g0)) {
964 Args.AddLastArg(CmdArgs, options::OPT_g_Flag);
967 CmdArgs.push_back(Args.MakeArgString(
"-gdwarf-" + Twine(DwarfVersion)));
971 Args.MakeArgString(getToolChain().GetProgramPath(DefaultAssembler));
972 C.addCommand(std::make_unique<Command>(JA, *
this,
974 Exec, CmdArgs, Inputs, Output));
979 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
980 getToolChain().getTriple().isOSLinux())
987class FilterNonExistent {
989 llvm::vfs::FileSystem &VFS;
992 FilterNonExistent(StringRef
Base, StringRef
File, llvm::vfs::FileSystem &VFS)
994 bool operator()(
const Multilib &M) {
1001 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1002 options::OPT_mfloat_abi_EQ);
1006 return A->getOption().matches(options::OPT_msoft_float) ||
1007 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
1008 A->getValue() == StringRef(
"soft"));
1012 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
1016 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1020 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
1021 return A && A->getOption().matches(options::OPT_mips16);
1025 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
1026 return A && A->getOption().matches(options::OPT_mmicromips);
1030 return Arch == llvm::Triple::msp430;
1034 FilterNonExistent &NonExistent,
1041 auto MArchMicroMips =
1045 .
flag(
"-mips16",
true)
1046 .
flag(
"-mmicromips",
true);
1055 .
flag(
"-msoft-float",
true)
1056 .
flag(
"-mnan=2008",
true);
1067 .includeSuffix(
"/64")
1069 .flag(
"-mabi=n32",
true)
1070 .flag(
"-m32",
true);
1074 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
1076 .
Either(SoftFloat, Nan2008, DefaultFloat)
1079 .
Either(BigEndian, LittleEndian)
1086 std::vector<std::string> Dirs({
"/include"});
1089 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1091 Dirs.push_back(
"/../../../../mips-linux-gnu/libc/usr/include");
1104 .includeSuffix(
"/64")
1107 .flag(
"-mabi=n32",
true);
1113 .flag(
"-mabi=n32",
true);
1116 .
Either(M32, M64, MAbiN32)
1123 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1124 if (CSMipsMultilibs.
size() < DebianMipsMultilibs.
size())
1125 std::iter_swap(Candidates, Candidates + 1);
1127 if (Candidate->select(Flags,
Result.SelectedMultilibs)) {
1128 if (Candidate == &DebianMipsMultilibs)
1130 Result.Multilibs = *Candidate;
1139 FilterNonExistent &NonExistent,
1153 .flag(
"-march=mips32r2"),
1155 .flag(
"-march=mips32r6"))
1163 .flag(
"-march=mips32"),
1165 .flag(
"-march=mips32r2"),
1167 .flag(
"-march=mips32r6"))
1172 if (VFS.exists(Path +
"/mips-r6"))
1173 MS = &AndroidMipselMultilibs;
1174 else if (VFS.exists(Path +
"/32"))
1175 MS = &AndroidMips64elMultilibs;
1184 FilterNonExistent &NonExistent,
1193 .flag(
"-march=mips32r2");
1198 .
flag(
"-march=mips32r2");
1201 .
Either(MArchMipsR2, MArchMipselR2)
1206 return std::vector<std::string>(
1207 {
"/../sysroot" + M.
osSuffix() +
"/usr/include"});
1210 if (MuslMipsMultilibs.
select(Flags,
Result.SelectedMultilibs)) {
1211 Result.Multilibs = MuslMipsMultilibs;
1218 FilterNonExistent &NonExistent,
1226 .
flag(
"-mmicromips",
true)
1227 .
flag(
"-march=mips32");
1232 .
flag(
"-mmicromips");
1237 .
flag(
"-march=mips64r2");
1242 .
flag(
"-march=mips64r2",
true);
1247 .
flag(
"-mmicromips",
true)
1248 .
flag(
"-march=mips32r2");
1256 .
flag(
"-mabi=n32",
true)
1257 .
flag(
"-m32",
true);
1269 MtiMipsMultilibsV1 =
1271 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1283 .
Either(BigEndian, LittleEndian)
1290 std::vector<std::string> Dirs({
"/include"});
1292 Dirs.push_back(
"/../../../../sysroot/uclibc/usr/include");
1294 Dirs.push_back(
"/../../../../sysroot/usr/include");
1304 .
flag(
"-msoft-float",
true)
1305 .
flag(
"-mnan=2008",
true)
1306 .
flag(
"-muclibc",
true);
1309 .
flag(
"-msoft-float")
1310 .
flag(
"-mnan=2008",
true);
1313 .
flag(
"-msoft-float",
true)
1314 .
flag(
"-mnan=2008",
true)
1315 .
flag(
"-muclibc",
true);
1318 .
flag(
"-msoft-float")
1319 .
flag(
"-mnan=2008",
true)
1320 .
flag(
"-mmicromips",
true);
1323 .
flag(
"-msoft-float",
true)
1325 .
flag(
"-muclibc",
true);
1328 .
flag(
"-msoft-float",
true)
1330 .
flag(
"-muclibc",
true)
1331 .
flag(
"-mmicromips",
true);
1332 auto BeHardNanUclibc =
MultilibBuilder(
"/mips-r2-hard-nan2008-uclibc")
1334 .
flag(
"-msoft-float",
true)
1337 auto ElHardNanUclibc =
MultilibBuilder(
"/mipsel-r2-hard-nan2008-uclibc")
1339 .
flag(
"-msoft-float",
true)
1344 .
flag(
"-msoft-float",
true)
1345 .
flag(
"-mnan=2008",
true)
1349 .
flag(
"-msoft-float",
true)
1350 .
flag(
"-mnan=2008",
true)
1354 .
flag(
"-msoft-float",
true)
1356 .
flag(
"-mmicromips");
1359 .
flag(
"-msoft-float")
1360 .
flag(
"-mnan=2008",
true)
1361 .
flag(
"-mmicromips");
1365 .flag(
"-mabi=n32",
true)
1366 .flag(
"-mabi=n64",
true);
1370 .flag(
"-mabi=n64",
true);
1373 .flag(
"-mabi=n32",
true)
1376 MtiMipsMultilibsV2 =
1378 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1379 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1380 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1381 .Either(O32, N32, N64)
1385 return std::vector<std::string>({
"/../../../../sysroot" +
1387 "/../usr/include"});
1389 .setFilePathsCallback([](
const Multilib &M) {
1390 return std::vector<std::string>(
1391 {
"/../../../../mips-mti-linux-gnu/lib" + M.
gccSuffix()});
1394 for (
auto *Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1395 if (Candidate->select(Flags,
Result.SelectedMultilibs)) {
1396 Result.Multilibs = *Candidate;
1404 FilterNonExistent &NonExistent,
1411 .
flag(
"-m32",
true);
1418 .
flag(
"-mabi=n32",
true)
1419 .
flag(
"-m32",
true);
1425 .
Maybe(LittleEndian)
1429 return std::vector<std::string>(
1430 {
"/include",
"/../../../../sysroot/usr/include"});
1439 .
flag(
"-msoft-float",
true)
1440 .
flag(
"-mmicromips",
true);
1443 .
flag(
"-msoft-float")
1444 .
flag(
"-mmicromips",
true);
1447 .
flag(
"-msoft-float",
true)
1448 .
flag(
"-mmicromips",
true);
1451 .
flag(
"-msoft-float")
1452 .
flag(
"-mmicromips",
true);
1455 .
flag(
"-msoft-float",
true)
1456 .
flag(
"-mmicromips");
1459 .
flag(
"-msoft-float")
1460 .
flag(
"-mmicromips");
1463 .
flag(
"-msoft-float",
true)
1464 .
flag(
"-mmicromips");
1467 .
flag(
"-msoft-float")
1468 .
flag(
"-mmicromips");
1472 .flag(
"-mabi=n32",
true)
1473 .flag(
"-mabi=n64",
true);
1477 .flag(
"-mabi=n64",
true);
1480 .flag(
"-mabi=n32",
true)
1485 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1486 ElMicroHard, ElMicroSoft})
1487 .Either(O32, N32, N64)
1491 return std::vector<std::string>({
"/../../../../sysroot" +
1493 "/../usr/include"});
1495 .setFilePathsCallback([](
const Multilib &M) {
1496 return std::vector<std::string>(
1497 {
"/../../../../mips-img-linux-gnu/lib" + M.
gccSuffix()});
1500 for (
auto *Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1501 if (Candidate->select(Flags,
Result.SelectedMultilibs)) {
1502 Result.Multilibs = *Candidate;
1510 const llvm::Triple &TargetTriple,
1511 StringRef Path,
const ArgList &Args,
1513 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1519 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1527 CPUName ==
"mips32r5" || CPUName ==
"p5600",
1528 "-march=mips32r2", Flags);
1532 CPUName ==
"mips64r5" || CPUName ==
"octeon" ||
1533 CPUName ==
"octeon+",
1534 "-march=mips64r2", Flags);
1547 if (TargetTriple.isAndroid())
1551 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1552 TargetTriple.getOS() == llvm::Triple::Linux &&
1553 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1556 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1557 TargetTriple.getOS() == llvm::Triple::Linux &&
1558 TargetTriple.isGNUEnvironment())
1561 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1562 TargetTriple.getOS() == llvm::Triple::Linux &&
1563 TargetTriple.isGNUEnvironment())
1572 Result.Multilibs.FilterOut(NonExistent);
1574 if (
Result.Multilibs.select(Flags,
Result.SelectedMultilibs)) {
1583 const llvm::Triple &TargetTriple,
1584 StringRef Path,
const ArgList &Args,
1587 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1589 .
flag(
"-march=armv7-a")
1590 .
flag(
"-mthumb",
true);
1592 .
flag(
"-march=armv7-a",
true)
1598 .
flag(
"-march=armv7-a",
true)
1599 .
flag(
"-mthumb",
true);
1602 .
Either(ThumbMultilib, ArmV7Multilib, ArmV7ThumbMultilib,
1608 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1609 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1610 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1611 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1612 bool IsThumbMode = IsThumbArch ||
1613 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb,
false) ||
1614 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1615 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1616 (llvm::ARM::parseArchVersion(Arch) == 7 ||
1617 (IsArmArch && Arch ==
"" && IsV7SubArch));
1618 addMultilibFlag(IsArmV7Mode,
"-march=armv7-a", Flags);
1619 addMultilibFlag(IsThumbMode,
"-mthumb", Flags);
1621 if (AndroidArmMultilibs.
select(Flags,
Result.SelectedMultilibs))
1622 Result.Multilibs = AndroidArmMultilibs;
1626 const llvm::Triple &TargetTriple,
1627 StringRef Path,
const ArgList &Args,
1629 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1641 Result.Multilibs.FilterOut(NonExistent);
1644 addMultilibFlag(Args.hasFlag(options::OPT_fexceptions,
1645 options::OPT_fno_exceptions,
false),
1646 "-exceptions", Flags);
1647 if (
Result.Multilibs.select(Flags,
Result.SelectedMultilibs))
1654 StringRef Path,
const ArgList &Args,
1656 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1659 std::optional<llvm::StringRef> Res =
1664 auto ARCHName = *Res;
1672 addMultilibFlag(ARCHName ==
"ck801",
"-march=ck801", Flags);
1673 addMultilibFlag(ARCHName ==
"ck802",
"-march=ck802", Flags);
1674 addMultilibFlag(ARCHName ==
"ck803",
"-march=ck803", Flags);
1675 addMultilibFlag(ARCHName ==
"ck804",
"-march=ck804", Flags);
1676 addMultilibFlag(ARCHName ==
"ck805",
"-march=ck805", Flags);
1677 addMultilibFlag(ARCHName ==
"ck807",
"-march=ck807", Flags);
1678 addMultilibFlag(ARCHName ==
"ck810",
"-march=ck810", Flags);
1679 addMultilibFlag(ARCHName ==
"ck810v",
"-march=ck810v", Flags);
1680 addMultilibFlag(ARCHName ==
"ck860",
"-march=ck860", Flags);
1681 addMultilibFlag(ARCHName ==
"ck860v",
"-march=ck860v", Flags);
1683 bool isBigEndian =
false;
1684 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
1685 options::OPT_mbig_endian))
1686 isBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
1687 addMultilibFlag(isBigEndian,
"-EB", Flags);
1708 .
Either({Arch801, Arch802, Arch803, Arch804, Arch805, Arch807,
1709 Arch810, Arch810v, Arch860, Arch860v})
1710 .Either(HardFloat, SoftFpFloat, SoftFloat)
1714 if (CSKYMultilibs.
select(Flags,
Result.SelectedMultilibs))
1715 Result.Multilibs = CSKYMultilibs;
1719 const llvm::Triple &TargetTriple,
1720 StringRef Path,
const ArgList &Args,
1722 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1723 struct RiscvMultilib {
1729 constexpr RiscvMultilib RISCVMultilibSet[] = {
1730 {
"rv32i",
"ilp32"}, {
"rv32im",
"ilp32"}, {
"rv32iac",
"ilp32"},
1731 {
"rv32imac",
"ilp32"}, {
"rv32imafc",
"ilp32f"}, {
"rv64imac",
"lp64"},
1732 {
"rv64imafdc",
"lp64d"}};
1734 std::vector<MultilibBuilder> Ms;
1735 for (
auto Element : RISCVMultilibSet) {
1739 (Twine(Element.march) +
"/" + Twine(Element.mabi)).str())
1740 .
flag(Twine(
"-march=", Element.march).str())
1741 .
flag(Twine(
"-mabi=", Element.mabi).str()));
1749 return std::vector<std::string>(
1751 "/../../../../riscv64-unknown-elf/lib" + M.
gccSuffix(),
1752 "/../../../../riscv32-unknown-elf/lib" + M.
gccSuffix()});
1756 llvm::StringSet<> Added_ABIs;
1759 for (
auto Element : RISCVMultilibSet) {
1760 addMultilibFlag(MArch == Element.march,
1761 Twine(
"-march=", Element.march).str().c_str(), Flags);
1762 if (!Added_ABIs.count(Element.mabi)) {
1763 Added_ABIs.insert(Element.mabi);
1764 addMultilibFlag(ABIName == Element.mabi,
1765 Twine(
"-mabi=", Element.mabi).str().c_str(), Flags);
1769 if (RISCVMultilibs.
select(Flags,
Result.SelectedMultilibs))
1770 Result.Multilibs = RISCVMultilibs;
1774 const llvm::Triple &TargetTriple, StringRef Path,
1776 if (TargetTriple.getOS() == llvm::Triple::UnknownOS)
1779 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1794 .
Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1799 bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1802 addMultilibFlag(!IsRV64,
"-m32", Flags);
1803 addMultilibFlag(IsRV64,
"-m64", Flags);
1804 addMultilibFlag(ABIName ==
"ilp32",
"-mabi=ilp32", Flags);
1805 addMultilibFlag(ABIName ==
"ilp32f",
"-mabi=ilp32f", Flags);
1806 addMultilibFlag(ABIName ==
"ilp32d",
"-mabi=ilp32d", Flags);
1807 addMultilibFlag(ABIName ==
"lp64",
"-mabi=lp64", Flags);
1808 addMultilibFlag(ABIName ==
"lp64f",
"-mabi=lp64f", Flags);
1809 addMultilibFlag(ABIName ==
"lp64d",
"-mabi=lp64d", Flags);
1811 if (RISCVMultilibs.
select(Flags,
Result.SelectedMultilibs))
1812 Result.Multilibs = RISCVMultilibs;
1816 const llvm::Triple &TargetTriple,
1817 StringRef Path,
const ArgList &Args,
1818 bool NeedsBiarchSuffix,
1829 StringRef Suff64 =
"/64";
1831 if (TargetTriple.isOSSolaris()) {
1832 switch (TargetTriple.getArch()) {
1833 case llvm::Triple::x86:
1834 case llvm::Triple::x86_64:
1837 case llvm::Triple::sparc:
1838 case llvm::Triple::sparcv9:
1839 Suff64 =
"/sparcv9";
1848 .includeSuffix(Suff64)
1851 .flag(
"-mx32",
true)
1855 .includeSuffix(
"/32")
1858 .flag(
"-mx32",
true)
1862 .includeSuffix(
"/x32")
1869 .includeSuffix(
"/sparcv8plus")
1875 FilterNonExistent NonExistent(
1876 Path, TargetTriple.isOSIAMCU() ?
"/libgcc.a" :
"/crtbegin.o", D.
getVFS());
1881 const bool IsX32 = TargetTriple.isX32();
1882 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1884 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32sparc))
1886 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1888 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1890 else if (TargetTriple.isArch64Bit() && !NonExistent(Alt32sparc))
1893 if (TargetTriple.isArch32Bit())
1894 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1896 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1898 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1902 DefaultBuilder.
flag(
"-m32")
1904 .
flag(
"-mx32",
true);
1905 else if (Want == WANT64)
1906 DefaultBuilder.
flag(
"-m32",
true)
1908 .
flag(
"-mx32",
true);
1909 else if (Want == WANTX32)
1910 DefaultBuilder.
flag(
"-m32",
true)
1919 Result.Multilibs.push_back(Alt64);
1920 Result.Multilibs.push_back(Alt32);
1921 Result.Multilibs.push_back(Altx32);
1922 Result.Multilibs.push_back(Alt32sparc);
1924 Result.Multilibs.FilterOut(NonExistent);
1927 addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32,
"-m64", Flags);
1928 addMultilibFlag(TargetTriple.isArch32Bit(),
"-m32", Flags);
1929 addMultilibFlag(TargetTriple.isArch64Bit() && IsX32,
"-mx32", Flags);
1931 if (!
Result.Multilibs.select(Flags,
Result.SelectedMultilibs))
1934 if (
Result.SelectedMultilibs.back() == Alt64 ||
1935 Result.SelectedMultilibs.back() == Alt32 ||
1936 Result.SelectedMultilibs.back() == Altx32 ||
1937 Result.SelectedMultilibs.back() == Alt32sparc)
1950 StringRef RHSPatchSuffix)
const {
1951 if (Major != RHSMajor)
1952 return Major < RHSMajor;
1953 if (Minor != RHSMinor) {
1960 return Minor < RHSMinor;
1962 if (Patch != RHSPatch) {
1971 return Patch < RHSPatch;
1973 if (PatchSuffix != RHSPatchSuffix) {
1975 if (RHSPatchSuffix.empty())
1977 if (PatchSuffix.empty())
1981 return PatchSuffix < RHSPatchSuffix;
1993 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1994 std::pair<StringRef, StringRef>
First = VersionText.split(
'.');
1995 std::pair<StringRef, StringRef> Second =
First.second.split(
'.');
1997 StringRef MajorStr =
First.first;
1998 StringRef MinorStr = Second.first;
1999 StringRef PatchStr = Second.second;
2001 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
2017 auto TryParseLastNumber = [&](StringRef Segment,
int &Number,
2018 std::string &OutStr) ->
bool {
2022 if (
size_t EndNumber = Segment.find_first_not_of(
"0123456789")) {
2023 StringRef NumberStr = Segment.slice(0, EndNumber);
2024 if (NumberStr.getAsInteger(10, Number) || Number < 0)
2027 GoodVersion.
PatchSuffix = Segment.substr(EndNumber);
2032 auto TryParseNumber = [](StringRef Segment,
int &Number) ->
bool {
2033 if (Segment.getAsInteger(10, Number) || Number < 0)
2038 if (MinorStr.empty()) {
2040 if (!TryParseLastNumber(MajorStr, GoodVersion.
Major, GoodVersion.
MajorStr))
2045 if (!TryParseNumber(MajorStr, GoodVersion.
Major))
2049 if (PatchStr.empty()) {
2051 if (!TryParseLastNumber(MinorStr, GoodVersion.
Minor, GoodVersion.
MinorStr))
2056 if (!TryParseNumber(MinorStr, GoodVersion.
Minor))
2061 std::string DummyStr;
2062 TryParseLastNumber(PatchStr, GoodVersion.
Patch, DummyStr);
2067 llvm::StringRef SysRoot) {
2068 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
2070 return A->getValue();
2075 if (!SysRoot.empty())
2078 return GCC_INSTALL_PREFIX;
2091 const llvm::Triple &TargetTriple,
const ArgList &Args) {
2092 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
2093 ? TargetTriple.get64BitArchVariant()
2094 : TargetTriple.get32BitArchVariant();
2101 CandidateTripleAliases.push_back(TargetTriple.str());
2102 std::string TripleNoVendor = TargetTriple.getArchName().str() +
"-" +
2103 TargetTriple.getOSAndEnvironmentName().str();
2104 if (TargetTriple.getVendor() == llvm::Triple::UnknownVendor)
2105 CandidateTripleAliases.push_back(TripleNoVendor);
2107 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
2108 CandidateTripleAliases, CandidateBiarchLibDirs,
2109 CandidateBiarchTripleAliases);
2113 Args.getLastArg(clang::driver::options::OPT_gcc_install_dir_EQ);
2114 A && A->getValue()[0]) {
2115 StringRef InstallDir = A->getValue();
2116 if (!ScanGCCForMultilibs(TargetTriple, Args, InstallDir,
false)) {
2117 D.
Diag(diag::err_drv_invalid_gcc_install_dir) << InstallDir;
2119 (void)InstallDir.consume_back(
"/");
2120 StringRef VersionText = llvm::sys::path::filename(InstallDir);
2121 StringRef TripleText =
2122 llvm::sys::path::filename(llvm::sys::path::parent_path(InstallDir));
2124 Version = GCCVersion::Parse(VersionText);
2125 GCCTriple.setTriple(TripleText);
2126 GCCInstallPath = std::string(InstallDir);
2127 GCCParentLibPath = GCCInstallPath +
"/../../..";
2136 if (GCCToolchainDir !=
"") {
2137 if (GCCToolchainDir.back() ==
'/')
2138 GCCToolchainDir = GCCToolchainDir.drop_back();
2140 Prefixes.push_back(std::string(GCCToolchainDir));
2144 Prefixes.push_back(D.
SysRoot);
2145 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
2155 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
2167 GentooTestTriples.push_back(TargetTriple.str());
2168 GentooTestTriples.append(CandidateTripleAliases.begin(),
2169 CandidateTripleAliases.end());
2170 if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
2171 CandidateBiarchTripleAliases))
2177 const GCCVersion VersionZero = GCCVersion::Parse(
"0.0.0");
2178 Version = VersionZero;
2179 for (
const std::string &Prefix : Prefixes) {
2181 if (!VFS.exists(Prefix))
2183 for (StringRef Suffix : CandidateLibDirs) {
2184 const std::string LibDir = concat(Prefix, Suffix);
2185 if (!VFS.exists(LibDir))
2188 bool GCCDirExists = VFS.exists(LibDir +
"/gcc");
2189 bool GCCCrossDirExists = VFS.exists(LibDir +
"/gcc-cross");
2190 for (StringRef Candidate : CandidateTripleAliases)
2191 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
false,
2192 GCCDirExists, GCCCrossDirExists);
2194 for (StringRef Suffix : CandidateBiarchLibDirs) {
2195 const std::string LibDir = Prefix + Suffix.str();
2196 if (!VFS.exists(LibDir))
2198 bool GCCDirExists = VFS.exists(LibDir +
"/gcc");
2199 bool GCCCrossDirExists = VFS.exists(LibDir +
"/gcc-cross");
2200 for (StringRef Candidate : CandidateBiarchTripleAliases)
2201 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
true,
2202 GCCDirExists, GCCCrossDirExists);
2206 if (Version > VersionZero)
2212 for (
const auto &InstallPath : CandidateGCCInstallPaths)
2213 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
2215 if (!GCCInstallPath.empty())
2216 OS <<
"Selected GCC installation: " << GCCInstallPath <<
"\n";
2218 for (
const auto &
Multilib : Multilibs)
2219 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
2221 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
2222 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
2226 if (BiarchSibling) {
2233void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
2235 StringRef SysRoot) {
2237 if (TargetTriple.isOSHaiku()) {
2238 Prefixes.push_back(concat(SysRoot,
"/boot/system/develop/tools"));
2242 if (TargetTriple.isOSSolaris()) {
2250 std::string PrefixDir = concat(SysRoot,
"/usr/gcc");
2252 for (llvm::vfs::directory_iterator LI = D.
getVFS().dir_begin(PrefixDir, EC),
2254 !EC && LI != LE; LI = LI.increment(EC)) {
2255 StringRef VersionText = llvm::sys::path::filename(LI->path());
2256 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2259 if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
2262 std::string CandidatePrefix = PrefixDir +
"/" + VersionText.str();
2263 std::string CandidateLibPath = CandidatePrefix +
"/lib/gcc";
2264 if (!D.
getVFS().exists(CandidateLibPath))
2267 SolarisPrefixes.emplace_back(
2268 std::make_pair(CandidateVersion, CandidatePrefix));
2271 std::sort(SolarisPrefixes.rbegin(), SolarisPrefixes.rend());
2272 for (
auto p : SolarisPrefixes)
2273 Prefixes.emplace_back(p.second);
2279 if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux &&
2280 D.
getVFS().exists(
"/opt/rh")) {
2283 Prefixes.push_back(
"/opt/rh/gcc-toolset-12/root/usr");
2284 Prefixes.push_back(
"/opt/rh/gcc-toolset-11/root/usr");
2285 Prefixes.push_back(
"/opt/rh/gcc-toolset-10/root/usr");
2286 Prefixes.push_back(
"/opt/rh/devtoolset-12/root/usr");
2287 Prefixes.push_back(
"/opt/rh/devtoolset-11/root/usr");
2288 Prefixes.push_back(
"/opt/rh/devtoolset-10/root/usr");
2289 Prefixes.push_back(
"/opt/rh/devtoolset-9/root/usr");
2290 Prefixes.push_back(
"/opt/rh/devtoolset-8/root/usr");
2291 Prefixes.push_back(
"/opt/rh/devtoolset-7/root/usr");
2292 Prefixes.push_back(
"/opt/rh/devtoolset-6/root/usr");
2293 Prefixes.push_back(
"/opt/rh/devtoolset-4/root/usr");
2294 Prefixes.push_back(
"/opt/rh/devtoolset-3/root/usr");
2295 Prefixes.push_back(
"/opt/rh/devtoolset-2/root/usr");
2299 Prefixes.push_back(concat(SysRoot,
"/usr"));
2302 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
2303 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
2317 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
2318 static const char *
const AArch64Triples[] = {
2319 "aarch64-none-linux-gnu",
"aarch64-linux-gnu",
"aarch64-redhat-linux",
2320 "aarch64-suse-linux"};
2321 static const char *
const AArch64beLibDirs[] = {
"/lib"};
2322 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu",
2323 "aarch64_be-linux-gnu"};
2325 static const char *
const ARMLibDirs[] = {
"/lib"};
2326 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi"};
2327 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
2328 "armv7hl-redhat-linux-gnueabi",
2329 "armv6hl-suse-linux-gnueabi",
2330 "armv7hl-suse-linux-gnueabi"};
2331 static const char *
const ARMebLibDirs[] = {
"/lib"};
2332 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi"};
2333 static const char *
const ARMebHFTriples[] = {
2334 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
2336 static const char *
const AVRLibDirs[] = {
"/lib"};
2337 static const char *
const AVRTriples[] = {
"avr"};
2339 static const char *
const CSKYLibDirs[] = {
"/lib"};
2340 static const char *
const CSKYTriples[] = {
2341 "csky-linux-gnuabiv2",
"csky-linux-uclibcabiv2",
"csky-elf-noneabiv2"};
2343 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
2344 static const char *
const X86_64Triples[] = {
2345 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
2346 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
2347 "x86_64-redhat-linux",
"x86_64-suse-linux",
2348 "x86_64-manbo-linux-gnu",
"x86_64-linux-gnu",
2349 "x86_64-slackware-linux",
"x86_64-unknown-linux",
2350 "x86_64-amazon-linux"};
2351 static const char *
const X32Triples[] = {
"x86_64-linux-gnux32",
2352 "x86_64-pc-linux-gnux32"};
2353 static const char *
const X32LibDirs[] = {
"/libx32",
"/lib"};
2354 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
2355 static const char *
const X86Triples[] = {
2356 "i586-linux-gnu",
"i686-linux-gnu",
"i686-pc-linux-gnu",
2357 "i386-redhat-linux6E",
"i686-redhat-linux",
"i386-redhat-linux",
2358 "i586-suse-linux",
"i686-montavista-linux",
"i686-gnu",
2361 static const char *
const LoongArch64LibDirs[] = {
"/lib64",
"/lib"};
2362 static const char *
const LoongArch64Triples[] = {
2363 "loongarch64-linux-gnu",
"loongarch64-unknown-linux-gnu"};
2365 static const char *
const M68kLibDirs[] = {
"/lib"};
2366 static const char *
const M68kTriples[] = {
2367 "m68k-linux-gnu",
"m68k-unknown-linux-gnu",
"m68k-suse-linux"};
2369 static const char *
const MIPSLibDirs[] = {
"/libo32",
"/lib"};
2370 static const char *
const MIPSTriples[] = {
2371 "mips-linux-gnu",
"mips-mti-linux",
"mips-mti-linux-gnu",
2372 "mips-img-linux-gnu",
"mipsisa32r6-linux-gnu"};
2373 static const char *
const MIPSELLibDirs[] = {
"/libo32",
"/lib"};
2374 static const char *
const MIPSELTriples[] = {
2375 "mipsel-linux-gnu",
"mips-img-linux-gnu",
"mipsisa32r6el-linux-gnu"};
2377 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
2378 static const char *
const MIPS64Triples[] = {
2379 "mips64-linux-gnu",
"mips-mti-linux-gnu",
2380 "mips-img-linux-gnu",
"mips64-linux-gnuabi64",
2381 "mipsisa64r6-linux-gnu",
"mipsisa64r6-linux-gnuabi64"};
2382 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
2383 static const char *
const MIPS64ELTriples[] = {
2384 "mips64el-linux-gnu",
"mips-mti-linux-gnu",
2385 "mips-img-linux-gnu",
"mips64el-linux-gnuabi64",
2386 "mipsisa64r6el-linux-gnu",
"mipsisa64r6el-linux-gnuabi64"};
2388 static const char *
const MIPSN32LibDirs[] = {
"/lib32"};
2389 static const char *
const MIPSN32Triples[] = {
"mips64-linux-gnuabin32",
2390 "mipsisa64r6-linux-gnuabin32"};
2391 static const char *
const MIPSN32ELLibDirs[] = {
"/lib32"};
2392 static const char *
const MIPSN32ELTriples[] = {
2393 "mips64el-linux-gnuabin32",
"mipsisa64r6el-linux-gnuabin32"};
2395 static const char *
const MSP430LibDirs[] = {
"/lib"};
2396 static const char *
const MSP430Triples[] = {
"msp430-elf"};
2398 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
2399 static const char *
const PPCTriples[] = {
2400 "powerpc-linux-gnu",
"powerpc-unknown-linux-gnu",
"powerpc-linux-gnuspe",
2403 "powerpc64-suse-linux",
"powerpc-montavista-linuxspe"};
2404 static const char *
const PPCLELibDirs[] = {
"/lib32",
"/lib"};
2405 static const char *
const PPCLETriples[] = {
"powerpcle-linux-gnu",
2406 "powerpcle-unknown-linux-gnu",
2407 "powerpcle-linux-musl"};
2409 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
2410 static const char *
const PPC64Triples[] = {
2411 "powerpc64-linux-gnu",
"powerpc64-unknown-linux-gnu",
2412 "powerpc64-suse-linux",
"ppc64-redhat-linux"};
2413 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
2414 static const char *
const PPC64LETriples[] = {
2415 "powerpc64le-linux-gnu",
"powerpc64le-unknown-linux-gnu",
2416 "powerpc64le-none-linux-gnu",
"powerpc64le-suse-linux",
2417 "ppc64le-redhat-linux"};
2419 static const char *
const RISCV32LibDirs[] = {
"/lib32",
"/lib"};
2420 static const char *
const RISCV32Triples[] = {
"riscv32-unknown-linux-gnu",
2421 "riscv32-linux-gnu",
2422 "riscv32-unknown-elf"};
2423 static const char *
const RISCV64LibDirs[] = {
"/lib64",
"/lib"};
2424 static const char *
const RISCV64Triples[] = {
"riscv64-unknown-linux-gnu",
2425 "riscv64-linux-gnu",
2426 "riscv64-unknown-elf"};
2428 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
2429 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
2430 "sparcv8-linux-gnu"};
2431 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
2432 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
2433 "sparcv9-linux-gnu"};
2435 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
2436 static const char *
const SystemZTriples[] = {
2437 "s390x-linux-gnu",
"s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
2438 "s390x-suse-linux",
"s390x-redhat-linux"};
2444 if (TargetTriple.isOSSolaris()) {
2445 static const char *
const SolarisLibDirs[] = {
"/lib"};
2446 static const char *
const SolarisSparcV8Triples[] = {
2447 "sparc-sun-solaris2.11"};
2448 static const char *
const SolarisSparcV9Triples[] = {
2449 "sparcv9-sun-solaris2.11"};
2450 static const char *
const SolarisX86Triples[] = {
"i386-pc-solaris2.11"};
2451 static const char *
const SolarisX86_64Triples[] = {
"x86_64-pc-solaris2.11"};
2452 LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2453 BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2454 switch (TargetTriple.getArch()) {
2455 case llvm::Triple::x86:
2456 TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
2457 BiarchTripleAliases.append(begin(SolarisX86_64Triples),
2458 end(SolarisX86_64Triples));
2460 case llvm::Triple::x86_64:
2461 TripleAliases.append(begin(SolarisX86_64Triples),
2462 end(SolarisX86_64Triples));
2463 BiarchTripleAliases.append(begin(SolarisX86Triples),
2464 end(SolarisX86Triples));
2466 case llvm::Triple::sparc:
2467 TripleAliases.append(begin(SolarisSparcV8Triples),
2468 end(SolarisSparcV8Triples));
2469 BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2470 end(SolarisSparcV9Triples));
2472 case llvm::Triple::sparcv9:
2473 TripleAliases.append(begin(SolarisSparcV9Triples),
2474 end(SolarisSparcV9Triples));
2475 BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2476 end(SolarisSparcV8Triples));
2485 if (TargetTriple.isAndroid()) {
2486 static const char *
const AArch64AndroidTriples[] = {
2487 "aarch64-linux-android"};
2488 static const char *
const ARMAndroidTriples[] = {
"arm-linux-androideabi"};
2489 static const char *
const X86AndroidTriples[] = {
"i686-linux-android"};
2490 static const char *
const X86_64AndroidTriples[] = {
"x86_64-linux-android"};
2492 switch (TargetTriple.getArch()) {
2493 case llvm::Triple::aarch64:
2494 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2495 TripleAliases.append(begin(AArch64AndroidTriples),
2496 end(AArch64AndroidTriples));
2498 case llvm::Triple::arm:
2499 case llvm::Triple::thumb:
2500 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2501 TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2503 case llvm::Triple::x86_64:
2504 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2505 TripleAliases.append(begin(X86_64AndroidTriples),
2506 end(X86_64AndroidTriples));
2507 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2508 BiarchTripleAliases.append(begin(X86AndroidTriples),
2509 end(X86AndroidTriples));
2511 case llvm::Triple::x86:
2512 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2513 TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
2514 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2515 BiarchTripleAliases.append(begin(X86_64AndroidTriples),
2516 end(X86_64AndroidTriples));
2525 switch (TargetTriple.getArch()) {
2526 case llvm::Triple::aarch64:
2527 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2528 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2529 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2530 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2532 case llvm::Triple::aarch64_be:
2533 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2534 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2535 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2536 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2538 case llvm::Triple::arm:
2539 case llvm::Triple::thumb:
2540 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2541 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2542 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2544 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2547 case llvm::Triple::armeb:
2548 case llvm::Triple::thumbeb:
2549 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2550 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2551 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2553 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2556 case llvm::Triple::avr:
2557 LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs));
2558 TripleAliases.append(begin(AVRTriples), end(AVRTriples));
2560 case llvm::Triple::csky:
2561 LibDirs.append(begin(CSKYLibDirs), end(CSKYLibDirs));
2562 TripleAliases.append(begin(CSKYTriples), end(CSKYTriples));
2564 case llvm::Triple::x86_64:
2565 if (TargetTriple.isX32()) {
2566 LibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2567 TripleAliases.append(begin(X32Triples), end(X32Triples));
2568 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2569 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2571 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2572 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2573 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2574 BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
2576 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2577 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2579 case llvm::Triple::x86:
2580 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2583 if (!TargetTriple.isOSIAMCU()) {
2584 TripleAliases.append(begin(X86Triples), end(X86Triples));
2585 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2586 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2587 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2588 BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
2592 case llvm::Triple::loongarch64:
2593 LibDirs.append(begin(LoongArch64LibDirs), end(LoongArch64LibDirs));
2594 TripleAliases.append(begin(LoongArch64Triples), end(LoongArch64Triples));
2596 case llvm::Triple::m68k:
2597 LibDirs.append(begin(M68kLibDirs), end(M68kLibDirs));
2598 TripleAliases.append(begin(M68kTriples), end(M68kTriples));
2600 case llvm::Triple::mips:
2601 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2602 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2603 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2604 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2605 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2606 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2608 case llvm::Triple::mipsel:
2609 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2610 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2611 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2612 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2613 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2614 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2615 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2617 case llvm::Triple::mips64:
2618 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2619 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2620 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2621 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2622 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2623 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2625 case llvm::Triple::mips64el:
2626 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2627 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2628 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2629 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2630 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2631 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2632 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2634 case llvm::Triple::msp430:
2635 LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2636 TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2638 case llvm::Triple::ppc:
2639 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2640 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2641 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2642 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2644 case llvm::Triple::ppcle:
2645 LibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs));
2646 TripleAliases.append(begin(PPCLETriples), end(PPCLETriples));
2647 BiarchLibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2648 BiarchTripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2650 case llvm::Triple::ppc64:
2651 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2652 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2653 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2654 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2656 case llvm::Triple::ppc64le:
2657 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2658 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2659 BiarchLibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs));
2660 BiarchTripleAliases.append(begin(PPCLETriples), end(PPCLETriples));
2662 case llvm::Triple::riscv32:
2663 LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2664 TripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2665 BiarchLibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2666 BiarchTripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2668 case llvm::Triple::riscv64:
2669 LibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2670 TripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2671 BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2672 BiarchTripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2674 case llvm::Triple::sparc:
2675 case llvm::Triple::sparcel:
2676 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2677 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2678 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2679 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2681 case llvm::Triple::sparcv9:
2682 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2683 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2684 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2685 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2687 case llvm::Triple::systemz:
2688 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2689 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2698 if (TargetTriple.str() != BiarchTriple.str())
2699 BiarchTripleAliases.push_back(BiarchTriple.str());
2702bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2703 const llvm::Triple &TargetTriple,
const ArgList &Args,
2704 StringRef Path,
bool NeedsBiarchSuffix) {
2705 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2714 }
else if (TargetTriple.isCSKY()) {
2716 }
else if (TargetTriple.isMIPS()) {
2719 }
else if (TargetTriple.isRISCV()) {
2723 }
else if (TargetArch == llvm::Triple::avr) {
2726 NeedsBiarchSuffix, Detected)) {
2733 : Detected.SelectedMultilibs.back();
2739void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2740 const llvm::Triple &TargetTriple,
const ArgList &Args,
2741 const std::string &LibDir, StringRef CandidateTriple,
2742 bool NeedsBiarchSuffix,
bool GCCDirExists,
bool GCCCrossDirExists) {
2745 struct GCCLibSuffix {
2747 std::string LibSuffix;
2750 StringRef ReversePath;
2755 {
"gcc/" + CandidateTriple.str(),
"../..", GCCDirExists},
2758 {
"gcc-cross/" + CandidateTriple.str(),
"../..", GCCCrossDirExists},
2764 {CandidateTriple.str(),
"..",
2765 TargetTriple.getVendor() == llvm::Triple::Freescale ||
2766 TargetTriple.getVendor() == llvm::Triple::OpenEmbedded}};
2772 StringRef LibSuffix = Suffix.LibSuffix;
2774 for (llvm::vfs::directory_iterator
2775 LI = D.
getVFS().dir_begin(LibDir +
"/" + LibSuffix, EC),
2777 !EC && LI != LE; LI = LI.increment(EC)) {
2778 StringRef VersionText = llvm::sys::path::filename(LI->path());
2779 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2780 if (CandidateVersion.Major != -1)
2781 if (!CandidateGCCInstallPaths.insert(std::string(LI->path())).second)
2783 if (CandidateVersion.isOlderThan(4, 1, 1))
2785 if (CandidateVersion <= Version)
2788 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
2792 Version = CandidateVersion;
2793 GCCTriple.setTriple(CandidateTriple);
2797 GCCInstallPath = (LibDir +
"/" + LibSuffix +
"/" + VersionText).str();
2798 GCCParentLibPath = (GCCInstallPath +
"/../" + Suffix.ReversePath).str();
2804bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
2805 const llvm::Triple &TargetTriple,
const ArgList &Args,
2811 for (StringRef CandidateTriple : CandidateTriples) {
2812 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
2816 for (StringRef CandidateTriple : CandidateBiarchTriples) {
2817 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple,
true))
2823bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2824 const llvm::Triple &TargetTriple,
const ArgList &Args,
2825 StringRef CandidateTriple,
bool NeedsBiarchSuffix) {
2826 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
File =
2827 D.
getVFS().getBufferForFile(concat(D.
SysRoot, GentooConfigDir,
2828 "/config-" + CandidateTriple.str()));
2831 File.get()->getBuffer().split(Lines,
"\n");
2832 for (StringRef
Line : Lines) {
2835 if (!
Line.consume_front(
"CURRENT="))
2838 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
2839 D.
getVFS().getBufferForFile(
2841 std::pair<StringRef, StringRef> ActiveVersion =
Line.rsplit(
'-');
2854 ConfigFile.get()->getBuffer().split(ConfigLines,
"\n");
2855 for (StringRef ConfLine : ConfigLines) {
2856 ConfLine = ConfLine.trim();
2857 if (ConfLine.consume_front(
"LDPATH=")) {
2859 ConfLine.consume_back(
"\"");
2860 ConfLine.consume_front(
"\"");
2862 ConfLine.split(GentooScanPaths,
':', -1,
false);
2867 std::string basePath =
"/usr/lib/gcc/" + ActiveVersion.first.str() +
"/"
2868 + ActiveVersion.second.str();
2869 GentooScanPaths.push_back(StringRef(basePath));
2872 for (
const auto &GentooScanPath : GentooScanPaths) {
2873 std::string GentooPath = concat(D.
SysRoot, GentooScanPath);
2874 if (D.
getVFS().exists(GentooPath +
"/crtbegin.o")) {
2875 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2879 Version = GCCVersion::Parse(ActiveVersion.second);
2880 GCCInstallPath = GentooPath;
2881 GCCParentLibPath = GentooPath + std::string(
"/../../..");
2882 GCCTriple.setTriple(ActiveVersion.first);
2894 const ArgList &Args)
2895 :
ToolChain(D, Triple, Args), GCCInstallation(D),
2896 CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {
2909 return Preprocess.get();
2913 return Compile.get();
2935 case llvm::Triple::aarch64:
2936 case llvm::Triple::aarch64_be:
2937 case llvm::Triple::ppc:
2938 case llvm::Triple::ppcle:
2939 case llvm::Triple::ppc64:
2940 case llvm::Triple::ppc64le:
2941 case llvm::Triple::riscv32:
2942 case llvm::Triple::riscv64:
2943 case llvm::Triple::x86:
2944 case llvm::Triple::x86_64:
2953 case llvm::Triple::x86_64:
2955 case llvm::Triple::mips64:
2956 case llvm::Triple::mips64el:
2973 case llvm::Triple::nvptx:
2974 case llvm::Triple::nvptx64:
2975 case llvm::Triple::xcore:
2998 const std::string &SysRoot,
2999 const std::string &OSLibDir,
3000 const std::string &MultiarchTriple,
3006 const std::string &LibPath =
3045 LibPath +
"/../" + GCCTriple.str() +
"/lib/../" + OSLibDir +
3058 if (StringRef(LibPath).startswith(SysRoot))
3059 addPathIfExists(D, LibPath +
"/../" + OSLibDir, Paths);
3064 const std::string &SysRoot,
3065 const std::string &OSLibDir,
3068 const std::string &LibPath =
3079 ArgStringList &CC1Args)
const {
3087 Twine(LibPath) +
"/../" + GCCTriple.str() +
"/include");
3098 ArgStringList &CC1Args)
const {
3099 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdincxx,
3100 options::OPT_nostdlibinc))
3116 llvm::opt::ArgStringList &CC1Args)
const {
3119 if (SysRoot.empty())
3120 SysRoot = llvm::sys::path::get_separator();
3122 auto AddIncludePath = [&](StringRef Path,
bool TargetDirRequired =
false) {
3124 if (Version.empty())
3128 bool TargetDirExists =
false;
3130 if (TargetIncludeDir) {
3132 llvm::sys::path::append(TargetDir,
"c++", Version);
3133 if (D.
getVFS().exists(TargetDir)) {
3135 TargetDirExists =
true;
3138 if (TargetDirRequired && !TargetDirExists)
3143 llvm::sys::path::append(GenericDir,
"c++", Version);
3152 llvm::sys::path::append(DriverIncludeDir,
"..",
"include");
3153 if (AddIncludePath(DriverIncludeDir,
3160 llvm::sys::path::append(UsrLocalIncludeDir,
"usr",
"local",
"include");
3161 if (AddIncludePath(UsrLocalIncludeDir))
3164 llvm::sys::path::append(UsrIncludeDir,
"usr",
"include");
3165 if (AddIncludePath(UsrIncludeDir))
3170 Twine IncludeSuffix,
3171 const llvm::opt::ArgList &DriverArgs,
3172 llvm::opt::ArgStringList &CC1Args,
3173 bool DetectDebian)
const {
3174 if (!
getVFS().exists(IncludeDir))
3180 std::string Dir = IncludeDir.str();
3182 llvm::sys::path::parent_path(llvm::sys::path::parent_path(Dir));
3184 (Include +
"/" + Triple + Dir.substr(Include.size()) + IncludeSuffix)
3186 if (DetectDebian && !
getVFS().exists(Path))
3195 else if (!Triple.empty())
3197 IncludeDir +
"/" + Triple + IncludeSuffix);
3204 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
3205 StringRef DebianMultiarch)
const {
3219 LibDir.str() +
"/../" + TripleStr +
"/include/c++/" + Version.
Text,
3227 Version.
Text +
"/include/c++/",
3235 DriverArgs, CC1Args,
true))
3246 const std::string LibStdCXXIncludePathCandidates[] = {
3249 InstallDir.str() +
"/include/g++-v" + Version.
Text,
3250 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr +
"." +
3252 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr,
3255 for (
const auto &IncludePath : LibStdCXXIncludePathCandidates) {
3265 llvm::opt::ArgStringList &CC1Args)
const {
3272llvm::opt::DerivedArgList *
3281 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
3286 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_shared));
3287 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_fPIC));
3291 for (
auto *A : Args) {
3296 case options::OPT_shared:
3297 case options::OPT_dynamic:
3298 case options::OPT_static:
3299 case options::OPT_fPIC:
3300 case options::OPT_fno_PIC:
3301 case options::OPT_fpic:
3302 case options::OPT_fno_pic:
3303 case options::OPT_fPIE:
3304 case options::OPT_fno_PIE:
3305 case options::OPT_fpie:
3306 case options::OPT_fno_pie:
3315void Generic_ELF::anchor() {}
3318 ArgStringList &CC1Args,
3320 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
3321 options::OPT_fno_use_init_array,
true))
3322 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 isArmOrThumbArch(llvm::Triple::ArchType Arch)
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 findMipsCsMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static bool isMipsEL(llvm::Triple::ArchType Arch)
static const char * getLDMOption(const llvm::Triple &T, const ArgList &Args)
static bool findMipsMuslMultilibs(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 findMipsAndroidMultilibs(llvm::vfs::FileSystem &VFS, StringRef Path, const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static bool isMSP430(llvm::Triple::ArchType Arch)
static bool isSoftFloatABI(const ArgList &Args)
static bool findMipsImgMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static bool getStaticPIE(const ArgList &Args, const ToolChain &TC)
static bool forwardToGCC(const Option &O)
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...
std::string SysRoot
sysroot, if present
std::string DyldPrefix
Dynamic loader prefix, if present.
DiagnosticBuilder Diag(unsigned DiagID) const
const llvm::opt::OptTable & getOpts() const
LTOKind getLTOMode(bool IsOffload=false) const
Get the specific kind of LTO being performed.
std::string InstalledDir
The path to the installed clang directory, if any.
llvm::vfs::FileSystem & getVFS() const
bool isUsingLTO(bool IsOffload=false) const
Returns true if we are performing any kind of LTO.
bool IsFlangMode() const
Whether the driver should invoke flang for fortran inputs.
const std::string & getCCCGenericGCCName() const
Name to use when invoking gcc/g++.
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
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 Multilib::flags_list &Flags, llvm::SmallVector< Multilib > &) 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)
@ 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()