18 #include "clang/Config/config.h" 25 #include "llvm/Option/ArgList.h" 26 #include "llvm/Support/CodeGen.h" 27 #include "llvm/Support/Path.h" 28 #include "llvm/Support/TargetParser.h" 29 #include "llvm/Support/VirtualFileSystem.h" 30 #include <system_error> 34 using namespace clang;
39 void tools::GnuTool::anchor() {}
44 return O.getKind() != Option::InputClass &&
52 ArgStringList &CmdArgs) {
53 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
54 StringRef CPUArg(A->getValue());
55 if (CPUArg.equals_lower(
"krait"))
56 CmdArgs.push_back(
"-mcpu=cortex-a15");
57 else if(CPUArg.equals_lower(
"kryo"))
58 CmdArgs.push_back(
"-mcpu=cortex-a57");
60 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
68 const char *LinkingOutput)
const {
69 const Driver &D = getToolChain().getDriver();
70 ArgStringList CmdArgs;
72 for (
const auto &A : Args) {
81 if (isa<AssembleJobAction>(JA) &&
82 A->getOption().matches(options::OPT_g_Group))
86 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
87 A->getOption().matches(options::OPT_W_Group))
92 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
93 (A->getOption().matches(options::OPT_munaligned_access) ||
94 A->getOption().matches(options::OPT_mno_unaligned_access)))
97 A->render(Args, CmdArgs);
101 RenderExtraToolArgs(JA, CmdArgs);
104 if (getToolChain().getTriple().isOSDarwin()) {
105 CmdArgs.push_back(
"-arch");
107 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
115 switch (getToolChain().getArch()) {
118 case llvm::Triple::x86:
119 case llvm::Triple::ppc:
120 CmdArgs.push_back(
"-m32");
122 case llvm::Triple::x86_64:
123 case llvm::Triple::ppc64:
124 case llvm::Triple::ppc64le:
125 CmdArgs.push_back(
"-m64");
127 case llvm::Triple::sparcel:
128 CmdArgs.push_back(
"-EL");
133 CmdArgs.push_back(
"-o");
136 assert(Output.
isNothing() &&
"Unexpected output");
137 CmdArgs.push_back(
"-fsyntax-only");
140 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
150 for (
const auto &II : Inputs) {
153 D.
Diag(clang::diag::err_drv_no_linker_llvm_support)
154 << getToolChain().getTripleString();
155 else if (II.getType() == types::TY_AST)
156 D.
Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
157 else if (II.getType() == types::TY_ModuleFile)
158 D.
Diag(diag::err_drv_no_module_support)
159 << getToolChain().getTripleString();
162 CmdArgs.push_back(
"-x");
167 CmdArgs.push_back(II.getFilename());
169 const Arg &A = II.getInputArg();
172 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
173 CmdArgs.push_back(
"-lstdc++");
178 A.render(Args, CmdArgs);
184 if (!customGCCName.empty())
185 GCCName = customGCCName.c_str();
191 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
192 C.
addCommand(std::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
196 const JobAction &JA, ArgStringList &CmdArgs)
const {
197 CmdArgs.push_back(
"-E");
201 ArgStringList &CmdArgs)
const {
202 const Driver &D = getToolChain().getDriver();
206 case types::TY_LLVM_IR:
207 case types::TY_LTO_IR:
208 case types::TY_LLVM_BC:
209 case types::TY_LTO_BC:
210 CmdArgs.push_back(
"-c");
214 case types::TY_Object:
215 CmdArgs.push_back(
"-c");
217 case types::TY_PP_Asm:
218 CmdArgs.push_back(
"-S");
220 case types::TY_Nothing:
221 CmdArgs.push_back(
"-fsyntax-only");
229 ArgStringList &CmdArgs)
const {
238 const ArgList &Args) {
239 bool IsBigEndian =
false;
240 switch (Triple.getArch()) {
241 case llvm::Triple::armeb:
242 case llvm::Triple::thumbeb:
245 case llvm::Triple::arm:
246 case llvm::Triple::thumb:
247 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
248 options::OPT_mbig_endian))
249 IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
257 static const char *
getLDMOption(
const llvm::Triple &T,
const ArgList &Args) {
258 switch (T.getArch()) {
259 case llvm::Triple::x86:
263 case llvm::Triple::aarch64:
264 return "aarch64linux";
265 case llvm::Triple::aarch64_be:
266 return "aarch64linuxb";
267 case llvm::Triple::arm:
268 case llvm::Triple::thumb:
269 case llvm::Triple::armeb:
270 case llvm::Triple::thumbeb:
271 return isArmBigEndian(T, Args) ?
"armelfb_linux_eabi" :
"armelf_linux_eabi";
272 case llvm::Triple::ppc:
273 return "elf32ppclinux";
274 case llvm::Triple::ppc64:
276 case llvm::Triple::ppc64le:
278 case llvm::Triple::riscv32:
279 return "elf32lriscv";
280 case llvm::Triple::riscv64:
281 return "elf64lriscv";
282 case llvm::Triple::sparc:
283 case llvm::Triple::sparcel:
284 return "elf32_sparc";
285 case llvm::Triple::sparcv9:
286 return "elf64_sparc";
287 case llvm::Triple::mips:
288 return "elf32btsmip";
289 case llvm::Triple::mipsel:
290 return "elf32ltsmip";
291 case llvm::Triple::mips64:
293 T.getEnvironment() == llvm::Triple::GNUABIN32)
294 return "elf32btsmipn32";
295 return "elf64btsmip";
296 case llvm::Triple::mips64el:
298 T.getEnvironment() == llvm::Triple::GNUABIN32)
299 return "elf32ltsmipn32";
300 return "elf64ltsmip";
301 case llvm::Triple::systemz:
303 case llvm::Triple::x86_64:
304 if (T.getEnvironment() == llvm::Triple::GNUX32)
305 return "elf32_x86_64";
313 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) ||
314 Args.hasArg(options::OPT_r) || Args.hasArg(options::OPT_static_pie))
317 Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
321 return A->getOption().matches(options::OPT_pie);
326 bool HasStaticPIE = Args.hasArg(options::OPT_static_pie);
329 if (HasStaticPIE && Args.hasArg(options::OPT_nopie)) {
331 const llvm::opt::OptTable &Opts = D.
getOpts();
332 const char *StaticPIEName = Opts.getOptionName(options::OPT_static_pie);
333 const char *NoPIEName = Opts.getOptionName(options::OPT_nopie);
334 D.
Diag(diag::err_drv_cannot_mix_options) << StaticPIEName << NoPIEName;
340 return Args.hasArg(options::OPT_static) &&
341 !Args.hasArg(options::OPT_static_pie);
348 const char *LinkingOutput)
const {
353 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
355 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
356 const bool isAndroid = ToolChain.
getTriple().isAndroid();
357 const bool IsIAMCU = ToolChain.
getTriple().isOSIAMCU();
358 const bool IsPIE =
getPIE(Args, ToolChain);
361 const bool HasCRTBeginEndFiles =
362 ToolChain.
getTriple().hasEnvironment() ||
363 (ToolChain.
getTriple().getVendor() != llvm::Triple::MipsTechnologies);
365 ArgStringList CmdArgs;
368 Args.ClaimAllArgs(options::OPT_g_Group);
370 Args.ClaimAllArgs(options::OPT_emit_llvm);
373 Args.ClaimAllArgs(options::OPT_w);
376 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
379 CmdArgs.push_back(
"-pie");
382 CmdArgs.push_back(
"-static");
383 CmdArgs.push_back(
"-pie");
384 CmdArgs.push_back(
"--no-dynamic-linker");
385 CmdArgs.push_back(
"-z");
386 CmdArgs.push_back(
"text");
390 CmdArgs.push_back(
"-z");
391 CmdArgs.push_back(
"noexecstack");
394 if (Args.hasArg(options::OPT_rdynamic))
395 CmdArgs.push_back(
"-export-dynamic");
397 if (Args.hasArg(options::OPT_s))
398 CmdArgs.push_back(
"-s");
400 if (Triple.isARM() || Triple.isThumb() || Triple.isAArch64()) {
404 IsBigEndian = IsBigEndian || Arch == llvm::Triple::aarch64_be;
405 CmdArgs.push_back(IsBigEndian ?
"-EB" :
"-EL");
410 if (Arch == llvm::Triple::aarch64 && isAndroid) {
412 if (CPU.empty() || CPU ==
"generic" || CPU ==
"cortex-a53")
413 CmdArgs.push_back(
"--fix-cortex-a53-843419");
419 CmdArgs.push_back(
"--warn-shared-textrel");
421 for (
const auto &Opt : ToolChain.
ExtraOpts)
422 CmdArgs.push_back(Opt.c_str());
424 CmdArgs.push_back(
"--eh-frame-hdr");
427 CmdArgs.push_back(
"-m");
428 CmdArgs.push_back(LDMOption);
430 D.
Diag(diag::err_target_unknown_triple) << Triple.str();
435 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
436 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
437 CmdArgs.push_back(
"-Bstatic");
439 CmdArgs.push_back(
"-static");
440 }
else if (Args.hasArg(options::OPT_shared)) {
441 CmdArgs.push_back(
"-shared");
445 if (Args.hasArg(options::OPT_rdynamic))
446 CmdArgs.push_back(
"-export-dynamic");
448 if (!Args.hasArg(options::OPT_shared) && !IsStaticPIE) {
449 const std::string Loader =
451 CmdArgs.push_back(
"-dynamic-linker");
452 CmdArgs.push_back(Args.MakeArgString(Loader));
456 CmdArgs.push_back(
"-o");
459 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
460 if (!isAndroid && !IsIAMCU) {
461 const char *crt1 =
nullptr;
462 if (!Args.hasArg(options::OPT_shared)) {
463 if (Args.hasArg(options::OPT_pg))
467 else if (IsStaticPIE)
473 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crt1)));
475 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
479 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crt0.o")));
480 else if (HasCRTBeginEndFiles) {
484 std::string crtbegin = ToolChain.
getCompilerRT(Args,
"crtbegin",
486 if (ToolChain.
getVFS().exists(crtbegin))
490 const char *crtbegin;
492 crtbegin = isAndroid ?
"crtbegin_static.o" :
"crtbeginT.o";
493 else if (Args.hasArg(options::OPT_shared))
494 crtbegin = isAndroid ?
"crtbegin_so.o" :
"crtbeginS.o";
495 else if (IsPIE || IsStaticPIE)
496 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbeginS.o";
498 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbegin.o";
501 CmdArgs.push_back(Args.MakeArgString(P));
508 Args.AddAllArgs(CmdArgs, options::OPT_L);
509 Args.AddAllArgs(CmdArgs, options::OPT_u);
514 assert(!Inputs.empty() &&
"Must have at least one input.");
519 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
520 CmdArgs.push_back(
"--no-demangle");
526 getToolChain().addProfileRTLibs(Args, CmdArgs);
529 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
531 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
532 !Args.hasArg(options::OPT_static);
533 if (OnlyLibstdcxxStatic)
534 CmdArgs.push_back(
"-Bstatic");
536 if (OnlyLibstdcxxStatic)
537 CmdArgs.push_back(
"-Bdynamic");
539 CmdArgs.push_back(
"-lm");
542 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
544 if (!Args.hasArg(options::OPT_nostdlib)) {
545 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
546 if (IsStatic || IsStaticPIE)
547 CmdArgs.push_back(
"--start-group");
549 if (NeedsSanitizerDeps)
555 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
556 Args.hasArg(options::OPT_pthreads);
559 bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&
560 !Args.hasArg(options::OPT_static);
573 if (WantPthread && !isAndroid)
574 CmdArgs.push_back(
"-lpthread");
576 if (Args.hasArg(options::OPT_fsplit_stack))
577 CmdArgs.push_back(
"--wrap=pthread_create");
579 if (!Args.hasArg(options::OPT_nolibc))
580 CmdArgs.push_back(
"-lc");
584 CmdArgs.push_back(
"-lgloss");
586 if (IsStatic || IsStaticPIE)
587 CmdArgs.push_back(
"--end-group");
593 CmdArgs.push_back(
"--as-needed");
594 CmdArgs.push_back(
"-lsoftfp");
595 CmdArgs.push_back(
"--no-as-needed");
599 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
600 if (HasCRTBeginEndFiles) {
606 if (ToolChain.
getVFS().exists(crtend))
611 if (Args.hasArg(options::OPT_shared))
612 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
613 else if (IsPIE || IsStaticPIE)
614 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
616 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
619 CmdArgs.push_back(Args.MakeArgString(P));
622 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
630 const char *Exec = Args.MakeArgString(ToolChain.
GetLinkerPath());
631 C.
addCommand(std::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
639 const char *LinkingOutput)
const {
640 const auto &D = getToolChain().getDriver();
644 ArgStringList CmdArgs;
646 llvm::Reloc::Model RelocationModel;
649 std::tie(RelocationModel, PICLevel, IsPIE) =
652 if (
const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
653 if (A->getOption().getID() == options::OPT_gz) {
654 CmdArgs.push_back(
"--compress-debug-sections");
656 StringRef
Value = A->getValue();
657 if (Value ==
"none" || Value ==
"zlib" || Value ==
"zlib-gnu") {
659 Args.MakeArgString(
"--compress-debug-sections=" + Twine(Value)));
661 D.Diag(diag::err_drv_unsupported_option_argument)
662 << A->getOption().getName() <<
Value;
667 if (getToolChain().isNoExecStackDefault()) {
668 CmdArgs.push_back(
"--noexecstack");
671 switch (getToolChain().getArch()) {
676 case llvm::Triple::x86:
677 CmdArgs.push_back(
"--32");
679 case llvm::Triple::x86_64:
680 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
681 CmdArgs.push_back(
"--x32");
683 CmdArgs.push_back(
"--64");
685 case llvm::Triple::ppc: {
686 CmdArgs.push_back(
"-a32");
687 CmdArgs.push_back(
"-mppc");
692 case llvm::Triple::ppc64: {
693 CmdArgs.push_back(
"-a64");
694 CmdArgs.push_back(
"-mppc64");
699 case llvm::Triple::ppc64le: {
700 CmdArgs.push_back(
"-a64");
701 CmdArgs.push_back(
"-mppc64");
702 CmdArgs.push_back(
"-mlittle-endian");
707 case llvm::Triple::riscv32:
708 case llvm::Triple::riscv64: {
710 CmdArgs.push_back(
"-mabi");
711 CmdArgs.push_back(ABIName.data());
713 CmdArgs.push_back(
"-march");
714 CmdArgs.push_back(MArchName.data());
717 case llvm::Triple::sparc:
718 case llvm::Triple::sparcel: {
719 CmdArgs.push_back(
"-32");
720 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
726 case llvm::Triple::sparcv9: {
727 CmdArgs.push_back(
"-64");
728 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
734 case llvm::Triple::arm:
735 case llvm::Triple::armeb:
736 case llvm::Triple::thumb:
737 case llvm::Triple::thumbeb: {
738 const llvm::Triple &Triple2 = getToolChain().getTriple();
740 switch (Triple2.getSubArch()) {
741 case llvm::Triple::ARMSubArch_v7:
742 CmdArgs.push_back(
"-mfpu=neon");
744 case llvm::Triple::ARMSubArch_v8:
745 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
752 case arm::FloatABI::Invalid: llvm_unreachable(
"must have an ABI!");
753 case arm::FloatABI::Soft:
754 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=soft"));
756 case arm::FloatABI::SoftFP:
757 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=softfp"));
759 case arm::FloatABI::Hard:
760 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=hard"));
764 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
767 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
770 case llvm::Triple::aarch64:
771 case llvm::Triple::aarch64_be: {
773 getToolChain().getArch() == llvm::Triple::aarch64_be ?
"-EB" :
"-EL");
774 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
779 case llvm::Triple::mips:
780 case llvm::Triple::mipsel:
781 case llvm::Triple::mips64:
782 case llvm::Triple::mips64el: {
788 CmdArgs.push_back(
"-march");
789 CmdArgs.push_back(CPUName.data());
791 CmdArgs.push_back(
"-mabi");
792 CmdArgs.push_back(ABIName.data());
796 if (RelocationModel == llvm::Reloc::Static)
797 CmdArgs.push_back(
"-mno-shared");
801 if (ABIName !=
"64" && !Args.hasArg(options::OPT_mno_abicalls))
802 CmdArgs.push_back(
"-call_nonpic");
804 if (getToolChain().getTriple().isLittleEndian())
805 CmdArgs.push_back(
"-EL");
807 CmdArgs.push_back(
"-EB");
809 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
810 if (StringRef(A->getValue()) ==
"2008")
811 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
815 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
816 options::OPT_mfp64)) {
818 A->render(Args, CmdArgs);
820 Args, getToolChain().getTriple(), CPUName, ABIName,
822 getToolChain().getTriple())))
823 CmdArgs.push_back(
"-mfpxx");
828 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
829 if (A->getOption().matches(options::OPT_mips16)) {
831 A->render(Args, CmdArgs);
834 CmdArgs.push_back(
"-no-mips16");
838 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
839 options::OPT_mno_micromips);
840 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
841 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
843 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
846 if (A->getOption().matches(options::OPT_mmsa))
847 CmdArgs.push_back(Args.MakeArgString(
"-mmsa"));
850 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
851 options::OPT_msoft_float);
853 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
854 options::OPT_msingle_float);
856 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
857 options::OPT_mno_odd_spreg);
862 case llvm::Triple::systemz: {
866 CmdArgs.push_back(Args.MakeArgString(
"-march=" + CPUName));
871 for (
const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
872 options::OPT_fdebug_prefix_map_EQ)) {
873 StringRef Map = A->getValue();
874 if (Map.find(
'=') == StringRef::npos)
875 D.Diag(diag::err_drv_invalid_argument_to_option)
876 << Map << A->getOption().getName();
878 CmdArgs.push_back(Args.MakeArgString(
"--debug-prefix-map"));
879 CmdArgs.push_back(Args.MakeArgString(Map));
884 Args.AddAllArgs(CmdArgs, options::OPT_I);
885 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
887 CmdArgs.push_back(
"-o");
890 for (
const auto &II : Inputs)
891 CmdArgs.push_back(II.getFilename());
893 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
894 C.
addCommand(std::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
899 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
900 getToolChain().getTriple().isOSLinux())
907 class FilterNonExistent {
908 StringRef
Base, File;
909 llvm::vfs::FileSystem &VFS;
912 FilterNonExistent(StringRef Base, StringRef File, llvm::vfs::FileSystem &VFS)
913 : Base(Base), File(File), VFS(VFS) {}
914 bool operator()(
const Multilib &M) {
915 return !VFS.exists(Base + M.
gccSuffix() + File);
921 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
922 options::OPT_mfloat_abi_EQ);
926 return A->getOption().matches(options::OPT_msoft_float) ||
927 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
928 A->getValue() == StringRef(
"soft"));
932 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
935 static bool isMipsEL(llvm::Triple::ArchType Arch) {
936 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
940 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
941 return A && A->getOption().matches(options::OPT_mips16);
945 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
946 return A && A->getOption().matches(options::OPT_mmicromips);
949 static bool isMSP430(llvm::Triple::ArchType Arch) {
950 return Arch == llvm::Triple::msp430;
954 return Multilib(commonSuffix, commonSuffix, commonSuffix);
958 FilterNonExistent &NonExistent,
965 auto MArchMicroMips =
986 .includeSuffix(
"/64")
993 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
995 .
Either(SoftFloat, Nan2008, DefaultFloat)
998 .
Either(BigEndian, LittleEndian)
1004 std::vector<std::string> Dirs({
"/include"});
1007 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1009 Dirs.push_back(
"/../../../../mips-linux-gnu/libc/usr/include");
1021 .includeSuffix(
"/64")
1028 DebianMipsMultilibs =
1034 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1035 if (CSMipsMultilibs.
size() < DebianMipsMultilibs.size())
1036 std::iter_swap(Candidates, Candidates + 1);
1039 if (Candidate == &DebianMipsMultilibs)
1050 FilterNonExistent &NonExistent,
1062 Multilib(
"/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
1063 Multilib(
"/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
1069 Multilib().flag(
"+march=mips64r6"),
1070 Multilib(
"/32/mips-r1",
"",
"/mips-r1").flag(
"+march=mips32"),
1071 Multilib(
"/32/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
1072 Multilib(
"/32/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
1076 if (VFS.exists(Path +
"/mips-r6"))
1077 MS = &AndroidMipselMultilibs;
1078 else if (VFS.exists(Path +
"/32"))
1079 MS = &AndroidMips64elMultilibs;
1088 FilterNonExistent &NonExistent,
1097 .flag(
"+march=mips32r2");
1099 auto MArchMipselR2 =
makeMultilib(
"/mipsel-r2-hard-musl")
1102 .
flag(
"+march=mips32r2");
1108 return std::vector<std::string>(
1109 {
"/../sysroot" + M.
osSuffix() +
"/usr/include"});
1120 FilterNonExistent &NonExistent,
1128 .
flag(
"-mmicromips")
1129 .
flag(
"+march=mips32");
1134 .
flag(
"+mmicromips");
1139 .
flag(
"+march=mips64r2");
1147 .
flag(
"-mmicromips")
1148 .
flag(
"+march=mips32r2");
1165 MtiMipsMultilibsV1 =
1167 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1179 .
Either(BigEndian, LittleEndian)
1185 std::vector<std::string> Dirs({
"/include"});
1187 Dirs.push_back(
"/../../../../sysroot/uclibc/usr/include");
1189 Dirs.push_back(
"/../../../../sysroot/usr/include");
1199 .
flag(
"-msoft-float")
1204 .
flag(
"+msoft-float")
1205 .
flag(
"-mnan=2008");
1208 .
flag(
"-msoft-float")
1213 .
flag(
"+msoft-float")
1215 .
flag(
"-mmicromips");
1218 .
flag(
"-msoft-float")
1221 auto ElHardNan =
makeMultilib(
"/mipsel-r2-hard-nan2008")
1223 .
flag(
"-msoft-float")
1226 .
flag(
"-mmicromips");
1227 auto BeHardNanUclibc =
makeMultilib(
"/mips-r2-hard-nan2008-uclibc")
1229 .
flag(
"-msoft-float")
1232 auto ElHardNanUclibc =
makeMultilib(
"/mipsel-r2-hard-nan2008-uclibc")
1234 .
flag(
"-msoft-float")
1237 auto BeHardUclibc =
makeMultilib(
"/mips-r2-hard-uclibc")
1239 .
flag(
"-msoft-float")
1242 auto ElHardUclibc =
makeMultilib(
"/mipsel-r2-hard-uclibc")
1244 .
flag(
"-msoft-float")
1247 auto ElMicroHardNan =
makeMultilib(
"/micromipsel-r2-hard-nan2008")
1249 .
flag(
"-msoft-float")
1251 .
flag(
"+mmicromips");
1252 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r2-soft")
1254 .
flag(
"+msoft-float")
1256 .
flag(
"+mmicromips");
1265 MtiMipsMultilibsV2 =
1267 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1268 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1269 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1270 .Either(O32, N32, N64)
1273 return std::vector<std::string>({
"/../../../../sysroot" +
1275 "/../usr/include"});
1277 .setFilePathsCallback([](
const Multilib &M) {
1278 return std::vector<std::string>(
1279 {
"/../../../../mips-mti-linux-gnu/lib" + M.
gccSuffix()});
1282 for (
auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1292 FilterNonExistent &NonExistent,
1308 .
Maybe(LittleEndian)
1311 return std::vector<std::string>(
1312 {
"/include",
"/../../../../sysroot/usr/include"});
1321 .
flag(
"-msoft-float")
1322 .
flag(
"-mmicromips");
1325 .
flag(
"+msoft-float")
1326 .
flag(
"-mmicromips");
1329 .
flag(
"-msoft-float")
1330 .
flag(
"-mmicromips");
1333 .
flag(
"+msoft-float")
1334 .
flag(
"-mmicromips");
1337 .
flag(
"-msoft-float")
1338 .
flag(
"+mmicromips");
1341 .
flag(
"+msoft-float")
1342 .
flag(
"+mmicromips");
1343 auto ElMicroHard =
makeMultilib(
"/micromipsel-r6-hard")
1345 .
flag(
"-msoft-float")
1346 .
flag(
"+mmicromips");
1347 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r6-soft")
1349 .
flag(
"+msoft-float")
1350 .
flag(
"+mmicromips");
1361 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1362 ElMicroHard, ElMicroSoft})
1363 .Either(O32, N32, N64)
1366 return std::vector<std::string>({
"/../../../../sysroot" +
1368 "/../usr/include"});
1370 .setFilePathsCallback([](
const Multilib &M) {
1371 return std::vector<std::string>(
1372 {
"/../../../../mips-img-linux-gnu/lib" + M.
gccSuffix()});
1375 for (
auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1385 const llvm::Triple &TargetTriple,
1386 StringRef Path,
const ArgList &Args,
1388 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1394 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1402 CPUName ==
"mips32r5" || CPUName ==
"p5600",
1403 "march=mips32r2", Flags);
1407 CPUName ==
"mips64r5" || CPUName ==
"octeon" ||
1408 CPUName ==
"octeon+",
1409 "march=mips64r2", Flags);
1422 if (TargetTriple.isAndroid())
1426 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1427 TargetTriple.getOS() == llvm::Triple::Linux &&
1428 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1431 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1432 TargetTriple.getOS() == llvm::Triple::Linux &&
1433 TargetTriple.isGNUEnvironment())
1436 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1437 TargetTriple.getOS() == llvm::Triple::Linux &&
1438 TargetTriple.isGNUEnvironment())
1458 const llvm::Triple &TargetTriple,
1459 StringRef Path,
const ArgList &Args,
1462 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1464 .
flag(
"+march=armv7-a")
1467 .
flag(
"-march=armv7-a")
1470 .
flag(
"+march=armv7-a")
1473 .
flag(
"-march=armv7-a")
1477 .
Either(ThumbMultilib, ArmV7Multilib,
1478 ArmV7ThumbMultilib, DefaultMultilib)
1482 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1483 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1484 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1485 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1486 bool IsThumbMode = IsThumbArch ||
1487 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb,
false) ||
1488 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1489 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1490 (llvm::ARM::parseArchVersion(Arch) == 7 ||
1491 (IsArmArch && Arch ==
"" && IsV7SubArch));
1500 const llvm::Triple &TargetTriple,
1501 StringRef Path,
const ArgList &Args,
1503 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1520 const llvm::Triple &TargetTriple,
1521 StringRef Path,
const ArgList &Args,
1523 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1524 struct RiscvMultilib {
1531 {
"rv32i",
"ilp32"}, {
"rv32im",
"ilp32"}, {
"rv32iac",
"ilp32"},
1532 {
"rv32imac",
"ilp32"}, {
"rv32imafc",
"ilp32f"}, {
"rv64imac",
"lp64"},
1533 {
"rv64imafdc",
"lp64d"}};
1535 std::vector<Multilib> Ms;
1536 for (
auto Element : RISCVMultilibSet) {
1539 makeMultilib((Twine(Element.march) +
"/" + Twine(Element.mabi)).str())
1540 .flag(Twine(
"+march=", Element.march).str())
1541 .flag(Twine(
"+mabi=", Element.mabi).str()));
1548 return std::vector<std::string>(
1550 "/../../../../riscv64-unknown-elf/lib" + M.
gccSuffix(),
1551 "/../../../../riscv32-unknown-elf/lib" + M.
gccSuffix()});
1556 llvm::StringSet<> Added_ABIs;
1559 for (
auto Element : RISCVMultilibSet) {
1561 Twine(
"march=", Element.march).str().c_str(), Flags);
1562 if (!Added_ABIs.count(Element.mabi)) {
1563 Added_ABIs.insert(Element.mabi);
1565 Twine(
"mabi=", Element.mabi).str().c_str(), Flags);
1574 const llvm::Triple &TargetTriple, StringRef Path,
1576 if (TargetTriple.getOS() == llvm::Triple::UnknownOS)
1579 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1590 .
Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1591 .FilterOut(NonExistent);
1594 bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1611 const llvm::Triple &TargetTriple,
1612 StringRef Path,
const ArgList &Args,
1613 bool NeedsBiarchSuffix,
1624 StringRef Suff64 =
"/64";
1626 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1627 switch (TargetTriple.getArch()) {
1628 case llvm::Triple::x86:
1629 case llvm::Triple::x86_64:
1632 case llvm::Triple::sparc:
1633 case llvm::Triple::sparcv9:
1634 Suff64 =
"/sparcv9";
1643 .includeSuffix(Suff64)
1649 .includeSuffix(
"/32")
1655 .includeSuffix(
"/x32")
1661 FilterNonExistent NonExistent(
1662 Path, TargetTriple.isOSIAMCU() ?
"/libgcc.a" :
"/crtbegin.o", D.
getVFS());
1667 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
1668 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1670 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1672 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1675 if (TargetTriple.isArch32Bit())
1676 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1678 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1680 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1685 else if (Want == WANT64)
1687 else if (Want == WANTX32)
1721 StringRef RHSPatchSuffix)
const {
1722 if (Major != RHSMajor)
1723 return Major < RHSMajor;
1724 if (Minor != RHSMinor)
1725 return Minor < RHSMinor;
1726 if (Patch != RHSPatch) {
1735 return Patch < RHSPatch;
1737 if (PatchSuffix != RHSPatchSuffix) {
1739 if (RHSPatchSuffix.empty())
1741 if (PatchSuffix.empty())
1745 return PatchSuffix < RHSPatchSuffix;
1757 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1758 std::pair<StringRef, StringRef>
First = VersionText.split(
'.');
1759 std::pair<StringRef, StringRef> Second = First.second.split(
'.');
1761 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1762 if (First.first.getAsInteger(10, GoodVersion.
Major) || GoodVersion.
Major < 0)
1764 GoodVersion.
MajorStr = First.first.str();
1765 if (First.second.empty())
1767 StringRef MinorStr = Second.first;
1768 if (Second.second.empty()) {
1769 if (
size_t EndNumber = MinorStr.find_first_not_of(
"0123456789")) {
1770 GoodVersion.
PatchSuffix = MinorStr.substr(EndNumber);
1771 MinorStr = MinorStr.slice(0, EndNumber);
1774 if (MinorStr.getAsInteger(10, GoodVersion.
Minor) || GoodVersion.
Minor < 0)
1776 GoodVersion.
MinorStr = MinorStr.str();
1789 StringRef PatchText = Second.second;
1790 if (!PatchText.empty()) {
1791 if (
size_t EndNumber = PatchText.find_first_not_of(
"0123456789")) {
1793 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.
Patch) ||
1794 GoodVersion.
Patch < 0)
1796 GoodVersion.
PatchSuffix = PatchText.substr(EndNumber);
1804 llvm::StringRef SysRoot) {
1805 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
1807 return A->getValue();
1812 if (!SysRoot.empty())
1815 return GCC_INSTALL_PREFIX;
1828 const llvm::Triple &TargetTriple,
const ArgList &Args,
1830 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1831 ? TargetTriple.get64BitArchVariant()
1832 : TargetTriple.get32BitArchVariant();
1838 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1839 CandidateTripleAliases, CandidateBiarchLibDirs,
1840 CandidateBiarchTripleAliases);
1847 if (GCCToolchainDir !=
"") {
1848 if (GCCToolchainDir.back() ==
'/')
1849 GCCToolchainDir = GCCToolchainDir.drop_back();
1851 Prefixes.push_back(GCCToolchainDir);
1855 Prefixes.push_back(D.
SysRoot);
1856 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
1866 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
1874 if (GCCToolchainDir ==
"" || GCCToolchainDir == D.
SysRoot +
"/usr") {
1881 GentooTestTriples.push_back(TargetTriple.str());
1883 GentooTestTriples.append(ExtraTripleAliases.begin(),
1884 ExtraTripleAliases.end());
1885 GentooTestTriples.append(CandidateTripleAliases.begin(),
1886 CandidateTripleAliases.end());
1887 if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
1888 CandidateBiarchTripleAliases))
1894 Version = GCCVersion::Parse(
"0.0.0");
1895 for (
const std::string &Prefix : Prefixes) {
1896 if (!D.
getVFS().exists(Prefix))
1898 for (StringRef Suffix : CandidateLibDirs) {
1899 const std::string LibDir = Prefix + Suffix.str();
1900 if (!D.
getVFS().exists(LibDir))
1903 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, TargetTriple.str());
1905 for (StringRef Candidate : ExtraTripleAliases)
1906 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1907 for (StringRef Candidate : CandidateTripleAliases)
1908 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1910 for (StringRef Suffix : CandidateBiarchLibDirs) {
1911 const std::string LibDir = Prefix + Suffix.str();
1912 if (!D.
getVFS().exists(LibDir))
1914 for (StringRef Candidate : CandidateBiarchTripleAliases)
1915 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1922 for (
const auto &InstallPath : CandidateGCCInstallPaths)
1923 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
1925 if (!GCCInstallPath.empty())
1926 OS <<
"Selected GCC installation: " << GCCInstallPath <<
"\n";
1928 for (
const auto &
Multilib : Multilibs)
1929 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
1931 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
1932 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
1936 if (BiarchSibling.hasValue()) {
1937 M = BiarchSibling.getValue();
1943 void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
1945 StringRef SysRoot) {
1946 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1953 std::string PrefixDir = SysRoot.str() +
"/usr/gcc";
1955 for (llvm::vfs::directory_iterator LI = D.
getVFS().dir_begin(PrefixDir, EC),
1957 !EC && LI !=
LE; LI = LI.increment(EC)) {
1958 StringRef VersionText = llvm::sys::path::filename(LI->path());
1959 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1962 if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
1965 std::string CandidatePrefix = PrefixDir +
"/" + VersionText.str();
1966 std::string CandidateLibPath = CandidatePrefix +
"/lib/gcc";
1967 if (!D.
getVFS().exists(CandidateLibPath))
1970 Prefixes.push_back(CandidatePrefix);
1976 if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux) {
1978 Prefixes.push_back(
"/opt/rh/devtoolset-8/root/usr");
1979 Prefixes.push_back(
"/opt/rh/devtoolset-7/root/usr");
1980 Prefixes.push_back(
"/opt/rh/devtoolset-6/root/usr");
1981 Prefixes.push_back(
"/opt/rh/devtoolset-4/root/usr");
1982 Prefixes.push_back(
"/opt/rh/devtoolset-3/root/usr");
1983 Prefixes.push_back(
"/opt/rh/devtoolset-2/root/usr");
1985 Prefixes.push_back(SysRoot.str() +
"/usr");
1988 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1989 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
1997 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
1998 static const char *
const AArch64Triples[] = {
1999 "aarch64-none-linux-gnu",
"aarch64-linux-gnu",
"aarch64-redhat-linux",
2000 "aarch64-suse-linux",
"aarch64-linux-android"};
2001 static const char *
const AArch64beLibDirs[] = {
"/lib"};
2002 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu",
2003 "aarch64_be-linux-gnu"};
2005 static const char *
const ARMLibDirs[] = {
"/lib"};
2006 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi",
2007 "arm-linux-androideabi"};
2008 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
2009 "armv7hl-redhat-linux-gnueabi",
2010 "armv6hl-suse-linux-gnueabi",
2011 "armv7hl-suse-linux-gnueabi"};
2012 static const char *
const ARMebLibDirs[] = {
"/lib"};
2013 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi",
2014 "armeb-linux-androideabi"};
2015 static const char *
const ARMebHFTriples[] = {
2016 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
2018 static const char *
const AVRLibDirs[] = {
"/lib"};
2019 static const char *
const AVRTriples[] = {
"avr"};
2021 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
2022 static const char *
const X86_64Triples[] = {
2023 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
2024 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
2025 "x86_64-redhat-linux",
"x86_64-suse-linux",
2026 "x86_64-manbo-linux-gnu",
"x86_64-linux-gnu",
2027 "x86_64-slackware-linux",
"x86_64-unknown-linux",
2028 "x86_64-amazon-linux",
"x86_64-linux-android"};
2029 static const char *
const X32LibDirs[] = {
"/libx32"};
2030 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
2031 static const char *
const X86Triples[] = {
2032 "i686-linux-gnu",
"i686-pc-linux-gnu",
"i486-linux-gnu",
2033 "i386-linux-gnu",
"i386-redhat-linux6E",
"i686-redhat-linux",
2034 "i586-redhat-linux",
"i386-redhat-linux",
"i586-suse-linux",
2035 "i486-slackware-linux",
"i686-montavista-linux",
"i586-linux-gnu",
2036 "i686-linux-android",
"i386-gnu",
"i486-gnu",
2037 "i586-gnu",
"i686-gnu"};
2039 static const char *
const MIPSLibDirs[] = {
"/lib"};
2040 static const char *
const MIPSTriples[] = {
2041 "mips-linux-gnu",
"mips-mti-linux",
"mips-mti-linux-gnu",
2042 "mips-img-linux-gnu",
"mipsisa32r6-linux-gnu"};
2043 static const char *
const MIPSELLibDirs[] = {
"/lib"};
2044 static const char *
const MIPSELTriples[] = {
2045 "mipsel-linux-gnu",
"mips-img-linux-gnu",
"mipsisa32r6el-linux-gnu",
2046 "mipsel-linux-android"};
2048 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
2049 static const char *
const MIPS64Triples[] = {
2050 "mips64-linux-gnu",
"mips-mti-linux-gnu",
2051 "mips-img-linux-gnu",
"mips64-linux-gnuabi64",
2052 "mipsisa64r6-linux-gnu",
"mipsisa64r6-linux-gnuabi64"};
2053 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
2054 static const char *
const MIPS64ELTriples[] = {
2055 "mips64el-linux-gnu",
"mips-mti-linux-gnu",
2056 "mips-img-linux-gnu",
"mips64el-linux-gnuabi64",
2057 "mipsisa64r6el-linux-gnu",
"mipsisa64r6el-linux-gnuabi64",
2058 "mips64el-linux-android"};
2060 static const char *
const MIPSN32LibDirs[] = {
"/lib32"};
2061 static const char *
const MIPSN32Triples[] = {
"mips64-linux-gnuabin32",
2062 "mipsisa64r6-linux-gnuabin32"};
2063 static const char *
const MIPSN32ELLibDirs[] = {
"/lib32"};
2064 static const char *
const MIPSN32ELTriples[] = {
2065 "mips64el-linux-gnuabin32",
"mipsisa64r6el-linux-gnuabin32"};
2067 static const char *
const MSP430LibDirs[] = {
"/lib"};
2068 static const char *
const MSP430Triples[] = {
"msp430-elf"};
2070 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
2071 static const char *
const PPCTriples[] = {
2072 "powerpc-linux-gnu",
"powerpc-unknown-linux-gnu",
"powerpc-linux-gnuspe",
2075 "powerpc64-suse-linux",
"powerpc-montavista-linuxspe"};
2076 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
2077 static const char *
const PPC64Triples[] = {
2078 "powerpc64-linux-gnu",
"powerpc64-unknown-linux-gnu",
2079 "powerpc64-suse-linux",
"ppc64-redhat-linux"};
2080 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
2081 static const char *
const PPC64LETriples[] = {
2082 "powerpc64le-linux-gnu",
"powerpc64le-unknown-linux-gnu",
2083 "powerpc64le-suse-linux",
"ppc64le-redhat-linux"};
2085 static const char *
const RISCV32LibDirs[] = {
"/lib32",
"/lib"};
2086 static const char *
const RISCV32Triples[] = {
"riscv32-unknown-linux-gnu",
2087 "riscv32-linux-gnu",
2088 "riscv32-unknown-elf"};
2089 static const char *
const RISCV64LibDirs[] = {
"/lib64",
"/lib"};
2090 static const char *
const RISCV64Triples[] = {
"riscv64-unknown-linux-gnu",
2091 "riscv64-linux-gnu",
2092 "riscv64-unknown-elf",
2093 "riscv64-suse-linux"};
2095 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
2096 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
2097 "sparcv8-linux-gnu"};
2098 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
2099 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
2100 "sparcv9-linux-gnu"};
2102 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
2103 static const char *
const SystemZTriples[] = {
2104 "s390x-linux-gnu",
"s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
2105 "s390x-suse-linux",
"s390x-redhat-linux"};
2111 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2112 static const char *
const SolarisLibDirs[] = {
"/lib"};
2113 static const char *
const SolarisSparcV8Triples[] = {
2114 "sparc-sun-solaris2.11",
"sparc-sun-solaris2.12"};
2115 static const char *
const SolarisSparcV9Triples[] = {
2116 "sparcv9-sun-solaris2.11",
"sparcv9-sun-solaris2.12"};
2117 static const char *
const SolarisX86Triples[] = {
"i386-pc-solaris2.11",
2118 "i386-pc-solaris2.12"};
2119 static const char *
const SolarisX86_64Triples[] = {
"x86_64-pc-solaris2.11",
2120 "x86_64-pc-solaris2.12"};
2121 LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2122 BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2123 switch (TargetTriple.getArch()) {
2124 case llvm::Triple::x86:
2125 TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
2126 BiarchTripleAliases.append(begin(SolarisX86_64Triples),
2127 end(SolarisX86_64Triples));
2129 case llvm::Triple::x86_64:
2130 TripleAliases.append(begin(SolarisX86_64Triples),
2131 end(SolarisX86_64Triples));
2132 BiarchTripleAliases.append(begin(SolarisX86Triples),
2133 end(SolarisX86Triples));
2135 case llvm::Triple::sparc:
2136 TripleAliases.append(begin(SolarisSparcV8Triples),
2137 end(SolarisSparcV8Triples));
2138 BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2139 end(SolarisSparcV9Triples));
2141 case llvm::Triple::sparcv9:
2142 TripleAliases.append(begin(SolarisSparcV9Triples),
2143 end(SolarisSparcV9Triples));
2144 BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2145 end(SolarisSparcV8Triples));
2154 if (TargetTriple.isAndroid()) {
2155 static const char *
const AArch64AndroidTriples[] = {
2156 "aarch64-linux-android"};
2157 static const char *
const ARMAndroidTriples[] = {
"arm-linux-androideabi"};
2158 static const char *
const MIPSELAndroidTriples[] = {
"mipsel-linux-android"};
2159 static const char *
const MIPS64ELAndroidTriples[] = {
2160 "mips64el-linux-android"};
2161 static const char *
const X86AndroidTriples[] = {
"i686-linux-android"};
2162 static const char *
const X86_64AndroidTriples[] = {
"x86_64-linux-android"};
2164 switch (TargetTriple.getArch()) {
2165 case llvm::Triple::aarch64:
2166 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2167 TripleAliases.append(begin(AArch64AndroidTriples),
2168 end(AArch64AndroidTriples));
2170 case llvm::Triple::arm:
2171 case llvm::Triple::thumb:
2172 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2173 TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2175 case llvm::Triple::mipsel:
2176 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2177 TripleAliases.append(begin(MIPSELAndroidTriples),
2178 end(MIPSELAndroidTriples));
2179 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2180 BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples),
2181 end(MIPS64ELAndroidTriples));
2183 case llvm::Triple::mips64el:
2184 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2185 TripleAliases.append(begin(MIPS64ELAndroidTriples),
2186 end(MIPS64ELAndroidTriples));
2187 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2188 BiarchTripleAliases.append(begin(MIPSELAndroidTriples),
2189 end(MIPSELAndroidTriples));
2191 case llvm::Triple::x86_64:
2192 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2193 TripleAliases.append(begin(X86_64AndroidTriples),
2194 end(X86_64AndroidTriples));
2195 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2196 BiarchTripleAliases.append(begin(X86AndroidTriples),
2197 end(X86AndroidTriples));
2199 case llvm::Triple::x86:
2200 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2201 TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
2202 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2203 BiarchTripleAliases.append(begin(X86_64AndroidTriples),
2204 end(X86_64AndroidTriples));
2213 switch (TargetTriple.getArch()) {
2214 case llvm::Triple::aarch64:
2215 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2216 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2217 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2218 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2220 case llvm::Triple::aarch64_be:
2221 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2222 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2223 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2224 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2226 case llvm::Triple::arm:
2227 case llvm::Triple::thumb:
2228 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2229 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2230 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2232 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2235 case llvm::Triple::armeb:
2236 case llvm::Triple::thumbeb:
2237 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2238 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2239 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2241 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2244 case llvm::Triple::avr:
2245 LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs));
2246 TripleAliases.append(begin(AVRTriples), end(AVRTriples));
2248 case llvm::Triple::x86_64:
2249 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2250 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2253 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
2254 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2255 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2257 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2258 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2261 case llvm::Triple::x86:
2262 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2265 if (!TargetTriple.isOSIAMCU()) {
2266 TripleAliases.append(begin(X86Triples), end(X86Triples));
2267 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2268 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2271 case llvm::Triple::mips:
2272 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2273 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2274 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2275 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2276 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2277 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2279 case llvm::Triple::mipsel:
2280 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2281 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2282 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2283 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2284 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2285 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2286 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2288 case llvm::Triple::mips64:
2289 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2290 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2291 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2292 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2293 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2294 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2296 case llvm::Triple::mips64el:
2297 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2298 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2299 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2300 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2301 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2302 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2303 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2305 case llvm::Triple::msp430:
2306 LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2307 TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2309 case llvm::Triple::ppc:
2310 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2311 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2312 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2313 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2315 case llvm::Triple::ppc64:
2316 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2317 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2318 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2319 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2321 case llvm::Triple::ppc64le:
2322 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2323 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2325 case llvm::Triple::riscv32:
2326 LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2327 TripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2328 BiarchLibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2329 BiarchTripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2331 case llvm::Triple::riscv64:
2332 LibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2333 TripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2334 BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2335 BiarchTripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2337 case llvm::Triple::sparc:
2338 case llvm::Triple::sparcel:
2339 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2340 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2341 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2342 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2344 case llvm::Triple::sparcv9:
2345 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2346 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2347 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2348 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2350 case llvm::Triple::systemz:
2351 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2352 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2362 TripleAliases.push_back(TargetTriple.str());
2365 if (TargetTriple.str() != BiarchTriple.str())
2366 BiarchTripleAliases.push_back(BiarchTriple.str());
2369 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2370 const llvm::Triple &TargetTriple,
const ArgList &Args,
2371 StringRef Path,
bool NeedsBiarchSuffix) {
2372 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2381 }
else if (TargetTriple.isMIPS()) {
2384 }
else if (TargetTriple.isRISCV()) {
2388 }
else if (TargetArch == llvm::Triple::avr) {
2391 NeedsBiarchSuffix, Detected)) {
2402 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2403 const llvm::Triple &TargetTriple,
const ArgList &Args,
2404 const std::string &LibDir, StringRef CandidateTriple,
2405 bool NeedsBiarchSuffix) {
2406 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2409 struct GCCLibSuffix {
2411 std::string LibSuffix;
2414 StringRef ReversePath;
2419 {
"gcc/" + CandidateTriple.str(),
"../..",
true},
2422 {
"gcc-cross/" + CandidateTriple.str(),
"../..",
2423 TargetTriple.getOS() != llvm::Triple::Solaris},
2429 {CandidateTriple.str(),
"..",
2430 TargetTriple.getVendor() == llvm::Triple::Freescale ||
2431 TargetTriple.getVendor() == llvm::Triple::OpenEmbedded},
2436 {CandidateTriple.str() +
"/gcc/" + CandidateTriple.str(),
"../../..",
2437 TargetTriple.getOS() != llvm::Triple::Solaris},
2443 {
"i386-linux-gnu/gcc/" + CandidateTriple.str(),
"../../..",
2444 (TargetArch == llvm::Triple::x86 &&
2445 TargetTriple.getOS() != llvm::Triple::Solaris)},
2446 {
"i386-gnu/gcc/" + CandidateTriple.str(),
"../../..",
2447 (TargetArch == llvm::Triple::x86 &&
2448 TargetTriple.getOS() != llvm::Triple::Solaris)}};
2454 StringRef LibSuffix = Suffix.LibSuffix;
2456 for (llvm::vfs::directory_iterator
2457 LI = D.
getVFS().dir_begin(LibDir +
"/" + LibSuffix, EC),
2459 !EC && LI !=
LE; LI = LI.increment(EC)) {
2460 StringRef VersionText = llvm::sys::path::filename(LI->path());
2461 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2462 if (CandidateVersion.Major != -1)
2463 if (!CandidateGCCInstallPaths.insert(LI->path()).second)
2465 if (CandidateVersion.isOlderThan(4, 1, 1))
2467 if (CandidateVersion <= Version)
2470 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
2474 Version = CandidateVersion;
2475 GCCTriple.setTriple(CandidateTriple);
2479 GCCInstallPath = (LibDir +
"/" + LibSuffix +
"/" + VersionText).str();
2480 GCCParentLibPath = (GCCInstallPath +
"/../" + Suffix.ReversePath).str();
2486 bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
2487 const llvm::Triple &TargetTriple,
const ArgList &Args,
2490 for (StringRef CandidateTriple : CandidateTriples) {
2491 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
2495 for (StringRef CandidateTriple : CandidateBiarchTriples) {
2496 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple,
true))
2502 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2503 const llvm::Triple &TargetTriple,
const ArgList &Args,
2504 StringRef CandidateTriple,
bool NeedsBiarchSuffix) {
2505 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
2506 D.
getVFS().getBufferForFile(D.
SysRoot +
"/etc/env.d/gcc/config-" +
2507 CandidateTriple.str());
2510 File.get()->getBuffer().split(Lines,
"\n");
2511 for (StringRef
Line : Lines) {
2514 if (!
Line.consume_front(
"CURRENT="))
2517 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
2520 std::pair<StringRef, StringRef> ActiveVersion =
Line.rsplit(
'-');
2533 ConfigFile.get()->getBuffer().split(ConfigLines,
"\n");
2534 for (StringRef ConfLine : ConfigLines) {
2535 ConfLine = ConfLine.trim();
2536 if (ConfLine.consume_front(
"LDPATH=")) {
2538 ConfLine.consume_back(
"\"");
2539 ConfLine.consume_front(
"\"");
2541 ConfLine.split(GentooScanPaths,
':', -1,
false);
2546 std::string basePath =
"/usr/lib/gcc/" + ActiveVersion.first.str() +
"/" 2547 + ActiveVersion.second.str();
2548 GentooScanPaths.push_back(StringRef(basePath));
2551 for (
const auto &GentooScanPath : GentooScanPaths) {
2552 std::string GentooPath = D.
SysRoot + std::string(GentooScanPath);
2553 if (D.
getVFS().exists(GentooPath +
"/crtbegin.o")) {
2554 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2558 Version = GCCVersion::Parse(ActiveVersion.second);
2559 GCCInstallPath = GentooPath;
2560 GCCParentLibPath = GentooPath + std::string(
"/../../..");
2561 GCCTriple.setTriple(ActiveVersion.first);
2573 const ArgList &Args)
2574 :
ToolChain(D, Triple, Args), GCCInstallation(D),
2575 CudaInstallation(D, Triple, Args) {
2588 return Preprocess.get();
2592 return Compile.get();
2611 return getArch() == llvm::Triple::x86_64;
2616 case llvm::Triple::x86_64:
2618 case llvm::Triple::mips64:
2619 case llvm::Triple::mips64el:
2634 case llvm::Triple::x86:
2635 case llvm::Triple::x86_64:
2636 case llvm::Triple::aarch64:
2637 case llvm::Triple::aarch64_be:
2638 case llvm::Triple::arm:
2639 case llvm::Triple::armeb:
2640 case llvm::Triple::avr:
2641 case llvm::Triple::bpfel:
2642 case llvm::Triple::bpfeb:
2643 case llvm::Triple::thumb:
2644 case llvm::Triple::thumbeb:
2645 case llvm::Triple::ppc:
2646 case llvm::Triple::ppc64:
2647 case llvm::Triple::ppc64le:
2648 case llvm::Triple::riscv32:
2649 case llvm::Triple::riscv64:
2650 case llvm::Triple::systemz:
2651 case llvm::Triple::mips:
2652 case llvm::Triple::mipsel:
2653 case llvm::Triple::mips64:
2654 case llvm::Triple::mips64el:
2655 case llvm::Triple::msp430:
2657 case llvm::Triple::sparc:
2658 case llvm::Triple::sparcel:
2659 case llvm::Triple::sparcv9:
2670 ArgStringList &CC1Args)
const {
2671 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2672 DriverArgs.hasArg(options::OPT_nostdincxx))
2690 std::string MaxVersionString;
2691 for (llvm::vfs::directory_iterator LI = vfs.dir_begin(base, EC),
LE;
2692 !EC && LI !=
LE; LI = LI.increment(EC)) {
2693 StringRef VersionText = llvm::sys::path::filename(LI->path());
2695 if (VersionText[0] ==
'v' &&
2696 !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) {
2697 if (Version > MaxVersion) {
2698 MaxVersion = Version;
2699 MaxVersionString = VersionText;
2703 return MaxVersion ? (base +
"/" + MaxVersionString).str() :
"";
2708 llvm::opt::ArgStringList &CC1Args)
const {
2710 auto AddIncludePath = [&](std::string Path) {
2712 if (IncludePath.empty() || !
getVFS().exists(IncludePath))
2720 if (AddIncludePath(
getDriver().Dir +
"/../include/c++"))
2725 if (AddIncludePath(SysRoot +
"/usr/local/include/c++"))
2727 if (AddIncludePath(SysRoot +
"/usr/include/c++"))
2733 Twine
Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2734 StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2735 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2736 if (!
getVFS().exists(Base + Suffix))
2744 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2745 getVFS().exists(Base + Suffix +
"/" + GCCTriple + IncludeSuffix)) {
2747 Base + Suffix +
"/" + GCCTriple + IncludeSuffix);
2755 Base +
"/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2757 Base +
"/" + TargetMultiarchTriple + Suffix);
2766 llvm::opt::ArgStringList &CC1Args)
const {
2780 const std::string TargetMultiarchTriple =
2786 "/c++/" + Version.
Text, TripleStr,
2787 GCCMultiarchTriple, TargetMultiarchTriple,
2793 const std::string LibStdCXXIncludePathCandidates[] = {
2796 InstallDir.str() +
"/include/g++-v" + Version.
Text,
2797 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr +
"." +
2799 InstallDir.str() +
"/include/g++-v" + Version.
MajorStr,
2802 for (
const auto &IncludePath : LibStdCXXIncludePathCandidates) {
2814 llvm::opt::ArgStringList &CC1Args)
const {
2818 llvm::opt::DerivedArgList *
2827 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2832 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_shared));
2833 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_fPIC));
2837 for (
auto *A : Args) {
2842 case options::OPT_shared:
2843 case options::OPT_dynamic:
2844 case options::OPT_static:
2845 case options::OPT_fPIC:
2846 case options::OPT_fno_PIC:
2847 case options::OPT_fpic:
2848 case options::OPT_fno_pic:
2849 case options::OPT_fPIE:
2850 case options::OPT_fno_PIE:
2851 case options::OPT_fpie:
2852 case options::OPT_fno_pie:
2861 void Generic_ELF::anchor() {}
2864 ArgStringList &CC1Args,
2866 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
2867 options::OPT_fno_use_init_array,
true))
2868 CC1Args.push_back(
"-fno-use-init-array");
MultilibSet & Either(const Multilib &M1, const Multilib &M2)
Add a set of mutually incompatible Multilib segments.
MultilibSet & Maybe(const Multilib &M)
Add an optional Multilib segment.
static void findRISCVBareMetalMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
static bool getPIE(const ArgList &Args, const toolchains::Linux &ToolChain)
bool isDefault() const
Check whether the default is selected.
static bool findMipsAndroidMultilibs(llvm::vfs::FileSystem &VFS, StringRef Path, const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
llvm::Optional< Multilib > BiarchSibling
On Biarch systems, this corresponds to the default multilib when targeting the non-default multilib...
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
std::string DyldPrefix
Dynamic loader prefix, if present.
bool canTypeBeUserSpecified(ID Id)
canTypeBeUserSpecified - Can this type be specified on the command line (by the type name); this is u...
bool isHostOffloading(OffloadKind OKind) const
Check if this action have any offload kinds.
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
DiagnosticBuilder Diag(unsigned DiagID) const
bool select(const Multilib::flags_list &Flags, Multilib &M) const
Pick the best multilib in the set,.
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
Multilib & flag(StringRef F)
Add a flag to the flags list Flag must be a flag accepted by the driver with its leading '-' removed...
static Multilib makeMultilib(StringRef commonSuffix)
const std::string & includeSuffix() const
Get the include directory suffix.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
static std::string DetectLibcxxIncludePath(llvm::vfs::FileSystem &vfs, StringRef base)
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
static bool isMipsEL(llvm::Triple::ArchType Arch)
MultilibSet & setIncludeDirsCallback(IncludeDirsFunc F)
types::ID getType() const
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
llvm::vfs::FileSystem & getVFS() const
static bool isMips16(const ArgList &Args)
static bool isSoftFloatABI(const ArgList &Args)
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
const AnnotatedLine * Line
static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static void normalizeCPUNamesForAssembler(const ArgList &Args, ArgStringList &CmdArgs)
std::vector< std::string > flags_list
void push_back(const Multilib &M)
Add a completed Multilib to the set.
void addCommand(std::unique_ptr< Command > C)
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag...
static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static bool forwardToGCC(const Option &O)
static const char * getLDMOption(const llvm::Triple &T, const ArgList &Args)
static bool findMipsImgMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static llvm::StringRef getGCCToolchainDir(const ArgList &Args, llvm::StringRef SysRoot)
std::string InstalledDir
The path to the installed clang directory, if any.
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
static bool findMSP430Multilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
static bool isArmOrThumbArch(llvm::Triple::ArchType Arch)
MultilibSet & setFilePathsCallback(IncludeDirsFunc F)
static bool findBiarchMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, bool NeedsBiarchSuffix, DetectedMultilibs &Result)
Dataflow Directional Tag Classes.
static bool isMSP430(llvm::Triple::ArchType Arch)
const std::string & getCCCGenericGCCName() const
Name to use when invoking gcc/g++.
std::string SysRoot
sysroot, if present
static bool findMipsCsMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static bool isArmBigEndian(const llvm::Triple &Triple, const ArgList &Args)
Compilation - A set of tasks to perform for a single driver invocation.
bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const llvm::opt::ArgList &Args, DetectedMultilibs &Result)
MultilibSet & FilterOut(FilterCallback F)
Filter out some subset of the Multilibs using a user defined callback.
bool LE(InterpState &S, CodePtr OpPC)
static bool getStatic(const ArgList &Args)
const llvm::opt::OptTable & getOpts() const
static constexpr CPUSuffix Suffixes[]
MultilibSet Multilibs
The set of multilibs that the detected installation supports.
static bool isMicroMips(const ArgList &Args)
bool isLLVMIR(ID Id)
Is this LLVM IR.
static void findAndroidArmMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
static void findRISCVMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
Multilib SelectedMultilib
The primary multilib appropriate for the given flags.
static bool getStaticPIE(const ArgList &Args, const toolchains::Linux &ToolChain)