20 #include "clang/Config/config.h" 26 #include "llvm/Option/ArgList.h" 27 #include "llvm/Support/CodeGen.h" 28 #include "llvm/Support/Path.h" 29 #include "llvm/Support/TargetParser.h" 30 #include <system_error> 34 using namespace clang;
37 void tools::GnuTool::anchor() {}
42 return O.getKind() != Option::InputClass &&
50 ArgStringList &CmdArgs) {
51 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
52 StringRef CPUArg(A->getValue());
53 if (CPUArg.equals_lower(
"krait"))
54 CmdArgs.push_back(
"-mcpu=cortex-a15");
55 else if(CPUArg.equals_lower(
"kryo"))
56 CmdArgs.push_back(
"-mcpu=cortex-a57");
58 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
66 const char *LinkingOutput)
const {
67 const Driver &D = getToolChain().getDriver();
68 ArgStringList CmdArgs;
70 for (
const auto &A : Args) {
79 if (isa<AssembleJobAction>(JA) &&
80 A->getOption().matches(options::OPT_g_Group))
84 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
85 A->getOption().matches(options::OPT_W_Group))
90 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
91 (A->getOption().matches(options::OPT_munaligned_access) ||
92 A->getOption().matches(options::OPT_mno_unaligned_access)))
95 A->render(Args, CmdArgs);
99 RenderExtraToolArgs(JA, CmdArgs);
102 if (getToolChain().getTriple().isOSDarwin()) {
103 CmdArgs.push_back(
"-arch");
105 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
113 switch (getToolChain().getArch()) {
116 case llvm::Triple::x86:
117 case llvm::Triple::ppc:
118 CmdArgs.push_back(
"-m32");
120 case llvm::Triple::x86_64:
121 case llvm::Triple::ppc64:
122 case llvm::Triple::ppc64le:
123 CmdArgs.push_back(
"-m64");
125 case llvm::Triple::sparcel:
126 CmdArgs.push_back(
"-EL");
131 CmdArgs.push_back(
"-o");
134 assert(Output.
isNothing() &&
"Unexpected output");
135 CmdArgs.push_back(
"-fsyntax-only");
138 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
148 for (
const auto &II : Inputs) {
151 D.
Diag(clang::diag::err_drv_no_linker_llvm_support)
152 << getToolChain().getTripleString();
153 else if (II.getType() == types::TY_AST)
154 D.
Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
155 else if (II.getType() == types::TY_ModuleFile)
156 D.
Diag(diag::err_drv_no_module_support)
157 << getToolChain().getTripleString();
160 CmdArgs.push_back(
"-x");
165 CmdArgs.push_back(II.getFilename());
167 const Arg &A = II.getInputArg();
170 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
171 CmdArgs.push_back(
"-lstdc++");
176 A.render(Args, CmdArgs);
182 if (!customGCCName.empty())
183 GCCName = customGCCName.c_str();
189 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
190 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
194 const JobAction &JA, ArgStringList &CmdArgs)
const {
195 CmdArgs.push_back(
"-E");
199 ArgStringList &CmdArgs)
const {
200 const Driver &D = getToolChain().getDriver();
204 case types::TY_LLVM_IR:
205 case types::TY_LTO_IR:
206 case types::TY_LLVM_BC:
207 case types::TY_LTO_BC:
208 CmdArgs.push_back(
"-c");
212 case types::TY_Object:
213 CmdArgs.push_back(
"-c");
215 case types::TY_PP_Asm:
216 CmdArgs.push_back(
"-S");
218 case types::TY_Nothing:
219 CmdArgs.push_back(
"-fsyntax-only");
227 ArgStringList &CmdArgs)
const {
231 static const char *
getLDMOption(
const llvm::Triple &T,
const ArgList &Args) {
232 switch (T.getArch()) {
233 case llvm::Triple::x86:
237 case llvm::Triple::aarch64:
238 return "aarch64linux";
239 case llvm::Triple::aarch64_be:
240 return "aarch64_be_linux";
241 case llvm::Triple::arm:
242 case llvm::Triple::thumb:
243 return "armelf_linux_eabi";
244 case llvm::Triple::armeb:
245 case llvm::Triple::thumbeb:
246 return "armelfb_linux_eabi";
247 case llvm::Triple::ppc:
248 return "elf32ppclinux";
249 case llvm::Triple::ppc64:
251 case llvm::Triple::ppc64le:
253 case llvm::Triple::riscv32:
254 return "elf32lriscv";
255 case llvm::Triple::riscv64:
256 return "elf64lriscv";
257 case llvm::Triple::sparc:
258 case llvm::Triple::sparcel:
259 return "elf32_sparc";
260 case llvm::Triple::sparcv9:
261 return "elf64_sparc";
262 case llvm::Triple::mips:
263 return "elf32btsmip";
264 case llvm::Triple::mipsel:
265 return "elf32ltsmip";
266 case llvm::Triple::mips64:
268 return "elf32btsmipn32";
269 return "elf64btsmip";
270 case llvm::Triple::mips64el:
272 return "elf32ltsmipn32";
273 return "elf64ltsmip";
274 case llvm::Triple::systemz:
276 case llvm::Triple::x86_64:
277 if (T.getEnvironment() == llvm::Triple::GNUX32)
278 return "elf32_x86_64";
286 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) ||
287 Args.hasArg(options::OPT_r))
290 Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
294 return A->getOption().matches(options::OPT_pie);
301 const char *LinkingOutput)
const {
306 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
308 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
309 const bool isAndroid = ToolChain.
getTriple().isAndroid();
310 const bool IsIAMCU = ToolChain.
getTriple().isOSIAMCU();
311 const bool IsPIE =
getPIE(Args, ToolChain);
312 const bool HasCRTBeginEndFiles =
313 ToolChain.
getTriple().hasEnvironment() ||
314 (ToolChain.
getTriple().getVendor() != llvm::Triple::MipsTechnologies);
316 ArgStringList CmdArgs;
319 Args.ClaimAllArgs(options::OPT_g_Group);
321 Args.ClaimAllArgs(options::OPT_emit_llvm);
324 Args.ClaimAllArgs(options::OPT_w);
326 const char *Exec = Args.MakeArgString(ToolChain.
GetLinkerPath());
327 if (llvm::sys::path::stem(Exec) ==
"lld") {
328 CmdArgs.push_back(
"-flavor");
329 CmdArgs.push_back(
"old-gnu");
330 CmdArgs.push_back(
"-target");
331 CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString()));
335 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
338 CmdArgs.push_back(
"-pie");
340 if (Args.hasArg(options::OPT_rdynamic))
341 CmdArgs.push_back(
"-export-dynamic");
343 if (Args.hasArg(options::OPT_s))
344 CmdArgs.push_back(
"-s");
346 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
351 if (Arch == llvm::Triple::aarch64 && isAndroid) {
353 if (CPU.empty() || CPU ==
"generic" || CPU ==
"cortex-a53")
354 CmdArgs.push_back(
"--fix-cortex-a53-843419");
357 for (
const auto &Opt : ToolChain.
ExtraOpts)
358 CmdArgs.push_back(Opt.c_str());
360 CmdArgs.push_back(
"--eh-frame-hdr");
363 CmdArgs.push_back(
"-m");
364 CmdArgs.push_back(LDMOption);
366 D.
Diag(diag::err_target_unknown_triple) << Triple.str();
370 if (Args.hasArg(options::OPT_static)) {
371 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
372 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
373 CmdArgs.push_back(
"-Bstatic");
375 CmdArgs.push_back(
"-static");
376 }
else if (Args.hasArg(options::OPT_shared)) {
377 CmdArgs.push_back(
"-shared");
380 if (!Args.hasArg(options::OPT_static)) {
381 if (Args.hasArg(options::OPT_rdynamic))
382 CmdArgs.push_back(
"-export-dynamic");
384 if (!Args.hasArg(options::OPT_shared)) {
385 const std::string Loader =
387 CmdArgs.push_back(
"-dynamic-linker");
388 CmdArgs.push_back(Args.MakeArgString(Loader));
392 CmdArgs.push_back(
"-o");
395 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
396 if (!isAndroid && !IsIAMCU) {
397 const char *crt1 =
nullptr;
398 if (!Args.hasArg(options::OPT_shared)) {
399 if (Args.hasArg(options::OPT_pg))
407 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crt1)));
409 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
413 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crt0.o")));
415 const char *crtbegin;
416 if (Args.hasArg(options::OPT_static))
417 crtbegin = isAndroid ?
"crtbegin_static.o" :
"crtbeginT.o";
418 else if (Args.hasArg(options::OPT_shared))
419 crtbegin = isAndroid ?
"crtbegin_so.o" :
"crtbeginS.o";
421 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbeginS.o";
423 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbegin.o";
425 if (HasCRTBeginEndFiles)
426 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtbegin)));
433 Args.AddAllArgs(CmdArgs, options::OPT_L);
434 Args.AddAllArgs(CmdArgs, options::OPT_u);
439 assert(!Inputs.empty() &&
"Must have at least one input.");
444 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
445 CmdArgs.push_back(
"--no-demangle");
451 getToolChain().addProfileRTLibs(Args, CmdArgs);
454 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
456 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
457 !Args.hasArg(options::OPT_static);
458 if (OnlyLibstdcxxStatic)
459 CmdArgs.push_back(
"-Bstatic");
461 if (OnlyLibstdcxxStatic)
462 CmdArgs.push_back(
"-Bdynamic");
464 CmdArgs.push_back(
"-lm");
467 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
469 if (!Args.hasArg(options::OPT_nostdlib)) {
470 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
471 if (Args.hasArg(options::OPT_static))
472 CmdArgs.push_back(
"--start-group");
474 if (NeedsSanitizerDeps)
480 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
481 Args.hasArg(options::OPT_pthreads);
494 if (WantPthread && !isAndroid)
495 CmdArgs.push_back(
"-lpthread");
497 if (Args.hasArg(options::OPT_fsplit_stack))
498 CmdArgs.push_back(
"--wrap=pthread_create");
500 CmdArgs.push_back(
"-lc");
504 CmdArgs.push_back(
"-lgloss");
506 if (Args.hasArg(options::OPT_static))
507 CmdArgs.push_back(
"--end-group");
513 CmdArgs.push_back(
"--as-needed");
514 CmdArgs.push_back(
"-lsoftfp");
515 CmdArgs.push_back(
"--no-as-needed");
519 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
521 if (Args.hasArg(options::OPT_shared))
522 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
524 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
526 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
528 if (HasCRTBeginEndFiles)
529 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtend)));
531 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
542 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
550 const char *LinkingOutput)
const {
551 const auto &D = getToolChain().getDriver();
555 ArgStringList CmdArgs;
557 llvm::Reloc::Model RelocationModel;
560 std::tie(RelocationModel, PICLevel, IsPIE) =
563 if (
const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
564 if (A->getOption().getID() == options::OPT_gz) {
565 CmdArgs.push_back(
"-compress-debug-sections");
567 StringRef
Value = A->getValue();
568 if (Value ==
"none") {
569 CmdArgs.push_back(
"-compress-debug-sections=none");
570 }
else if (Value ==
"zlib" || Value ==
"zlib-gnu") {
572 Args.MakeArgString(
"-compress-debug-sections=" + Twine(Value)));
574 D.Diag(diag::err_drv_unsupported_option_argument)
575 << A->getOption().getName() <<
Value;
580 switch (getToolChain().getArch()) {
585 case llvm::Triple::x86:
586 CmdArgs.push_back(
"--32");
588 case llvm::Triple::x86_64:
589 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
590 CmdArgs.push_back(
"--x32");
592 CmdArgs.push_back(
"--64");
594 case llvm::Triple::ppc: {
595 CmdArgs.push_back(
"-a32");
596 CmdArgs.push_back(
"-mppc");
601 case llvm::Triple::ppc64: {
602 CmdArgs.push_back(
"-a64");
603 CmdArgs.push_back(
"-mppc64");
608 case llvm::Triple::ppc64le: {
609 CmdArgs.push_back(
"-a64");
610 CmdArgs.push_back(
"-mppc64");
611 CmdArgs.push_back(
"-mlittle-endian");
616 case llvm::Triple::riscv32:
617 case llvm::Triple::riscv64: {
619 CmdArgs.push_back(
"-mabi");
620 CmdArgs.push_back(ABIName.data());
621 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
622 StringRef MArch = A->getValue();
623 CmdArgs.push_back(
"-march");
624 CmdArgs.push_back(MArch.data());
628 case llvm::Triple::sparc:
629 case llvm::Triple::sparcel: {
630 CmdArgs.push_back(
"-32");
631 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
636 case llvm::Triple::sparcv9: {
637 CmdArgs.push_back(
"-64");
638 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
643 case llvm::Triple::arm:
644 case llvm::Triple::armeb:
645 case llvm::Triple::thumb:
646 case llvm::Triple::thumbeb: {
647 const llvm::Triple &Triple2 = getToolChain().getTriple();
648 switch (Triple2.getSubArch()) {
649 case llvm::Triple::ARMSubArch_v7:
650 CmdArgs.push_back(
"-mfpu=neon");
652 case llvm::Triple::ARMSubArch_v8:
653 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
660 case arm::FloatABI::Invalid: llvm_unreachable(
"must have an ABI!");
661 case arm::FloatABI::Soft:
662 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=soft"));
664 case arm::FloatABI::SoftFP:
665 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=softfp"));
667 case arm::FloatABI::Hard:
668 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=hard"));
672 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
675 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
678 case llvm::Triple::aarch64:
679 case llvm::Triple::aarch64_be: {
680 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
685 case llvm::Triple::mips:
686 case llvm::Triple::mipsel:
687 case llvm::Triple::mips64:
688 case llvm::Triple::mips64el: {
694 CmdArgs.push_back(
"-march");
695 CmdArgs.push_back(CPUName.data());
697 CmdArgs.push_back(
"-mabi");
698 CmdArgs.push_back(ABIName.data());
702 if (RelocationModel == llvm::Reloc::Static)
703 CmdArgs.push_back(
"-mno-shared");
707 if (ABIName !=
"64" && !Args.hasArg(options::OPT_mno_abicalls))
708 CmdArgs.push_back(
"-call_nonpic");
710 if (getToolChain().getTriple().isLittleEndian())
711 CmdArgs.push_back(
"-EL");
713 CmdArgs.push_back(
"-EB");
715 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
716 if (StringRef(A->getValue()) ==
"2008")
717 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
721 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
722 options::OPT_mfp64)) {
724 A->render(Args, CmdArgs);
726 Args, getToolChain().getTriple(), CPUName, ABIName,
728 CmdArgs.push_back(
"-mfpxx");
733 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
734 if (A->getOption().matches(options::OPT_mips16)) {
736 A->render(Args, CmdArgs);
739 CmdArgs.push_back(
"-no-mips16");
743 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
744 options::OPT_mno_micromips);
745 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
746 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
748 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
751 if (A->getOption().matches(options::OPT_mmsa))
752 CmdArgs.push_back(Args.MakeArgString(
"-mmsa"));
755 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
756 options::OPT_msoft_float);
758 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
759 options::OPT_msingle_float);
761 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
762 options::OPT_mno_odd_spreg);
767 case llvm::Triple::systemz: {
771 CmdArgs.push_back(Args.MakeArgString(
"-march=" + CPUName));
776 Args.AddAllArgs(CmdArgs, options::OPT_I);
777 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
779 CmdArgs.push_back(
"-o");
782 for (
const auto &II : Inputs)
783 CmdArgs.push_back(II.getFilename());
785 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
786 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
791 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
792 getToolChain().getTriple().isOSLinux())
799 class FilterNonExistent {
800 StringRef
Base, File;
804 FilterNonExistent(StringRef Base, StringRef File,
vfs::FileSystem &VFS)
805 : Base(Base), File(File), VFS(VFS) {}
806 bool operator()(
const Multilib &M) {
813 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
814 options::OPT_mfloat_abi_EQ);
818 return A->getOption().matches(options::OPT_msoft_float) ||
819 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
820 A->getValue() == StringRef(
"soft"));
826 std::vector<std::string> &Flags) {
828 Flags.push_back(std::string(
"+") + Flag);
830 Flags.push_back(std::string(
"-") + Flag);
834 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
837 static bool isMipsEL(llvm::Triple::ArchType Arch) {
838 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
842 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
843 return A && A->getOption().matches(options::OPT_mips16);
847 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
848 return A && A->getOption().matches(options::OPT_mmicromips);
851 static bool isRISCV(llvm::Triple::ArchType Arch) {
852 return Arch == llvm::Triple::riscv32 || Arch == llvm::Triple::riscv64;
856 return Multilib(commonSuffix, commonSuffix, commonSuffix);
860 FilterNonExistent &NonExistent,
867 auto MArchMicroMips =
888 .includeSuffix(
"/64")
895 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
897 .
Either(SoftFloat, Nan2008, DefaultFloat)
900 .
Either(BigEndian, LittleEndian)
906 std::vector<std::string> Dirs({
"/include"});
909 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
911 Dirs.push_back(
"/../../../../mips-linux-gnu/libc/usr/include");
923 .includeSuffix(
"/64")
930 DebianMipsMultilibs =
936 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
937 if (CSMipsMultilibs.
size() < DebianMipsMultilibs.size())
938 std::iter_swap(Candidates, Candidates + 1);
941 if (Candidate == &DebianMipsMultilibs)
952 FilterNonExistent &NonExistent,
964 Multilib(
"/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
965 Multilib(
"/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
972 Multilib(
"/32/mips-r1",
"",
"/mips-r1").flag(
"+march=mips32"),
973 Multilib(
"/32/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
974 Multilib(
"/32/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
978 if (VFS.
exists(Path +
"/mips-r6"))
979 MS = &AndroidMipselMultilibs;
980 else if (VFS.
exists(Path +
"/32"))
981 MS = &AndroidMips64elMultilibs;
990 FilterNonExistent &NonExistent,
999 .flag(
"+march=mips32r2");
1001 auto MArchMipselR2 =
makeMultilib(
"/mipsel-r2-hard-musl")
1004 .
flag(
"+march=mips32r2");
1010 return std::vector<std::string>(
1011 {
"/../sysroot" + M.
osSuffix() +
"/usr/include"});
1022 FilterNonExistent &NonExistent,
1030 .
flag(
"-mmicromips")
1031 .
flag(
"+march=mips32");
1036 .
flag(
"+mmicromips");
1041 .
flag(
"+march=mips64r2");
1049 .
flag(
"-mmicromips")
1050 .
flag(
"+march=mips32r2");
1067 MtiMipsMultilibsV1 =
1069 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1081 .
Either(BigEndian, LittleEndian)
1087 std::vector<std::string> Dirs({
"/include"});
1089 Dirs.push_back(
"/../../../../sysroot/uclibc/usr/include");
1091 Dirs.push_back(
"/../../../../sysroot/usr/include");
1101 .
flag(
"-msoft-float")
1106 .
flag(
"+msoft-float")
1107 .
flag(
"-mnan=2008");
1110 .
flag(
"-msoft-float")
1115 .
flag(
"+msoft-float")
1117 .
flag(
"-mmicromips");
1120 .
flag(
"-msoft-float")
1123 auto ElHardNan =
makeMultilib(
"/mipsel-r2-hard-nan2008")
1125 .
flag(
"-msoft-float")
1128 .
flag(
"-mmicromips");
1129 auto BeHardNanUclibc =
makeMultilib(
"/mips-r2-hard-nan2008-uclibc")
1131 .
flag(
"-msoft-float")
1134 auto ElHardNanUclibc =
makeMultilib(
"/mipsel-r2-hard-nan2008-uclibc")
1136 .
flag(
"-msoft-float")
1139 auto BeHardUclibc =
makeMultilib(
"/mips-r2-hard-uclibc")
1141 .
flag(
"-msoft-float")
1144 auto ElHardUclibc =
makeMultilib(
"/mipsel-r2-hard-uclibc")
1146 .
flag(
"-msoft-float")
1149 auto ElMicroHardNan =
makeMultilib(
"/micromipsel-r2-hard-nan2008")
1151 .
flag(
"-msoft-float")
1153 .
flag(
"+mmicromips");
1154 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r2-soft")
1156 .
flag(
"+msoft-float")
1158 .
flag(
"+mmicromips");
1167 MtiMipsMultilibsV2 =
1169 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1170 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1171 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1172 .Either(O32, N32, N64)
1175 return std::vector<std::string>({
"/../../../../sysroot" +
1177 "/../usr/include"});
1179 .setFilePathsCallback([](
const Multilib &M) {
1180 return std::vector<std::string>(
1181 {
"/../../../../mips-mti-linux-gnu/lib" + M.
gccSuffix()});
1184 for (
auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1194 FilterNonExistent &NonExistent,
1210 .
Maybe(LittleEndian)
1213 return std::vector<std::string>(
1214 {
"/include",
"/../../../../sysroot/usr/include"});
1223 .
flag(
"-msoft-float")
1224 .
flag(
"-mmicromips");
1227 .
flag(
"+msoft-float")
1228 .
flag(
"-mmicromips");
1231 .
flag(
"-msoft-float")
1232 .
flag(
"-mmicromips");
1235 .
flag(
"+msoft-float")
1236 .
flag(
"-mmicromips");
1239 .
flag(
"-msoft-float")
1240 .
flag(
"+mmicromips");
1243 .
flag(
"+msoft-float")
1244 .
flag(
"+mmicromips");
1245 auto ElMicroHard =
makeMultilib(
"/micromipsel-r6-hard")
1247 .
flag(
"-msoft-float")
1248 .
flag(
"+mmicromips");
1249 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r6-soft")
1251 .
flag(
"+msoft-float")
1252 .
flag(
"+mmicromips");
1263 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1264 ElMicroHard, ElMicroSoft})
1265 .Either(O32, N32, N64)
1268 return std::vector<std::string>({
"/../../../../sysroot" +
1270 "/../usr/include"});
1272 .setFilePathsCallback([](
const Multilib &M) {
1273 return std::vector<std::string>(
1274 {
"/../../../../mips-img-linux-gnu/lib" + M.
gccSuffix()});
1277 for (
auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1287 const llvm::Triple &TargetTriple,
1288 StringRef Path,
const ArgList &Args,
1290 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1296 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1304 CPUName ==
"mips32r5" || CPUName ==
"p5600",
1305 "march=mips32r2", Flags);
1309 CPUName ==
"mips64r5" || CPUName ==
"octeon",
1310 "march=mips64r2", Flags);
1323 if (TargetTriple.isAndroid())
1327 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1328 TargetTriple.getOS() == llvm::Triple::Linux &&
1329 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1332 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1333 TargetTriple.getOS() == llvm::Triple::Linux &&
1334 TargetTriple.isGNUEnvironment())
1337 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1338 TargetTriple.getOS() == llvm::Triple::Linux &&
1339 TargetTriple.isGNUEnvironment())
1359 const llvm::Triple &TargetTriple,
1360 StringRef Path,
const ArgList &Args,
1363 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1365 .
flag(
"+march=armv7-a")
1368 .
flag(
"-march=armv7-a")
1371 .
flag(
"+march=armv7-a")
1374 .
flag(
"-march=armv7-a")
1378 .
Either(ThumbMultilib, ArmV7Multilib,
1379 ArmV7ThumbMultilib, DefaultMultilib)
1383 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1384 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1385 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1386 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1387 bool IsThumbMode = IsThumbArch ||
1388 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb,
false) ||
1389 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1390 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1391 (llvm::ARM::parseArchVersion(Arch) == 7 ||
1392 (IsArmArch && Arch ==
"" && IsV7SubArch));
1401 const llvm::Triple &TargetTriple, StringRef Path,
1404 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1415 .
Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1416 .FilterOut(NonExistent);
1419 bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1436 const llvm::Triple &TargetTriple,
1437 StringRef Path,
const ArgList &Args,
1438 bool NeedsBiarchSuffix,
1449 StringRef Suff64 =
"/64";
1451 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1452 switch (TargetTriple.getArch()) {
1453 case llvm::Triple::x86:
1454 case llvm::Triple::x86_64:
1457 case llvm::Triple::sparc:
1458 case llvm::Triple::sparcv9:
1459 Suff64 =
"/sparcv9";
1468 .includeSuffix(Suff64)
1474 .includeSuffix(
"/32")
1480 .includeSuffix(
"/x32")
1486 FilterNonExistent NonExistent(
1487 Path, TargetTriple.isOSIAMCU() ?
"/libgcc.a" :
"/crtbegin.o", D.
getVFS());
1492 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
1493 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1495 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1497 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1500 if (TargetTriple.isArch32Bit())
1501 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1503 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1505 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1510 else if (Want == WANT64)
1512 else if (Want == WANTX32)
1546 StringRef RHSPatchSuffix)
const {
1547 if (Major != RHSMajor)
1548 return Major < RHSMajor;
1549 if (Minor != RHSMinor)
1550 return Minor < RHSMinor;
1551 if (Patch != RHSPatch) {
1560 return Patch < RHSPatch;
1562 if (PatchSuffix != RHSPatchSuffix) {
1564 if (RHSPatchSuffix.empty())
1566 if (PatchSuffix.empty())
1570 return PatchSuffix < RHSPatchSuffix;
1582 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1583 std::pair<StringRef, StringRef>
First = VersionText.split(
'.');
1584 std::pair<StringRef, StringRef> Second = First.second.split(
'.');
1586 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1587 if (First.first.getAsInteger(10, GoodVersion.
Major) || GoodVersion.
Major < 0)
1589 GoodVersion.
MajorStr = First.first.str();
1590 if (First.second.empty())
1592 StringRef MinorStr = Second.first;
1593 if (Second.second.empty()) {
1594 if (
size_t EndNumber = MinorStr.find_first_not_of(
"0123456789")) {
1595 GoodVersion.
PatchSuffix = MinorStr.substr(EndNumber);
1596 MinorStr = MinorStr.slice(0, EndNumber);
1599 if (MinorStr.getAsInteger(10, GoodVersion.
Minor) || GoodVersion.
Minor < 0)
1601 GoodVersion.
MinorStr = MinorStr.str();
1614 StringRef PatchText = Second.second;
1615 if (!PatchText.empty()) {
1616 if (
size_t EndNumber = PatchText.find_first_not_of(
"0123456789")) {
1618 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.
Patch) ||
1619 GoodVersion.
Patch < 0)
1621 GoodVersion.
PatchSuffix = PatchText.substr(EndNumber);
1629 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
1631 return A->getValue();
1632 return GCC_INSTALL_PREFIX;
1645 const llvm::Triple &TargetTriple,
const ArgList &Args,
1647 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1648 ? TargetTriple.get64BitArchVariant()
1649 : TargetTriple.get32BitArchVariant();
1655 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1656 CandidateTripleAliases, CandidateBiarchLibDirs,
1657 CandidateBiarchTripleAliases);
1664 if (GCCToolchainDir !=
"") {
1665 if (GCCToolchainDir.back() ==
'/')
1666 GCCToolchainDir = GCCToolchainDir.drop_back();
1668 Prefixes.push_back(GCCToolchainDir);
1672 Prefixes.push_back(D.
SysRoot);
1673 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
1683 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
1691 if (GCCToolchainDir ==
"" || GCCToolchainDir == D.
SysRoot +
"/usr") {
1698 GentooTestTriples.push_back(TargetTriple.str());
1700 GentooTestTriples.append(ExtraTripleAliases.begin(),
1701 ExtraTripleAliases.end());
1702 GentooTestTriples.append(CandidateTripleAliases.begin(),
1703 CandidateTripleAliases.end());
1704 if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
1705 CandidateBiarchTripleAliases))
1711 Version = GCCVersion::Parse(
"0.0.0");
1712 for (
const std::string &Prefix : Prefixes) {
1715 for (StringRef Suffix : CandidateLibDirs) {
1716 const std::string LibDir = Prefix + Suffix.str();
1720 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, TargetTriple.str());
1722 for (StringRef Candidate : ExtraTripleAliases)
1723 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1724 for (StringRef Candidate : CandidateTripleAliases)
1725 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1727 for (StringRef Suffix : CandidateBiarchLibDirs) {
1728 const std::string LibDir = Prefix + Suffix.str();
1731 for (StringRef Candidate : CandidateBiarchTripleAliases)
1732 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1739 for (
const auto &InstallPath : CandidateGCCInstallPaths)
1740 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
1742 if (!GCCInstallPath.empty())
1743 OS <<
"Selected GCC installation: " << GCCInstallPath <<
"\n";
1745 for (
const auto &
Multilib : Multilibs)
1746 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
1748 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
1749 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
1753 if (BiarchSibling.hasValue()) {
1754 M = BiarchSibling.getValue();
1760 void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
1762 StringRef SysRoot) {
1763 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1770 std::string PrefixDir = SysRoot.str() +
"/usr/gcc";
1773 !EC && LI != LE; LI = LI.
increment(EC)) {
1774 StringRef VersionText = llvm::sys::path::filename(LI->getName());
1775 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1778 if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
1781 std::string CandidatePrefix = PrefixDir +
"/" + VersionText.str();
1782 std::string CandidateLibPath = CandidatePrefix +
"/lib/gcc";
1786 Prefixes.push_back(CandidatePrefix);
1792 if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux) {
1794 Prefixes.push_back(
"/opt/rh/devtoolset-7/root/usr");
1795 Prefixes.push_back(
"/opt/rh/devtoolset-6/root/usr");
1796 Prefixes.push_back(
"/opt/rh/devtoolset-4/root/usr");
1797 Prefixes.push_back(
"/opt/rh/devtoolset-3/root/usr");
1798 Prefixes.push_back(
"/opt/rh/devtoolset-2/root/usr");
1800 Prefixes.push_back(SysRoot.str() +
"/usr");
1803 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1804 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
1812 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
1813 static const char *
const AArch64Triples[] = {
1814 "aarch64-none-linux-gnu",
"aarch64-linux-gnu",
"aarch64-redhat-linux",
1815 "aarch64-suse-linux"};
1816 static const char *
const AArch64beLibDirs[] = {
"/lib"};
1817 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu",
1818 "aarch64_be-linux-gnu"};
1820 static const char *
const ARMLibDirs[] = {
"/lib"};
1821 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi"};
1822 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
1823 "armv7hl-redhat-linux-gnueabi",
1824 "armv6hl-suse-linux-gnueabi",
1825 "armv7hl-suse-linux-gnueabi"};
1826 static const char *
const ARMebLibDirs[] = {
"/lib"};
1827 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi"};
1828 static const char *
const ARMebHFTriples[] = {
1829 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
1831 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
1832 static const char *
const X86_64Triples[] = {
1833 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
1834 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
1835 "x86_64-redhat-linux",
"x86_64-suse-linux",
1836 "x86_64-manbo-linux-gnu",
"x86_64-linux-gnu",
1837 "x86_64-slackware-linux",
"x86_64-unknown-linux",
1838 "x86_64-amazon-linux"};
1839 static const char *
const X32LibDirs[] = {
"/libx32"};
1840 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
1841 static const char *
const X86Triples[] = {
1842 "i686-linux-gnu",
"i686-pc-linux-gnu",
"i486-linux-gnu",
1843 "i386-linux-gnu",
"i386-redhat-linux6E",
"i686-redhat-linux",
1844 "i586-redhat-linux",
"i386-redhat-linux",
"i586-suse-linux",
1845 "i486-slackware-linux",
"i686-montavista-linux",
"i586-linux-gnu"};
1847 static const char *
const MIPSLibDirs[] = {
"/lib"};
1848 static const char *
const MIPSTriples[] = {
"mips-linux-gnu",
"mips-mti-linux",
1849 "mips-mti-linux-gnu",
1850 "mips-img-linux-gnu"};
1851 static const char *
const MIPSELLibDirs[] = {
"/lib"};
1852 static const char *
const MIPSELTriples[] = {
"mipsel-linux-gnu",
1853 "mips-img-linux-gnu"};
1855 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
1856 static const char *
const MIPS64Triples[] = {
1857 "mips64-linux-gnu",
"mips-mti-linux-gnu",
"mips-img-linux-gnu",
1858 "mips64-linux-gnuabi64"};
1859 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
1860 static const char *
const MIPS64ELTriples[] = {
1861 "mips64el-linux-gnu",
"mips-mti-linux-gnu",
"mips-img-linux-gnu",
1862 "mips64el-linux-gnuabi64"};
1865 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
1866 static const char *
const PPCTriples[] = {
1867 "powerpc-linux-gnu",
"powerpc-unknown-linux-gnu",
"powerpc-linux-gnuspe",
1868 "powerpc-suse-linux",
"powerpc-montavista-linuxspe"};
1869 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
1870 static const char *
const PPC64Triples[] = {
1871 "powerpc64-linux-gnu",
"powerpc64-unknown-linux-gnu",
1872 "powerpc64-suse-linux",
"ppc64-redhat-linux"};
1873 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
1874 static const char *
const PPC64LETriples[] = {
1875 "powerpc64le-linux-gnu",
"powerpc64le-unknown-linux-gnu",
1876 "powerpc64le-suse-linux",
"ppc64le-redhat-linux"};
1878 static const char *
const RISCV32LibDirs[] = {
"/lib",
"/lib32"};
1879 static const char *
const RISCVTriples[] = {
"riscv32-unknown-linux-gnu",
1880 "riscv64-unknown-linux-gnu",
1881 "riscv32-unknown-elf"};
1883 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
1884 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
1885 "sparcv8-linux-gnu"};
1886 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
1887 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
1888 "sparcv9-linux-gnu"};
1890 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
1891 static const char *
const SystemZTriples[] = {
1892 "s390x-linux-gnu",
"s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
1893 "s390x-suse-linux",
"s390x-redhat-linux"};
1899 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1900 static const char *
const SolarisLibDirs[] = {
"/lib"};
1901 static const char *
const SolarisSparcV8Triples[] = {
1902 "sparc-sun-solaris2.11",
"sparc-sun-solaris2.12"};
1903 static const char *
const SolarisSparcV9Triples[] = {
1904 "sparcv9-sun-solaris2.11",
"sparcv9-sun-solaris2.12"};
1905 static const char *
const SolarisX86Triples[] = {
"i386-pc-solaris2.11",
1906 "i386-pc-solaris2.12"};
1907 static const char *
const SolarisX86_64Triples[] = {
"x86_64-pc-solaris2.11",
1908 "x86_64-pc-solaris2.12"};
1909 LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
1910 BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
1911 switch (TargetTriple.getArch()) {
1912 case llvm::Triple::x86:
1913 TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
1914 BiarchTripleAliases.append(begin(SolarisX86_64Triples),
1915 end(SolarisX86_64Triples));
1917 case llvm::Triple::x86_64:
1918 TripleAliases.append(begin(SolarisX86_64Triples),
1919 end(SolarisX86_64Triples));
1920 BiarchTripleAliases.append(begin(SolarisX86Triples),
1921 end(SolarisX86Triples));
1923 case llvm::Triple::sparc:
1924 TripleAliases.append(begin(SolarisSparcV8Triples),
1925 end(SolarisSparcV8Triples));
1926 BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
1927 end(SolarisSparcV9Triples));
1929 case llvm::Triple::sparcv9:
1930 TripleAliases.append(begin(SolarisSparcV9Triples),
1931 end(SolarisSparcV9Triples));
1932 BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
1933 end(SolarisSparcV8Triples));
1942 if (TargetTriple.isAndroid()) {
1943 static const char *
const AArch64AndroidTriples[] = {
1944 "aarch64-linux-android"};
1945 static const char *
const ARMAndroidTriples[] = {
"arm-linux-androideabi"};
1946 static const char *
const MIPSELAndroidTriples[] = {
"mipsel-linux-android"};
1947 static const char *
const MIPS64ELAndroidTriples[] = {
1948 "mips64el-linux-android"};
1949 static const char *
const X86AndroidTriples[] = {
"i686-linux-android"};
1950 static const char *
const X86_64AndroidTriples[] = {
"x86_64-linux-android"};
1952 switch (TargetTriple.getArch()) {
1953 case llvm::Triple::aarch64:
1954 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1955 TripleAliases.append(begin(AArch64AndroidTriples),
1956 end(AArch64AndroidTriples));
1958 case llvm::Triple::arm:
1959 case llvm::Triple::thumb:
1960 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
1961 TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
1963 case llvm::Triple::mipsel:
1964 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1965 TripleAliases.append(begin(MIPSELAndroidTriples),
1966 end(MIPSELAndroidTriples));
1967 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1968 BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples),
1969 end(MIPS64ELAndroidTriples));
1971 case llvm::Triple::mips64el:
1972 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1973 TripleAliases.append(begin(MIPS64ELAndroidTriples),
1974 end(MIPS64ELAndroidTriples));
1975 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1976 BiarchTripleAliases.append(begin(MIPSELAndroidTriples),
1977 end(MIPSELAndroidTriples));
1979 case llvm::Triple::x86_64:
1980 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1981 TripleAliases.append(begin(X86_64AndroidTriples),
1982 end(X86_64AndroidTriples));
1983 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1984 BiarchTripleAliases.append(begin(X86AndroidTriples),
1985 end(X86AndroidTriples));
1987 case llvm::Triple::x86:
1988 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1989 TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
1990 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1991 BiarchTripleAliases.append(begin(X86_64AndroidTriples),
1992 end(X86_64AndroidTriples));
2001 switch (TargetTriple.getArch()) {
2002 case llvm::Triple::aarch64:
2003 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2004 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2005 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2006 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2008 case llvm::Triple::aarch64_be:
2009 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2010 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2011 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2012 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2014 case llvm::Triple::arm:
2015 case llvm::Triple::thumb:
2016 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2017 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2018 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2020 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2023 case llvm::Triple::armeb:
2024 case llvm::Triple::thumbeb:
2025 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2026 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2027 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2029 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2032 case llvm::Triple::x86_64:
2033 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2034 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2037 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
2038 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2039 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2041 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2042 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2045 case llvm::Triple::x86:
2046 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2049 if (!TargetTriple.isOSIAMCU()) {
2050 TripleAliases.append(begin(X86Triples), end(X86Triples));
2051 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2052 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2055 case llvm::Triple::mips:
2056 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2057 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2058 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2059 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2061 case llvm::Triple::mipsel:
2062 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2063 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2064 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2065 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2066 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2068 case llvm::Triple::mips64:
2069 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2070 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2071 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2072 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2074 case llvm::Triple::mips64el:
2075 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2076 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2077 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2078 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2079 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2081 case llvm::Triple::ppc:
2082 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2083 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2084 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2085 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2087 case llvm::Triple::ppc64:
2088 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2089 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2090 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2091 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2093 case llvm::Triple::ppc64le:
2094 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2095 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2097 case llvm::Triple::riscv32:
2098 LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2099 BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2100 TripleAliases.append(begin(RISCVTriples), end(RISCVTriples));
2101 BiarchTripleAliases.append(begin(RISCVTriples), end(RISCVTriples));
2103 case llvm::Triple::sparc:
2104 case llvm::Triple::sparcel:
2105 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2106 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2107 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2108 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2110 case llvm::Triple::sparcv9:
2111 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2112 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2113 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2114 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2116 case llvm::Triple::systemz:
2117 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2118 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2128 TripleAliases.push_back(TargetTriple.str());
2131 if (TargetTriple.str() != BiarchTriple.str())
2132 BiarchTripleAliases.push_back(BiarchTriple.str());
2135 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2136 const llvm::Triple &TargetTriple,
const ArgList &Args,
2137 StringRef Path,
bool NeedsBiarchSuffix) {
2138 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2147 }
else if (TargetTriple.isMIPS()) {
2150 }
else if (
isRISCV(TargetArch)) {
2153 NeedsBiarchSuffix, Detected)) {
2164 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2165 const llvm::Triple &TargetTriple,
const ArgList &Args,
2166 const std::string &LibDir, StringRef CandidateTriple,
2167 bool NeedsBiarchSuffix) {
2168 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2171 struct GCCLibSuffix {
2173 std::string LibSuffix;
2176 StringRef ReversePath;
2181 {
"gcc/" + CandidateTriple.str(),
"../..",
true},
2184 {
"gcc-cross/" + CandidateTriple.str(),
"../..",
2185 TargetTriple.getOS() != llvm::Triple::Solaris},
2191 {CandidateTriple.str(),
"..",
2192 TargetTriple.getVendor() == llvm::Triple::Freescale ||
2193 TargetTriple.getVendor() == llvm::Triple::OpenEmbedded},
2198 {CandidateTriple.str() +
"/gcc/" + CandidateTriple.str(),
"../../..",
2199 TargetTriple.getOS() != llvm::Triple::Solaris},
2205 {
"i386-linux-gnu/gcc/" + CandidateTriple.str(),
"../../..",
2206 (TargetArch == llvm::Triple::x86 &&
2207 TargetTriple.getOS() != llvm::Triple::Solaris)}};
2213 StringRef LibSuffix = Suffix.LibSuffix;
2218 !EC && LI != LE; LI = LI.
increment(EC)) {
2219 StringRef VersionText = llvm::sys::path::filename(LI->getName());
2220 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2221 if (CandidateVersion.Major != -1)
2222 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2224 if (CandidateVersion.isOlderThan(4, 1, 1))
2226 if (CandidateVersion <= Version)
2229 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->getName(),
2233 Version = CandidateVersion;
2234 GCCTriple.setTriple(CandidateTriple);
2238 GCCInstallPath = (LibDir +
"/" + LibSuffix +
"/" + VersionText).str();
2239 GCCParentLibPath = (GCCInstallPath +
"/../" + Suffix.ReversePath).str();
2245 bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
2246 const llvm::Triple &TargetTriple,
const ArgList &Args,
2249 for (StringRef CandidateTriple : CandidateTriples) {
2250 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
2254 for (StringRef CandidateTriple : CandidateBiarchTriples) {
2255 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple,
true))
2261 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2262 const llvm::Triple &TargetTriple,
const ArgList &Args,
2263 StringRef CandidateTriple,
bool NeedsBiarchSuffix) {
2264 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
2266 CandidateTriple.str());
2269 File.get()->getBuffer().split(Lines,
"\n");
2270 for (StringRef
Line : Lines) {
2273 if (!
Line.consume_front(
"CURRENT="))
2276 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
2279 std::pair<StringRef, StringRef> ActiveVersion =
Line.rsplit(
'-');
2292 ConfigFile.get()->getBuffer().split(ConfigLines,
"\n");
2293 for (StringRef ConfLine : ConfigLines) {
2294 ConfLine = ConfLine.trim();
2295 if (ConfLine.consume_front(
"LDPATH=")) {
2297 ConfLine.consume_back(
"\"");
2298 ConfLine.consume_front(
"\"");
2300 ConfLine.split(GentooScanPaths,
':', -1,
false);
2305 std::string basePath =
"/usr/lib/gcc/" + ActiveVersion.first.str() +
"/" 2306 + ActiveVersion.second.str();
2307 GentooScanPaths.push_back(StringRef(basePath));
2310 for (
const auto &GentooScanPath : GentooScanPaths) {
2311 std::string GentooPath = D.
SysRoot + std::string(GentooScanPath);
2313 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2317 Version = GCCVersion::Parse(ActiveVersion.second);
2318 GCCInstallPath = GentooPath;
2319 GCCParentLibPath = GentooPath + std::string(
"/../../..");
2320 GCCTriple.setTriple(ActiveVersion.first);
2332 const ArgList &Args)
2333 :
ToolChain(D, Triple, Args), GCCInstallation(D),
2334 CudaInstallation(D, Triple, Args) {
2347 return Preprocess.get();
2351 return Compile.get();
2370 return getArch() == llvm::Triple::x86_64;
2375 case llvm::Triple::x86_64:
2377 case llvm::Triple::ppc64:
2378 case llvm::Triple::ppc64le:
2380 case llvm::Triple::mips64:
2381 case llvm::Triple::mips64el:
2396 case llvm::Triple::x86:
2397 case llvm::Triple::x86_64:
2398 case llvm::Triple::aarch64:
2399 case llvm::Triple::aarch64_be:
2400 case llvm::Triple::arm:
2401 case llvm::Triple::armeb:
2402 case llvm::Triple::avr:
2403 case llvm::Triple::bpfel:
2404 case llvm::Triple::bpfeb:
2405 case llvm::Triple::thumb:
2406 case llvm::Triple::thumbeb:
2407 case llvm::Triple::ppc:
2408 case llvm::Triple::ppc64:
2409 case llvm::Triple::ppc64le:
2410 case llvm::Triple::riscv32:
2411 case llvm::Triple::riscv64:
2412 case llvm::Triple::systemz:
2413 case llvm::Triple::mips:
2414 case llvm::Triple::mipsel:
2416 case llvm::Triple::mips64:
2417 case llvm::Triple::mips64el:
2421 if (
getTriple().getEnvironment() == llvm::Triple::GNUABI64 ||
2433 ArgStringList &CC1Args)
const {
2434 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2435 DriverArgs.hasArg(options::OPT_nostdincxx))
2451 llvm::opt::ArgStringList &CC1Args)
const {
2454 getDriver().SysRoot +
"/usr/include/c++/v1");
2459 llvm::opt::ArgStringList &CC1Args)
const {
2466 Twine
Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2467 StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2468 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2469 if (!
getVFS().exists(Base + Suffix))
2477 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2478 getVFS().
exists(Base + Suffix +
"/" + GCCTriple + IncludeSuffix)) {
2480 Base + Suffix +
"/" + GCCTriple + IncludeSuffix);
2488 Base +
"/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2490 Base +
"/" + TargetMultiarchTriple + Suffix);
2497 llvm::opt::DerivedArgList *
2506 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2511 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_shared));
2512 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_fPIC));
2516 for (
auto *A : Args) {
2521 case options::OPT_shared:
2522 case options::OPT_dynamic:
2523 case options::OPT_static:
2524 case options::OPT_fPIC:
2525 case options::OPT_fno_PIC:
2526 case options::OPT_fpic:
2527 case options::OPT_fno_pic:
2528 case options::OPT_fPIE:
2529 case options::OPT_fno_PIE:
2530 case options::OPT_fpie:
2531 case options::OPT_fno_pie:
2540 void Generic_ELF::anchor() {}
2543 ArgStringList &CC1Args,
2546 bool UseInitArrayDefault =
2547 getTriple().getArch() == llvm::Triple::aarch64 ||
2548 getTriple().getArch() == llvm::Triple::aarch64_be ||
2549 (
getTriple().getOS() == llvm::Triple::FreeBSD &&
2550 getTriple().getOSMajorVersion() >= 12) ||
2551 (
getTriple().getOS() == llvm::Triple::Linux &&
2554 getTriple().getOS() == llvm::Triple::NaCl ||
2555 (
getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2557 getTriple().getOS() == llvm::Triple::Solaris;
2559 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2560 options::OPT_fno_use_init_array, UseInitArrayDefault))
2561 CC1Args.push_back(
"-fuse-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 bool getPIE(const ArgList &Args, const toolchains::Linux &ToolChain)
bool isDefault() const
Check whether the default is selected.
llvm::Optional< Multilib > BiarchSibling
On Biarch systems, this corresponds to the default multilib when targeting the non-default multilib...
static llvm::StringRef getGCCToolchainDir(const ArgList &Args)
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
static bool findMipsAndroidMultilibs(vfs::FileSystem &VFS, StringRef Path, const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
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
virtual directory_iterator dir_begin(const Twine &Dir, std::error_code &EC)=0
Get a directory_iterator for Dir.
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.
The virtual file system interface.
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.
directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
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...
static bool isMips16(const ArgList &Args)
static bool isSoftFloatABI(const ArgList &Args)
static void addMultilibFlag(bool Enabled, const char *const Flag, std::vector< std::string > &Flags)
Flag must be a flag accepted by the driver with its leading '-' removed,
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)
vfs::FileSystem & getVFS() const
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 isArmOrThumbArch(llvm::Triple::ArchType Arch)
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 isRISCV(llvm::Triple::ArchType Arch)
const std::string & getCCCGenericGCCName() const
Name to use when invoking gcc/g++.
std::string SysRoot
sysroot, if present
Defines the virtual file system interface vfs::FileSystem.
static bool findMipsCsMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
bool exists(const Twine &Path)
Check whether a file exists. Provided for convenience.
Compilation - A set of tasks to perform for a single driver invocation.
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const Twine &Name, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
This is a convenience method that opens a file, gets its content and then closes the file...
bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const llvm::opt::ArgList &Args, DetectedMultilibs &Result)
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
MultilibSet & FilterOut(FilterCallback F)
Filter out some subset of the Multilibs using a user defined callback.
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.