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");
121 CmdArgs.push_back(
"-o");
124 assert(Output.
isNothing() &&
"Unexpected output");
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 {
228 const ArgList &Args) {
229 bool IsBigEndian =
false;
230 switch (Triple.getArch()) {
231 case llvm::Triple::armeb:
232 case llvm::Triple::thumbeb:
235 case llvm::Triple::arm:
236 case llvm::Triple::thumb:
237 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
238 options::OPT_mbig_endian))
239 IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
247static const char *
getLDMOption(
const llvm::Triple &T,
const ArgList &Args) {
248 switch (T.getArch()) {
249 case llvm::Triple::x86:
253 case llvm::Triple::aarch64:
254 return "aarch64linux";
255 case llvm::Triple::aarch64_be:
256 return "aarch64linuxb";
257 case llvm::Triple::arm:
258 case llvm::Triple::thumb:
259 case llvm::Triple::armeb:
260 case llvm::Triple::thumbeb:
261 return isArmBigEndian(T, Args) ?
"armelfb_linux_eabi" :
"armelf_linux_eabi";
262 case llvm::Triple::m68k:
264 case llvm::Triple::ppc:
266 return "elf32ppclinux";
268 case llvm::Triple::ppcle:
270 return "elf32lppclinux";
272 case llvm::Triple::ppc64:
274 case llvm::Triple::ppc64le:
276 case llvm::Triple::riscv32:
277 return "elf32lriscv";
278 case llvm::Triple::riscv64:
279 return "elf64lriscv";
280 case llvm::Triple::sparc:
281 case llvm::Triple::sparcel:
282 return "elf32_sparc";
283 case llvm::Triple::sparcv9:
284 return "elf64_sparc";
285 case llvm::Triple::loongarch32:
286 return "elf32loongarch";
287 case llvm::Triple::loongarch64:
288 return "elf64loongarch";
289 case llvm::Triple::mips:
290 return "elf32btsmip";
291 case llvm::Triple::mipsel:
292 return "elf32ltsmip";
293 case llvm::Triple::mips64:
295 T.getEnvironment() == llvm::Triple::GNUABIN32)
296 return "elf32btsmipn32";
297 return "elf64btsmip";
298 case llvm::Triple::mips64el:
300 T.getEnvironment() == llvm::Triple::GNUABIN32)
301 return "elf32ltsmipn32";
302 return "elf64ltsmip";
303 case llvm::Triple::systemz:
305 case llvm::Triple::x86_64:
307 return "elf32_x86_64";
309 case llvm::Triple::ve:
311 case llvm::Triple::csky:
312 return "cskyelf_linux";
319 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) ||
320 Args.hasArg(options::OPT_r) || Args.hasArg(options::OPT_static_pie))
323 Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
327 return A->getOption().matches(options::OPT_pie);
331 bool HasStaticPIE = Args.hasArg(options::OPT_static_pie);
334 if (HasStaticPIE && Args.hasArg(options::OPT_nopie)) {
336 const llvm::opt::OptTable &Opts = D.
getOpts();
337 StringRef StaticPIEName = Opts.getOptionName(options::OPT_static_pie);
338 StringRef NoPIEName = Opts.getOptionName(options::OPT_nopie);
339 D.
Diag(diag::err_drv_cannot_mix_options) << StaticPIEName << NoPIEName;
345 return Args.hasArg(options::OPT_static) &&
346 !Args.hasArg(options::OPT_static_pie);
352 const char *LinkingOutput)
const {
353 const Driver &D = getToolChain().getDriver();
356 Args.ClaimAllArgs(options::OPT_g_Group);
358 Args.ClaimAllArgs(options::OPT_emit_llvm);
361 Args.ClaimAllArgs(options::OPT_w);
363 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
366 ArgStringList CmdArgs;
368 CmdArgs.push_back(
"rcsD");
371 for (
const auto &II : Inputs) {
372 if (II.isFilename()) {
373 CmdArgs.push_back(II.getFilename());
380 if (Output.
isFilename() && llvm::sys::fs::exists(OutputFileName)) {
381 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
382 D.
Diag(diag::err_drv_unable_to_remove_file) << EC.message();
387 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
388 C.addCommand(std::make_unique<Command>(JA, *
this,
390 Exec, CmdArgs, Inputs, Output));
397 const char *LinkingOutput)
const {
406 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
416 const bool HasCRTBeginEndFiles =
420 ArgStringList CmdArgs;
423 Args.ClaimAllArgs(options::OPT_g_Group);
425 Args.ClaimAllArgs(options::OPT_emit_llvm);
428 Args.ClaimAllArgs(options::OPT_w);
431 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
434 CmdArgs.push_back(
"-pie");
437 CmdArgs.push_back(
"-static");
438 CmdArgs.push_back(
"-pie");
439 CmdArgs.push_back(
"--no-dynamic-linker");
440 CmdArgs.push_back(
"-z");
441 CmdArgs.push_back(
"text");
444 if (Args.hasArg(options::OPT_rdynamic))
445 CmdArgs.push_back(
"-export-dynamic");
447 if (Args.hasArg(options::OPT_s))
448 CmdArgs.push_back(
"-s");
450 if (Triple.isARM() || Triple.isThumb() || Triple.isAArch64()) {
454 IsBigEndian = IsBigEndian || Arch == llvm::Triple::aarch64_be;
455 CmdArgs.push_back(IsBigEndian ?
"-EB" :
"-EL");
460 if (Arch == llvm::Triple::aarch64 && (isAndroid || isOHOSFamily)) {
461 std::string CPU =
getCPUName(D, Args, Triple);
462 if (CPU.empty() || CPU ==
"generic" || CPU ==
"cortex-a53")
463 CmdArgs.push_back(
"--fix-cortex-a53-843419");
468 CmdArgs.push_back(
"--eh-frame-hdr");
471 CmdArgs.push_back(
"-m");
472 CmdArgs.push_back(LDMOption);
474 D.
Diag(diag::err_target_unknown_triple) << Triple.str();
477 if (Triple.isRISCV())
478 CmdArgs.push_back(
"-X");
480 if (Args.hasArg(options::OPT_shared))
481 CmdArgs.push_back(
"-shared");
484 CmdArgs.push_back(
"-static");
486 if (Args.hasArg(options::OPT_rdynamic))
487 CmdArgs.push_back(
"-export-dynamic");
489 if (!Args.hasArg(options::OPT_shared) && !IsStaticPIE &&
490 !Args.hasArg(options::OPT_r)) {
491 CmdArgs.push_back(
"-dynamic-linker");
492 CmdArgs.push_back(Args.MakeArgString(Twine(D.
DyldPrefix) +
497 CmdArgs.push_back(
"-o");
500 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles,
502 if (!isAndroid && !IsIAMCU) {
503 const char *crt1 =
nullptr;
504 if (!Args.hasArg(options::OPT_shared)) {
505 if (Args.hasArg(options::OPT_pg))
509 else if (IsStaticPIE)
521 CmdArgs.push_back(
"-z");
522 CmdArgs.push_back(
"max-page-size=0x4000000");
527 else if (HasCRTBeginEndFiles) {
537 const char *crtbegin;
538 if (Args.hasArg(options::OPT_shared))
539 crtbegin = isAndroid ?
"crtbegin_so.o" :
"crtbeginS.o";
541 crtbegin = isAndroid ?
"crtbegin_static.o" :
"crtbeginT.o";
542 else if (IsPIE || IsStaticPIE)
543 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbeginS.o";
545 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbegin.o";
548 CmdArgs.push_back(Args.MakeArgString(
P));
555 Args.AddAllArgs(CmdArgs, options::OPT_L);
556 Args.AddAllArgs(CmdArgs, options::OPT_u);
561 assert(!Inputs.empty() &&
"Must have at least one input.");
566 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
567 CmdArgs.push_back(
"--no-demangle");
577 getToolChain().addProfileRTLibs(Args, CmdArgs);
580 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
583 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
584 !Args.hasArg(options::OPT_static);
585 if (OnlyLibstdcxxStatic)
586 CmdArgs.push_back(
"-Bstatic");
588 if (OnlyLibstdcxxStatic)
589 CmdArgs.push_back(
"-Bdynamic");
591 CmdArgs.push_back(
"-lm");
595 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
604 CmdArgs.push_back(
"-lm");
607 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_r)) {
608 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
610 CmdArgs.push_back(
"--start-group");
612 if (NeedsSanitizerDeps)
618 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
619 Args.hasArg(options::OPT_pthreads);
622 bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&
623 !Args.hasArg(options::OPT_static);
639 if (getToolChain().getTriple().getArch() == llvm::Triple::sparc) {
640 CmdArgs.push_back(
"--push-state");
641 CmdArgs.push_back(
"--as-needed");
642 CmdArgs.push_back(
"-latomic");
643 CmdArgs.push_back(
"--pop-state");
648 if (WantPthread && !isAndroid && !isOHOSFamily)
649 CmdArgs.push_back(
"-lpthread");
651 if (Args.hasArg(options::OPT_fsplit_stack))
652 CmdArgs.push_back(
"--wrap=pthread_create");
654 if (!Args.hasArg(options::OPT_nolibc))
655 CmdArgs.push_back(
"-lc");
659 CmdArgs.push_back(
"-lgloss");
662 CmdArgs.push_back(
"--end-group");
668 CmdArgs.push_back(
"--as-needed");
669 CmdArgs.push_back(
"-lsoftfp");
670 CmdArgs.push_back(
"--no-as-needed");
674 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
675 if (HasCRTBeginEndFiles) {
686 if (Args.hasArg(options::OPT_shared))
687 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
688 else if (IsPIE || IsStaticPIE)
689 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
691 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
694 CmdArgs.push_back(Args.MakeArgString(
P));
701 Args.AddAllArgs(CmdArgs, options::OPT_T);
704 C.addCommand(std::make_unique<Command>(JA, *
this,
706 Exec, CmdArgs, Inputs, Output));
714 const char *LinkingOutput)
const {
715 const auto &D = getToolChain().getDriver();
719 ArgStringList CmdArgs;
721 llvm::Reloc::Model RelocationModel;
724 const char *DefaultAssembler =
"as";
725 std::tie(RelocationModel, PICLevel, IsPIE) =
728 if (
const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
729 if (A->getOption().getID() == options::OPT_gz) {
730 CmdArgs.push_back(
"--compress-debug-sections");
732 StringRef
Value = A->getValue();
735 Args.MakeArgString(
"--compress-debug-sections=" + Twine(
Value)));
737 D.Diag(diag::err_drv_unsupported_option_argument)
738 << A->getSpelling() <<
Value;
743 switch (getToolChain().getArch()) {
748 case llvm::Triple::x86:
749 CmdArgs.push_back(
"--32");
751 case llvm::Triple::x86_64:
752 if (getToolChain().getTriple().isX32())
753 CmdArgs.push_back(
"--x32");
755 CmdArgs.push_back(
"--64");
757 case llvm::Triple::ppc: {
758 CmdArgs.push_back(
"-a32");
759 CmdArgs.push_back(
"-mppc");
760 CmdArgs.push_back(
"-mbig-endian");
762 getCPUName(D, Args, getToolChain().getTriple())));
765 case llvm::Triple::ppcle: {
766 CmdArgs.push_back(
"-a32");
767 CmdArgs.push_back(
"-mppc");
768 CmdArgs.push_back(
"-mlittle-endian");
770 getCPUName(D, Args, getToolChain().getTriple())));
773 case llvm::Triple::ppc64: {
774 CmdArgs.push_back(
"-a64");
775 CmdArgs.push_back(
"-mppc64");
776 CmdArgs.push_back(
"-mbig-endian");
778 getCPUName(D, Args, getToolChain().getTriple())));
781 case llvm::Triple::ppc64le: {
782 CmdArgs.push_back(
"-a64");
783 CmdArgs.push_back(
"-mppc64");
784 CmdArgs.push_back(
"-mlittle-endian");
786 getCPUName(D, Args, getToolChain().getTriple())));
789 case llvm::Triple::riscv32:
790 case llvm::Triple::riscv64: {
792 CmdArgs.push_back(
"-mabi");
793 CmdArgs.push_back(ABIName.data());
795 CmdArgs.push_back(
"-march");
796 CmdArgs.push_back(MArchName.data());
797 if (!Args.hasFlag(options::OPT_mrelax, options::OPT_mno_relax,
true))
798 Args.addOptOutFlag(CmdArgs, options::OPT_mrelax, options::OPT_mno_relax);
801 case llvm::Triple::sparc:
802 case llvm::Triple::sparcel: {
803 CmdArgs.push_back(
"-32");
804 std::string CPU =
getCPUName(D, Args, getToolChain().getTriple());
810 case llvm::Triple::sparcv9: {
811 CmdArgs.push_back(
"-64");
812 std::string CPU =
getCPUName(D, Args, getToolChain().getTriple());
818 case llvm::Triple::arm:
819 case llvm::Triple::armeb:
820 case llvm::Triple::thumb:
821 case llvm::Triple::thumbeb: {
822 const llvm::Triple &Triple2 = getToolChain().getTriple();
824 switch (Triple2.getSubArch()) {
825 case llvm::Triple::ARMSubArch_v7:
826 CmdArgs.push_back(
"-mfpu=neon");
828 case llvm::Triple::ARMSubArch_v8:
829 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
838 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=soft"));
841 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=softfp"));
844 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=hard"));
848 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
851 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
854 case llvm::Triple::aarch64:
855 case llvm::Triple::aarch64_be: {
857 getToolChain().getArch() == llvm::Triple::aarch64_be ?
"-EB" :
"-EL");
858 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
864 case llvm::Triple::loongarch64: {
867 CmdArgs.push_back(Args.MakeArgString(
"-mabi=" + ABIName));
870 case llvm::Triple::mips:
871 case llvm::Triple::mipsel:
872 case llvm::Triple::mips64:
873 case llvm::Triple::mips64el: {
879 CmdArgs.push_back(
"-march");
880 CmdArgs.push_back(CPUName.data());
882 CmdArgs.push_back(
"-mabi");
883 CmdArgs.push_back(ABIName.data());
887 if (RelocationModel == llvm::Reloc::Static)
888 CmdArgs.push_back(
"-mno-shared");
892 if (ABIName !=
"64" && !Args.hasArg(options::OPT_mno_abicalls))
893 CmdArgs.push_back(
"-call_nonpic");
895 if (getToolChain().getTriple().isLittleEndian())
896 CmdArgs.push_back(
"-EL");
898 CmdArgs.push_back(
"-EB");
900 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
901 if (StringRef(A->getValue()) ==
"2008")
902 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
906 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
907 options::OPT_mfp64)) {
909 A->render(Args, CmdArgs);
911 Args, getToolChain().getTriple(), CPUName, ABIName,
913 getToolChain().getTriple())))
914 CmdArgs.push_back(
"-mfpxx");
919 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
920 if (A->getOption().matches(options::OPT_mips16)) {
922 A->render(Args, CmdArgs);
925 CmdArgs.push_back(
"-no-mips16");
929 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
930 options::OPT_mno_micromips);
931 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
932 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
934 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
937 if (A->getOption().matches(options::OPT_mmsa))
938 CmdArgs.push_back(Args.MakeArgString(
"-mmsa"));
941 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
942 options::OPT_msoft_float);
944 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
945 options::OPT_msingle_float);
947 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
948 options::OPT_mno_odd_spreg);
953 case llvm::Triple::systemz: {
957 CmdArgs.push_back(Args.MakeArgString(
"-march=" + CPUName));
960 case llvm::Triple::ve:
961 DefaultAssembler =
"nas";
964 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
965 options::OPT_fdebug_prefix_map_EQ)) {
966 StringRef Map = A->getValue();
967 if (!Map.contains(
'='))
968 D.Diag(diag::err_drv_invalid_argument_to_option)
969 << Map << A->getOption().getName();
971 CmdArgs.push_back(Args.MakeArgString(
"--debug-prefix-map"));
972 CmdArgs.push_back(Args.MakeArgString(Map));
977 Args.AddAllArgs(CmdArgs, options::OPT_I);
978 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
980 CmdArgs.push_back(
"-o");
983 for (
const auto &II : Inputs)
984 CmdArgs.push_back(II.getFilename());
986 if (Arg *A = Args.getLastArg(options::OPT_g_Flag, options::OPT_gN_Group,
987 options::OPT_gdwarf_2, options::OPT_gdwarf_3,
988 options::OPT_gdwarf_4, options::OPT_gdwarf_5,
989 options::OPT_gdwarf))
990 if (!A->getOption().matches(options::OPT_g0)) {
991 Args.AddLastArg(CmdArgs, options::OPT_g_Flag);
994 CmdArgs.push_back(Args.MakeArgString(
"-gdwarf-" + Twine(DwarfVersion)));
998 Args.MakeArgString(getToolChain().GetProgramPath(DefaultAssembler));
999 C.addCommand(std::make_unique<Command>(JA, *
this,
1001 Exec, CmdArgs, Inputs, Output));
1006 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
1007 getToolChain().getTriple().isOSLinux())
1014class FilterNonExistent {
1016 llvm::vfs::FileSystem &VFS;
1019 FilterNonExistent(StringRef
Base, StringRef
File, llvm::vfs::FileSystem &VFS)
1021 bool operator()(
const Multilib &M) {
1028 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1029 options::OPT_mfloat_abi_EQ);
1033 return A->getOption().matches(options::OPT_msoft_float) ||
1034 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
1035 A->getValue() == StringRef(
"soft"));
1039 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
1043 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1047 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
1048 return A && A->getOption().matches(options::OPT_mips16);
1052 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
1053 return A && A->getOption().matches(options::OPT_mmicromips);
1057 return Arch == llvm::Triple::msp430;
1061 FilterNonExistent &NonExistent,
1068 auto MArchMicroMips =
1089 .includeSuffix(
"/64")
1096 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
1098 .
Either(SoftFloat, Nan2008, DefaultFloat)
1101 .
Either(BigEndian, LittleEndian)
1108 std::vector<std::string> Dirs({
"/include"});
1111 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1113 Dirs.push_back(
"/../../../../mips-linux-gnu/libc/usr/include");
1126 .includeSuffix(
"/64")
1136 .
Either(M32, M64, MAbiN32)
1143 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1144 if (CSMipsMultilibs.
size() < DebianMipsMultilibs.
size())
1145 std::iter_swap(Candidates, Candidates + 1);
1147 if (Candidate->select(Flags,
Result.SelectedMultilib)) {
1148 if (Candidate == &DebianMipsMultilibs)
1150 Result.Multilibs = *Candidate;
1159 FilterNonExistent &NonExistent,
1173 .flag(
"+march=mips32r2"),
1175 .flag(
"+march=mips32r6"))
1183 .flag(
"+march=mips32"),
1185 .flag(
"+march=mips32r2"),
1187 .flag(
"+march=mips32r6"))
1192 if (VFS.exists(Path +
"/mips-r6"))
1193 MS = &AndroidMipselMultilibs;
1194 else if (VFS.exists(Path +
"/32"))
1195 MS = &AndroidMips64elMultilibs;
1204 FilterNonExistent &NonExistent,
1213 .flag(
"+march=mips32r2");
1218 .
flag(
"+march=mips32r2");
1221 .
Either(MArchMipsR2, MArchMipselR2)
1226 return std::vector<std::string>(
1227 {
"/../sysroot" + M.
osSuffix() +
"/usr/include"});
1230 if (MuslMipsMultilibs.
select(Flags,
Result.SelectedMultilib)) {
1231 Result.Multilibs = MuslMipsMultilibs;
1238 FilterNonExistent &NonExistent,
1246 .
flag(
"-mmicromips")
1247 .
flag(
"+march=mips32");
1252 .
flag(
"+mmicromips");
1257 .
flag(
"+march=mips64r2");
1266 .
flag(
"-mmicromips")
1267 .
flag(
"+march=mips32r2");
1284 MtiMipsMultilibsV1 =
1286 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1298 .
Either(BigEndian, LittleEndian)
1305 std::vector<std::string> Dirs({
"/include"});
1307 Dirs.push_back(
"/../../../../sysroot/uclibc/usr/include");
1309 Dirs.push_back(
"/../../../../sysroot/usr/include");
1319 .
flag(
"-msoft-float")
1324 .
flag(
"+msoft-float")
1325 .
flag(
"-mnan=2008");
1328 .
flag(
"-msoft-float")
1333 .
flag(
"+msoft-float")
1335 .
flag(
"-mmicromips");
1338 .
flag(
"-msoft-float")
1343 .
flag(
"-msoft-float")
1346 .
flag(
"-mmicromips");
1347 auto BeHardNanUclibc =
MultilibBuilder(
"/mips-r2-hard-nan2008-uclibc")
1349 .
flag(
"-msoft-float")
1352 auto ElHardNanUclibc =
MultilibBuilder(
"/mipsel-r2-hard-nan2008-uclibc")
1354 .
flag(
"-msoft-float")
1359 .
flag(
"-msoft-float")
1364 .
flag(
"-msoft-float")
1369 .
flag(
"-msoft-float")
1371 .
flag(
"+mmicromips");
1374 .
flag(
"+msoft-float")
1376 .
flag(
"+mmicromips");
1391 MtiMipsMultilibsV2 =
1393 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1394 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1395 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1396 .Either(O32, N32, N64)
1400 return std::vector<std::string>({
"/../../../../sysroot" +
1402 "/../usr/include"});
1404 .setFilePathsCallback([](
const Multilib &M) {
1405 return std::vector<std::string>(
1406 {
"/../../../../mips-mti-linux-gnu/lib" + M.
gccSuffix()});
1409 for (
auto *Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1410 if (Candidate->select(Flags,
Result.SelectedMultilib)) {
1411 Result.Multilibs = *Candidate;
1419 FilterNonExistent &NonExistent,
1435 .
Maybe(LittleEndian)
1439 return std::vector<std::string>(
1440 {
"/include",
"/../../../../sysroot/usr/include"});
1449 .
flag(
"-msoft-float")
1450 .
flag(
"-mmicromips");
1453 .
flag(
"+msoft-float")
1454 .
flag(
"-mmicromips");
1457 .
flag(
"-msoft-float")
1458 .
flag(
"-mmicromips");
1461 .
flag(
"+msoft-float")
1462 .
flag(
"-mmicromips");
1465 .
flag(
"-msoft-float")
1466 .
flag(
"+mmicromips");
1469 .
flag(
"+msoft-float")
1470 .
flag(
"+mmicromips");
1473 .
flag(
"-msoft-float")
1474 .
flag(
"+mmicromips");
1477 .
flag(
"+msoft-float")
1478 .
flag(
"+mmicromips");
1495 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1496 ElMicroHard, ElMicroSoft})
1497 .Either(O32, N32, N64)
1501 return std::vector<std::string>({
"/../../../../sysroot" +
1503 "/../usr/include"});
1505 .setFilePathsCallback([](
const Multilib &M) {
1506 return std::vector<std::string>(
1507 {
"/../../../../mips-img-linux-gnu/lib" + M.
gccSuffix()});
1510 for (
auto *Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1511 if (Candidate->select(Flags,
Result.SelectedMultilib)) {
1512 Result.Multilibs = *Candidate;
1520 const llvm::Triple &TargetTriple,
1521 StringRef Path,
const ArgList &Args,
1523 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1529 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1537 CPUName ==
"mips32r5" || CPUName ==
"p5600",
1538 "march=mips32r2", Flags);
1542 CPUName ==
"mips64r5" || CPUName ==
"octeon" ||
1543 CPUName ==
"octeon+",
1544 "march=mips64r2", Flags);
1557 if (TargetTriple.isAndroid())
1561 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1562 TargetTriple.getOS() == llvm::Triple::Linux &&
1563 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1566 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1567 TargetTriple.getOS() == llvm::Triple::Linux &&
1568 TargetTriple.isGNUEnvironment())
1571 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1572 TargetTriple.getOS() == llvm::Triple::Linux &&
1573 TargetTriple.isGNUEnvironment())
1582 Result.Multilibs.FilterOut(NonExistent);
1584 if (
Result.Multilibs.select(Flags,
Result.SelectedMultilib)) {
1593 const llvm::Triple &TargetTriple,
1594 StringRef Path,
const ArgList &Args,
1597 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1608 .
Either(ThumbMultilib, ArmV7Multilib, ArmV7ThumbMultilib,
1614 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1615 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1616 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1617 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1618 bool IsThumbMode = IsThumbArch ||
1619 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb,
false) ||
1620 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1621 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1622 (llvm::ARM::parseArchVersion(Arch) == 7 ||
1623 (IsArmArch && Arch ==
"" && IsV7SubArch));
1624 addMultilibFlag(IsArmV7Mode,
"march=armv7-a", Flags);
1625 addMultilibFlag(IsThumbMode,
"mthumb", Flags);
1627 if (AndroidArmMultilibs.
select(Flags,
Result.SelectedMultilib))
1628 Result.Multilibs = AndroidArmMultilibs;
1632 const llvm::Triple &TargetTriple,
1633 StringRef Path,
const ArgList &Args,
1635 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1647 Result.Multilibs.FilterOut(NonExistent);
1650 addMultilibFlag(Args.hasFlag(options::OPT_fexceptions,
1651 options::OPT_fno_exceptions,
false),
1652 "exceptions", Flags);
1653 if (
Result.Multilibs.select(Flags,
Result.SelectedMultilib))
1660 StringRef Path,
const ArgList &Args,
1662 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1665 std::optional<llvm::StringRef> Res =
1670 auto ARCHName = *Res;
1677 addMultilibFlag(ARCHName ==
"ck801",
"march=ck801", Flags);
1678 addMultilibFlag(ARCHName ==
"ck802",
"march=ck802", Flags);
1679 addMultilibFlag(ARCHName ==
"ck803",
"march=ck803", Flags);
1680 addMultilibFlag(ARCHName ==
"ck804",
"march=ck804", Flags);
1681 addMultilibFlag(ARCHName ==
"ck805",
"march=ck805", Flags);
1682 addMultilibFlag(ARCHName ==
"ck807",
"march=ck807", Flags);
1683 addMultilibFlag(ARCHName ==
"ck810",
"march=ck810", Flags);
1684 addMultilibFlag(ARCHName ==
"ck810v",
"march=ck810v", Flags);
1685 addMultilibFlag(ARCHName ==
"ck860",
"march=ck860", Flags);
1686 addMultilibFlag(ARCHName ==
"ck860v",
"march=ck860v", Flags);
1688 bool isBigEndian =
false;
1689 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
1690 options::OPT_mbig_endian))
1691 isBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
1692 addMultilibFlag(isBigEndian,
"EB", Flags);
1713 .
Either({Arch801, Arch802, Arch803, Arch804, Arch805, Arch807,
1714 Arch810, Arch810v, Arch860, Arch860v})
1715 .Either(HardFloat, SoftFpFloat, SoftFloat)
1719 if (CSKYMultilibs.
select(Flags,
Result.SelectedMultilib))
1720 Result.Multilibs = CSKYMultilibs;
1724 const llvm::Triple &TargetTriple,
1725 StringRef Path,
const ArgList &Args,
1727 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1728 struct RiscvMultilib {
1734 constexpr RiscvMultilib RISCVMultilibSet[] = {
1735 {
"rv32i",
"ilp32"}, {
"rv32im",
"ilp32"}, {
"rv32iac",
"ilp32"},
1736 {
"rv32imac",
"ilp32"}, {
"rv32imafc",
"ilp32f"}, {
"rv64imac",
"lp64"},
1737 {
"rv64imafdc",
"lp64d"}};
1739 std::vector<MultilibBuilder> Ms;
1740 for (
auto Element : RISCVMultilibSet) {
1744 (Twine(Element.march) +
"/" + Twine(Element.mabi)).str())
1745 .
flag(Twine(
"+march=", Element.march).str())
1746 .
flag(Twine(
"+mabi=", Element.mabi).str()));
1754 return std::vector<std::string>(
1756 "/../../../../riscv64-unknown-elf/lib" + M.
gccSuffix(),
1757 "/../../../../riscv32-unknown-elf/lib" + M.
gccSuffix()});
1761 llvm::StringSet<> Added_ABIs;
1764 for (
auto Element : RISCVMultilibSet) {
1765 addMultilibFlag(MArch == Element.march,
1766 Twine(
"march=", Element.march).str().c_str(), Flags);
1767 if (!Added_ABIs.count(Element.mabi)) {
1768 Added_ABIs.insert(Element.mabi);
1769 addMultilibFlag(ABIName == Element.mabi,
1770 Twine(
"mabi=", Element.mabi).str().c_str(), Flags);
1774 if (RISCVMultilibs.
select(Flags,
Result.SelectedMultilib))
1775 Result.Multilibs = RISCVMultilibs;
1779 const llvm::Triple &TargetTriple, StringRef Path,
1781 if (TargetTriple.getOS() == llvm::Triple::UnknownOS)
1784 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1799 .
Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1804 bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1807 addMultilibFlag(!IsRV64,
"m32", Flags);
1808 addMultilibFlag(IsRV64,
"m64", Flags);
1809 addMultilibFlag(ABIName ==
"ilp32",
"mabi=ilp32", Flags);
1810 addMultilibFlag(ABIName ==
"ilp32f",
"mabi=ilp32f", Flags);
1811 addMultilibFlag(ABIName ==
"ilp32d",
"mabi=ilp32d", Flags);
1812 addMultilibFlag(ABIName ==
"lp64",
"mabi=lp64", Flags);
1813 addMultilibFlag(ABIName ==
"lp64f",
"mabi=lp64f", Flags);
1814 addMultilibFlag(ABIName ==
"lp64d",
"mabi=lp64d", Flags);
1816 if (RISCVMultilibs.
select(Flags,
Result.SelectedMultilib))
1817 Result.Multilibs = RISCVMultilibs;
1821 const llvm::Triple &TargetTriple,
1822 StringRef Path,
const ArgList &Args,
1823 bool NeedsBiarchSuffix,
1834 StringRef Suff64 =
"/64";
1836 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1837 switch (TargetTriple.getArch()) {
1838 case llvm::Triple::x86:
1839 case llvm::Triple::x86_64:
1842 case llvm::Triple::sparc:
1843 case llvm::Triple::sparcv9:
1844 Suff64 =
"/sparcv9";
1853 .includeSuffix(Suff64)
1860 .includeSuffix(
"/32")
1867 .includeSuffix(
"/x32")
1874 FilterNonExistent NonExistent(
1875 Path, TargetTriple.isOSIAMCU() ?
"/libgcc.a" :
"/crtbegin.o", D.
getVFS());
1880 const bool IsX32 = TargetTriple.isX32();
1881 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1883 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1885 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1888 if (TargetTriple.isArch32Bit())
1889 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1891 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1893 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1897 DefaultBuilder.
flag(
"+m32").
flag(
"-m64").
flag(
"-mx32");
1898 else if (Want == WANT64)
1899 DefaultBuilder.
flag(
"-m32").
flag(
"+m64").
flag(
"-mx32");
1900 else if (Want == WANTX32)
1901 DefaultBuilder.
flag(
"-m32").
flag(
"-m64").
flag(
"+mx32");
1908 Result.Multilibs.push_back(Alt64);
1909 Result.Multilibs.push_back(Alt32);
1910 Result.Multilibs.push_back(Altx32);
1912 Result.Multilibs.FilterOut(NonExistent);
1915 addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32,
"m64", Flags);
1916 addMultilibFlag(TargetTriple.isArch32Bit(),
"m32", Flags);
1917 addMultilibFlag(TargetTriple.isArch64Bit() && IsX32,
"mx32", Flags);
1919 if (!
Result.Multilibs.select(Flags,
Result.SelectedMultilib))
1922 if (
Result.SelectedMultilib == Alt64 ||
Result.SelectedMultilib == Alt32 ||
1923 Result.SelectedMultilib == Altx32)
1936 StringRef RHSPatchSuffix)
const {
1937 if (Major != RHSMajor)
1938 return Major < RHSMajor;
1939 if (Minor != RHSMinor) {
1946 return Minor < RHSMinor;
1948 if (Patch != RHSPatch) {
1957 return Patch < RHSPatch;
1959 if (PatchSuffix != RHSPatchSuffix) {
1961 if (RHSPatchSuffix.empty())
1963 if (PatchSuffix.empty())
1967 return PatchSuffix < RHSPatchSuffix;
1979 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1980 std::pair<StringRef, StringRef>
First = VersionText.split(
'.');
1981 std::pair<StringRef, StringRef> Second =
First.second.split(
'.');
1983 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1984 if (
First.first.getAsInteger(10, GoodVersion.
Major) || GoodVersion.
Major < 0)
1987 if (
First.second.empty())
1989 StringRef MinorStr = Second.first;
1990 if (Second.second.empty()) {
1991 if (
size_t EndNumber = MinorStr.find_first_not_of(
"0123456789")) {
1992 GoodVersion.
PatchSuffix = std::string(MinorStr.substr(EndNumber));
1993 MinorStr = MinorStr.slice(0, EndNumber);
1996 if (MinorStr.getAsInteger(10, GoodVersion.
Minor) || GoodVersion.
Minor < 0)
1998 GoodVersion.
MinorStr = MinorStr.str();
2011 StringRef PatchText = Second.second;
2012 if (!PatchText.empty()) {
2013 if (
size_t EndNumber = PatchText.find_first_not_of(
"0123456789")) {
2015 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.
Patch) ||
2016 GoodVersion.
Patch < 0)
2018 GoodVersion.
PatchSuffix = std::string(PatchText.substr(EndNumber));
2026 llvm::StringRef SysRoot) {
2027 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
2029 return A->getValue();
2034 if (!SysRoot.empty())
2037 return GCC_INSTALL_PREFIX;
2050 const llvm::Triple &TargetTriple,
const ArgList &Args,
2052 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
2053 ? TargetTriple.get64BitArchVariant()
2054 : TargetTriple.get32BitArchVariant();
2060 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
2061 CandidateTripleAliases, CandidateBiarchLibDirs,
2062 CandidateBiarchTripleAliases);
2066 Args.getLastArg(clang::driver::options::OPT_gcc_install_dir_EQ);
2067 A && A->getValue()[0]) {
2068 StringRef InstallDir = A->getValue();
2069 if (!ScanGCCForMultilibs(TargetTriple, Args, InstallDir,
false)) {
2070 D.
Diag(diag::err_drv_invalid_gcc_install_dir) << InstallDir;
2072 (void)InstallDir.consume_back(
"/");
2073 StringRef VersionText = llvm::sys::path::filename(InstallDir);
2074 StringRef TripleText =
2075 llvm::sys::path::filename(llvm::sys::path::parent_path(InstallDir));
2077 Version = GCCVersion::Parse(VersionText);
2078 GCCTriple.setTriple(TripleText);
2079 GCCInstallPath = std::string(InstallDir);
2080 GCCParentLibPath = GCCInstallPath +
"/../../..";
2089 if (GCCToolchainDir !=
"") {
2090 if (GCCToolchainDir.back() ==
'/')
2091 GCCToolchainDir = GCCToolchainDir.drop_back();
2093 Prefixes.push_back(std::string(GCCToolchainDir));
2097 Prefixes.push_back(D.
SysRoot);
2098 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
2108 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
2120 GentooTestTriples.push_back(TargetTriple.str());
2122 GentooTestTriples.append(ExtraTripleAliases.begin(),
2123 ExtraTripleAliases.end());
2124 GentooTestTriples.append(CandidateTripleAliases.begin(),
2125 CandidateTripleAliases.end());
2126 if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
2127 CandidateBiarchTripleAliases))
2133 const GCCVersion VersionZero = GCCVersion::Parse(
"0.0.0");
2134 Version = VersionZero;
2135 for (
const std::string &Prefix : Prefixes) {
2137 if (!VFS.exists(Prefix))
2139 for (StringRef Suffix : CandidateLibDirs) {
2140 const std::string LibDir = concat(Prefix, Suffix);
2141 if (!VFS.exists(LibDir))
2144 bool GCCDirExists = VFS.exists(LibDir +
"/gcc");
2145 bool GCCCrossDirExists = VFS.exists(LibDir +
"/gcc-cross");
2147 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, TargetTriple.str(),
2148 false, GCCDirExists, GCCCrossDirExists);
2150 for (StringRef Candidate : ExtraTripleAliases)
2151 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
false,
2152 GCCDirExists, GCCCrossDirExists);
2153 for (StringRef Candidate : CandidateTripleAliases)
2154 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
false,
2155 GCCDirExists, GCCCrossDirExists);
2157 for (StringRef Suffix : CandidateBiarchLibDirs) {
2158 const std::string LibDir = Prefix + Suffix.str();
2159 if (!VFS.exists(LibDir))
2161 bool GCCDirExists = VFS.exists(LibDir +
"/gcc");
2162 bool GCCCrossDirExists = VFS.exists(LibDir +
"/gcc-cross");
2163 for (StringRef Candidate : CandidateBiarchTripleAliases)
2164 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
true,
2165 GCCDirExists, GCCCrossDirExists);
2169 if (Version > VersionZero)
2175 for (
const auto &InstallPath : CandidateGCCInstallPaths)
2176 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
2178 if (!GCCInstallPath.empty())
2179 OS <<
"Selected GCC installation: " << GCCInstallPath <<
"\n";
2181 for (
const auto &
Multilib : Multilibs)
2182 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
2184 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
2185 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
2189 if (BiarchSibling) {
2196void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
2198 StringRef SysRoot) {
2199 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2206 std::string PrefixDir = concat(SysRoot,
"/usr/gcc");
2208 for (llvm::vfs::directory_iterator LI = D.
getVFS().dir_begin(PrefixDir, EC),
2210 !EC && LI != LE; LI = LI.increment(EC)) {
2211 StringRef VersionText = llvm::sys::path::filename(LI->path());
2212 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2218 std::string CandidatePrefix = PrefixDir +
"/" + VersionText.str();
2219 std::string CandidateLibPath = CandidatePrefix +
"/lib/gcc";
2220 if (!D.
getVFS().exists(CandidateLibPath))
2223 Prefixes.push_back(CandidatePrefix);
2230 if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux &&
2231 D.
getVFS().exists(
"/opt/rh")) {
2234 Prefixes.push_back(
"/opt/rh/gcc-toolset-12/root/usr");
2235 Prefixes.push_back(
"/opt/rh/gcc-toolset-11/root/usr");
2236 Prefixes.push_back(
"/opt/rh/gcc-toolset-10/root/usr");
2237 Prefixes.push_back(
"/opt/rh/devtoolset-12/root/usr");
2238 Prefixes.push_back(
"/opt/rh/devtoolset-11/root/usr");
2239 Prefixes.push_back(
"/opt/rh/devtoolset-10/root/usr");
2240 Prefixes.push_back(
"/opt/rh/devtoolset-9/root/usr");
2241 Prefixes.push_back(
"/opt/rh/devtoolset-8/root/usr");
2242 Prefixes.push_back(
"/opt/rh/devtoolset-7/root/usr");
2243 Prefixes.push_back(
"/opt/rh/devtoolset-6/root/usr");
2244 Prefixes.push_back(
"/opt/rh/devtoolset-4/root/usr");
2245 Prefixes.push_back(
"/opt/rh/devtoolset-3/root/usr");
2246 Prefixes.push_back(
"/opt/rh/devtoolset-2/root/usr");
2250 Prefixes.push_back(concat(SysRoot,
"/usr"));
2253 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
2254 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
2268 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
2269 static const char *
const AArch64Triples[] = {
2270 "aarch64-none-linux-gnu",
"aarch64-linux-gnu",
"aarch64-redhat-linux",
2271 "aarch64-suse-linux"};
2272 static const char *
const AArch64beLibDirs[] = {
"/lib"};
2273 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu",
2274 "aarch64_be-linux-gnu"};
2276 static const char *
const ARMLibDirs[] = {
"/lib"};
2277 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi"};
2278 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
2279 "armv7hl-redhat-linux-gnueabi",
2280 "armv6hl-suse-linux-gnueabi",
2281 "armv7hl-suse-linux-gnueabi"};
2282 static const char *
const ARMebLibDirs[] = {
"/lib"};
2283 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi"};
2284 static const char *
const ARMebHFTriples[] = {
2285 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
2287 static const char *
const AVRLibDirs[] = {
"/lib"};
2288 static const char *
const AVRTriples[] = {
"avr"};
2290 static const char *
const CSKYLibDirs[] = {
"/lib"};
2291 static const char *
const CSKYTriples[] = {
2292 "csky-linux-gnuabiv2",
"csky-linux-uclibcabiv2",
"csky-elf-noneabiv2"};
2294 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
2295 static const char *
const X86_64Triples[] = {
2296 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
2297 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
2298 "x86_64-redhat-linux",
"x86_64-suse-linux",
2299 "x86_64-manbo-linux-gnu",
"x86_64-linux-gnu",
2300 "x86_64-slackware-linux",
"x86_64-unknown-linux",
2301 "x86_64-amazon-linux"};
2302 static const char *
const X32Triples[] = {
"x86_64-linux-gnux32",
2303 "x86_64-pc-linux-gnux32"};
2304 static const char *
const X32LibDirs[] = {
"/libx32",
"/lib"};
2305 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
2306 static const char *
const X86Triples[] = {
2307 "i586-linux-gnu",
"i686-linux-gnu",
"i686-pc-linux-gnu",
2308 "i386-redhat-linux6E",
"i686-redhat-linux",
"i386-redhat-linux",
2309 "i586-suse-linux",
"i686-montavista-linux",
"i686-gnu",
2312 static const char *
const LoongArch64LibDirs[] = {
"/lib64",
"/lib"};
2313 static const char *
const LoongArch64Triples[] = {
2314 "loongarch64-linux-gnu",
"loongarch64-unknown-linux-gnu"};
2316 static const char *
const M68kLibDirs[] = {
"/lib"};
2317 static const char *
const M68kTriples[] = {
2318 "m68k-linux-gnu",
"m68k-unknown-linux-gnu",
"m68k-suse-linux"};
2320 static const char *
const MIPSLibDirs[] = {
"/libo32",
"/lib"};
2321 static const char *
const MIPSTriples[] = {
2322 "mips-linux-gnu",
"mips-mti-linux",
"mips-mti-linux-gnu",
2323 "mips-img-linux-gnu",
"mipsisa32r6-linux-gnu"};
2324 static const char *
const MIPSELLibDirs[] = {
"/libo32",
"/lib"};
2325 static const char *
const MIPSELTriples[] = {
2326 "mipsel-linux-gnu",
"mips-img-linux-gnu",
"mipsisa32r6el-linux-gnu"};
2328 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
2329 static const char *
const MIPS64Triples[] = {
2330 "mips64-linux-gnu",
"mips-mti-linux-gnu",
2331 "mips-img-linux-gnu",
"mips64-linux-gnuabi64",
2332 "mipsisa64r6-linux-gnu",
"mipsisa64r6-linux-gnuabi64"};
2333 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
2334 static const char *
const MIPS64ELTriples[] = {
2335 "mips64el-linux-gnu",
"mips-mti-linux-gnu",
2336 "mips-img-linux-gnu",
"mips64el-linux-gnuabi64",
2337 "mipsisa64r6el-linux-gnu",
"mipsisa64r6el-linux-gnuabi64"};
2339 static const char *
const MIPSN32LibDirs[] = {
"/lib32"};
2340 static const char *
const MIPSN32Triples[] = {
"mips64-linux-gnuabin32",
2341 "mipsisa64r6-linux-gnuabin32"};
2342 static const char *
const MIPSN32ELLibDirs[] = {
"/lib32"};
2343 static const char *
const MIPSN32ELTriples[] = {
2344 "mips64el-linux-gnuabin32",
"mipsisa64r6el-linux-gnuabin32"};
2346 static const char *
const MSP430LibDirs[] = {
"/lib"};
2347 static const char *
const MSP430Triples[] = {
"msp430-elf"};
2349 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
2350 static const char *
const PPCTriples[] = {
2351 "powerpc-linux-gnu",
"powerpc-unknown-linux-gnu",
"powerpc-linux-gnuspe",
2354 "powerpc64-suse-linux",
"powerpc-montavista-linuxspe"};
2355 static const char *
const PPCLELibDirs[] = {
"/lib32",
"/lib"};
2356 static const char *
const PPCLETriples[] = {
"powerpcle-linux-gnu",
2357 "powerpcle-unknown-linux-gnu",
2358 "powerpcle-linux-musl"};
2360 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
2361 static const char *
const PPC64Triples[] = {
2362 "powerpc64-linux-gnu",
"powerpc64-unknown-linux-gnu",
2363 "powerpc64-suse-linux",
"ppc64-redhat-linux"};
2364 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
2365 static const char *
const PPC64LETriples[] = {
2366 "powerpc64le-linux-gnu",
"powerpc64le-unknown-linux-gnu",
2367 "powerpc64le-none-linux-gnu",
"powerpc64le-suse-linux",
2368 "ppc64le-redhat-linux"};
2370 static const char *
const RISCV32LibDirs[] = {
"/lib32",
"/lib"};
2371 static const char *
const RISCV32Triples[] = {
"riscv32-unknown-linux-gnu",
2372 "riscv32-linux-gnu",
2373 "riscv32-unknown-elf"};
2374 static const char *
const RISCV64LibDirs[] = {
"/lib64",
"/lib"};
2375 static const char *
const RISCV64Triples[] = {
"riscv64-unknown-linux-gnu",
2376 "riscv64-linux-gnu",
2377 "riscv64-unknown-elf"};
2379 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
2380 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
2381 "sparcv8-linux-gnu"};
2382 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
2383 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
2384 "sparcv9-linux-gnu"};
2386 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
2387 static const char *
const SystemZTriples[] = {
2388 "s390x-linux-gnu",
"s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
2389 "s390x-suse-linux",
"s390x-redhat-linux"};
2395 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2396 static const char *
const SolarisLibDirs[] = {
"/lib"};
2397 static const char *
const SolarisSparcV8Triples[] = {
2398 "sparc-sun-solaris2.11",
"sparc-sun-solaris2.12"};
2399 static const char *
const SolarisSparcV9Triples[] = {
2400 "sparcv9-sun-solaris2.11",
"sparcv9-sun-solaris2.12"};
2401 static const char *
const SolarisX86Triples[] = {
"i386-pc-solaris2.11",
2402 "i386-pc-solaris2.12"};
2403 static const char *
const SolarisX86_64Triples[] = {
"x86_64-pc-solaris2.11",
2404 "x86_64-pc-solaris2.12"};
2405 LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2406 BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2407 switch (TargetTriple.getArch()) {
2408 case llvm::Triple::x86:
2409 TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
2410 BiarchTripleAliases.append(begin(SolarisX86_64Triples),
2411 end(SolarisX86_64Triples));
2413 case llvm::Triple::x86_64:
2414 TripleAliases.append(begin(SolarisX86_64Triples),
2415 end(SolarisX86_64Triples));
2416 BiarchTripleAliases.append(begin(SolarisX86Triples),
2417 end(SolarisX86Triples));
2419 case llvm::Triple::sparc:
2420 TripleAliases.append(begin(SolarisSparcV8Triples),
2421 end(SolarisSparcV8Triples));
2422 BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2423 end(SolarisSparcV9Triples));
2425 case llvm::Triple::sparcv9:
2426 TripleAliases.append(begin(SolarisSparcV9Triples),
2427 end(SolarisSparcV9Triples));
2428 BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2429 end(SolarisSparcV8Triples));
2438 if (TargetTriple.isAndroid()) {
2439 static const char *
const AArch64AndroidTriples[] = {
2440 "aarch64-linux-android"};
2441 static const char *
const ARMAndroidTriples[] = {
"arm-linux-androideabi"};
2442 static const char *
const X86AndroidTriples[] = {
"i686-linux-android"};
2443 static const char *
const X86_64AndroidTriples[] = {
"x86_64-linux-android"};
2445 switch (TargetTriple.getArch()) {
2446 case llvm::Triple::aarch64:
2447 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2448 TripleAliases.append(begin(AArch64AndroidTriples),
2449 end(AArch64AndroidTriples));
2451 case llvm::Triple::arm:
2452 case llvm::Triple::thumb:
2453 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2454 TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2456 case llvm::Triple::x86_64:
2457 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2458 TripleAliases.append(begin(X86_64AndroidTriples),
2459 end(X86_64AndroidTriples));
2460 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2461 BiarchTripleAliases.append(begin(X86AndroidTriples),
2462 end(X86AndroidTriples));
2464 case llvm::Triple::x86:
2465 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2466 TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
2467 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2468 BiarchTripleAliases.append(begin(X86_64AndroidTriples),
2469 end(X86_64AndroidTriples));
2478 switch (TargetTriple.getArch()) {
2479 case llvm::Triple::aarch64:
2480 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2481 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2482 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2483 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2485 case llvm::Triple::aarch64_be:
2486 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2487 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2488 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2489 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2491 case llvm::Triple::arm:
2492 case llvm::Triple::thumb:
2493 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2494 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2495 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2497 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2500 case llvm::Triple::armeb:
2501 case llvm::Triple::thumbeb:
2502 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2503 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2504 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2506 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2509 case llvm::Triple::avr:
2510 LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs));
2511 TripleAliases.append(begin(AVRTriples), end(AVRTriples));
2513 case llvm::Triple::csky:
2514 LibDirs.append(begin(CSKYLibDirs), end(CSKYLibDirs));
2515 TripleAliases.append(begin(CSKYTriples), end(CSKYTriples));
2517 case llvm::Triple::x86_64:
2518 if (TargetTriple.isX32()) {
2519 LibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2520 TripleAliases.append(begin(X32Triples), end(X32Triples));
2521 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2522 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2524 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2525 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2526 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2527 BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
2529 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2530 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2532 case llvm::Triple::x86:
2533 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2536 if (!TargetTriple.isOSIAMCU()) {
2537 TripleAliases.append(begin(X86Triples), end(X86Triples));
2538 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2539 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2540 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2541 BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
2545 case llvm::Triple::loongarch64:
2546 LibDirs.append(begin(LoongArch64LibDirs), end(LoongArch64LibDirs));
2547 TripleAliases.append(begin(LoongArch64Triples), end(LoongArch64Triples));
2549 case llvm::Triple::m68k:
2550 LibDirs.append(begin(M68kLibDirs), end(M68kLibDirs));
2551 TripleAliases.append(begin(M68kTriples), end(M68kTriples));
2553 case llvm::Triple::mips:
2554 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2555 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2556 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2557 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2558 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2559 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2561 case llvm::Triple::mipsel:
2562 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2563 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2564 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2565 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2566 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2567 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2568 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2570 case llvm::Triple::mips64:
2571 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2572 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2573 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2574 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2575 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2576 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2578 case llvm::Triple::mips64el:
2579 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2580 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2581 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2582 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2583 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2584 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2585 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2587 case llvm::Triple::msp430:
2588 LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2589 TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2591 case llvm::Triple::ppc:
2592 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2593 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2594 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2595 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2597 case llvm::Triple::ppcle:
2598 LibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs));
2599 TripleAliases.append(begin(PPCLETriples), end(PPCLETriples));
2600 BiarchLibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2601 BiarchTripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2603 case llvm::Triple::ppc64:
2604 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2605 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2606 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2607 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2609 case llvm::Triple::ppc64le:
2610 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2611 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2612 BiarchLibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs));
2613 BiarchTripleAliases.append(begin(PPCLETriples), end(PPCLETriples));
2615 case llvm::Triple::riscv32:
2616 LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2617 TripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2618 BiarchLibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2619 BiarchTripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2621 case llvm::Triple::riscv64:
2622 LibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2623 TripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2624 BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2625 BiarchTripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2627 case llvm::Triple::sparc:
2628 case llvm::Triple::sparcel:
2629 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2630 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2631 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2632 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2634 case llvm::Triple::sparcv9:
2635 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2636 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2637 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2638 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2640 case llvm::Triple::systemz:
2641 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2642 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2652 TripleAliases.push_back(TargetTriple.str());
2655 if (TargetTriple.str() != BiarchTriple.str())
2656 BiarchTripleAliases.push_back(BiarchTriple.str());
2659bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2660 const llvm::Triple &TargetTriple,
const ArgList &Args,
2661 StringRef Path,
bool NeedsBiarchSuffix) {
2662 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2671 }
else if (TargetTriple.isCSKY()) {
2673 }
else if (TargetTriple.isMIPS()) {
2676 }
else if (TargetTriple.isRISCV()) {
2680 }
else if (TargetArch == llvm::Triple::avr) {
2683 NeedsBiarchSuffix, Detected)) {
2694void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2695 const llvm::Triple &TargetTriple,
const ArgList &Args,
2696 const std::string &LibDir, StringRef CandidateTriple,
2697 bool NeedsBiarchSuffix,
bool GCCDirExists,
bool GCCCrossDirExists) {
2700 struct GCCLibSuffix {
2702 std::string LibSuffix;
2705 StringRef ReversePath;
2710 {
"gcc/" + CandidateTriple.str(),
"../..", GCCDirExists},
2713 {
"gcc-cross/" + CandidateTriple.str(),
"../..", GCCCrossDirExists},
2719 {CandidateTriple.str(),
"..",
2720 TargetTriple.getVendor() == llvm::Triple::Freescale ||
2721 TargetTriple.getVendor() == llvm::Triple::OpenEmbedded}};
2727 StringRef LibSuffix = Suffix.LibSuffix;
2729 for (llvm::vfs::directory_iterator
2730 LI = D.
getVFS().dir_begin(LibDir +
"/" + LibSuffix, EC),
2732 !EC && LI != LE; LI = LI.increment(EC)) {
2733 StringRef VersionText = llvm::sys::path::filename(LI->path());
2734 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2735 if (CandidateVersion.Major != -1)
2736 if (!CandidateGCCInstallPaths.insert(std::string(LI->path())).second)
2738 if (CandidateVersion.isOlderThan(4, 1, 1))
2740 if (CandidateVersion <= Version)
2743 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
2747 Version = CandidateVersion;
2748 GCCTriple.setTriple(CandidateTriple);
2752 GCCInstallPath = (LibDir +
"/" + LibSuffix +
"/" + VersionText).str();
2753 GCCParentLibPath = (GCCInstallPath +
"/../" + Suffix.ReversePath).str();
2759bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
2760 const llvm::Triple &TargetTriple,
const ArgList &Args,
2766 for (StringRef CandidateTriple : CandidateTriples) {
2767 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
2771 for (StringRef CandidateTriple : CandidateBiarchTriples) {
2772 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple,
true))
2778bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2779 const llvm::Triple &TargetTriple,
const ArgList &Args,
2780 StringRef CandidateTriple,
bool NeedsBiarchSuffix) {
2781 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
File =
2782 D.
getVFS().getBufferForFile(concat(D.
SysRoot, GentooConfigDir,
2783 "/config-" + CandidateTriple.str()));
2786 File.get()->getBuffer().split(Lines,
"\n");
2787 for (StringRef Line : Lines) {
2790 if (!Line.consume_front(
"CURRENT="))
2793 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
2794 D.
getVFS().getBufferForFile(
2795 concat(D.
SysRoot, GentooConfigDir,
"/" + Line));
2796 std::pair<StringRef, StringRef> ActiveVersion = Line.rsplit(
'-');
2809 ConfigFile.get()->getBuffer().split(ConfigLines,
"\n");
2810 for (StringRef ConfLine : ConfigLines) {
2811 ConfLine = ConfLine.trim();
2812 if (ConfLine.consume_front(
"LDPATH=")) {
2814 ConfLine.consume_back(
"\"");
2815 ConfLine.consume_front(
"\"");
2817 ConfLine.split(GentooScanPaths,
':', -1,
false);
2822 std::string basePath =
"/usr/lib/gcc/" + ActiveVersion.first.str() +
"/"
2823 + ActiveVersion.second.str();
2824 GentooScanPaths.push_back(StringRef(basePath));
2827 for (
const auto &GentooScanPath : GentooScanPaths) {
2828 std::string GentooPath = concat(D.
SysRoot, GentooScanPath);
2829 if (D.
getVFS().exists(GentooPath +
"/crtbegin.o")) {
2830 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2834 Version = GCCVersion::Parse(ActiveVersion.second);
2835 GCCInstallPath = GentooPath;
2836 GCCParentLibPath = GentooPath + std::string(
"/../../..");
2837 GCCTriple.setTriple(ActiveVersion.first);
2849 const ArgList &Args)
2850 :
ToolChain(D, Triple, Args), GCCInstallation(D),
2851 CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {
2864 return Preprocess.get();
2868 return Compile.get();
2890 case llvm::Triple::aarch64:
2891 case llvm::Triple::ppc:
2892 case llvm::Triple::ppcle:
2893 case llvm::Triple::ppc64:
2894 case llvm::Triple::ppc64le:
2895 case llvm::Triple::riscv32:
2896 case llvm::Triple::riscv64:
2897 case llvm::Triple::x86:
2898 case llvm::Triple::x86_64:
2907 case llvm::Triple::x86_64:
2909 case llvm::Triple::mips64:
2910 case llvm::Triple::mips64el:
2927 case llvm::Triple::nvptx:
2928 case llvm::Triple::nvptx64:
2929 case llvm::Triple::xcore:
2932 return getTriple().getVendor() != llvm::Triple::Myriad;
2952 const std::string &SysRoot,
2953 const std::string &OSLibDir,
2954 const std::string &MultiarchTriple,
2959 const std::string &LibPath =
2997 LibPath +
"/../" + GCCTriple.str() +
"/lib/../" + OSLibDir +
3010 if (StringRef(LibPath).startswith(SysRoot))
3011 addPathIfExists(D, LibPath +
"/../" + OSLibDir, Paths);
3016 const std::string &SysRoot,
3017 const std::string &OSLibDir,
3020 const std::string &LibPath =
3031 ArgStringList &CC1Args)
const {
3039 Twine(LibPath) +
"/../" + GCCTriple.str() +
"/include");
3050 ArgStringList &CC1Args)
const {
3051 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdincxx,
3052 options::OPT_nostdlibinc))
3068 llvm::opt::ArgStringList &CC1Args)
const {
3073 auto AddIncludePath = [&](std::string Path) {
3075 if (Version.empty())
3079 std::string TargetDir = Path +
"/" +
Target +
"/c++/" + Version;
3080 if (D.
getVFS().exists(TargetDir))
3091 if (AddIncludePath(
getDriver().Dir +
"/../include"))
3096 if (AddIncludePath(
concat(SysRoot,
"/usr/local/include")))
3098 if (AddIncludePath(
concat(SysRoot,
"/usr/include")))
3103 Twine IncludeSuffix,
3104 const llvm::opt::ArgList &DriverArgs,
3105 llvm::opt::ArgStringList &CC1Args,
3106 bool DetectDebian)
const {
3107 if (!
getVFS().exists(IncludeDir))
3113 std::string Dir = IncludeDir.str();
3115 llvm::sys::path::parent_path(llvm::sys::path::parent_path(Dir));
3117 (Include +
"/" + Triple + Dir.substr(Include.size()) + IncludeSuffix)
3119 if (DetectDebian && !
getVFS().exists(Path))
3128 else if (!Triple.empty())
3130 IncludeDir +
"/" + Triple + IncludeSuffix);
3137 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
3138 StringRef DebianMultiarch)
const {
3152 LibDir.str() +
"/../" + TripleStr +
"/include/c++/" + Version.
Text,
3160 Version.
Text +
"/include/c++/",
3168 DriverArgs, CC1Args,
true))
3179 const std::string LibStdCXXIncludePathCandidates[] = {
3182 InstallDir.str() +
"/include/g++-v" + Version.
Text,
3183 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr +
"." +
3185 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr,
3188 for (
const auto &IncludePath : LibStdCXXIncludePathCandidates) {
3198 llvm::opt::ArgStringList &CC1Args)
const {
3205llvm::opt::DerivedArgList *
3214 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
3219 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_shared));
3220 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_fPIC));
3224 for (
auto *A : Args) {
3229 case options::OPT_shared:
3230 case options::OPT_dynamic:
3231 case options::OPT_static:
3232 case options::OPT_fPIC:
3233 case options::OPT_fno_PIC:
3234 case options::OPT_fpic:
3235 case options::OPT_fno_pic:
3236 case options::OPT_fPIE:
3237 case options::OPT_fno_PIE:
3238 case options::OPT_fpie:
3239 case options::OPT_fno_pie:
3248void Generic_ELF::anchor() {}
3251 ArgStringList &CC1Args,
3253 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
3254 options::OPT_fno_use_init_array,
true))
3255 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 isArmBigEndian(const llvm::Triple &Triple, const ArgList &Args)
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 getPIE(const ArgList &Args, const ToolChain &TC)
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.
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
MultilibBuilder & flag(StringRef F)
Add a flag to the flags list Flag must be a flag accepted by the driver with its leading '-' removed,...
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.
MultilibSet & setFilePathsCallback(IncludeDirsFunc F)
MultilibSet & FilterOut(FilterCallback F)
Filter out some subset of the Multilibs using a user defined callback.
multilib_list select(const Multilib::flags_list &Flags) const
Select compatible variants.
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)
@ C
Languages that the frontend can parse and compile.
@ Result
The result type of a method or function.
Multilib SelectedMultilib
The primary multilib appropriate for the given flags.
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.
static constexpr ResponseFileSupport AtFileCurCP()