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(llvm::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);
569 if (WantPthread && !isAndroid)
570 CmdArgs.push_back(
"-lpthread");
572 if (Args.hasArg(options::OPT_fsplit_stack))
573 CmdArgs.push_back(
"--wrap=pthread_create");
575 if (!Args.hasArg(options::OPT_nolibc))
576 CmdArgs.push_back(
"-lc");
580 CmdArgs.push_back(
"-lgloss");
582 if (IsStatic || IsStaticPIE)
583 CmdArgs.push_back(
"--end-group");
589 CmdArgs.push_back(
"--as-needed");
590 CmdArgs.push_back(
"-lsoftfp");
591 CmdArgs.push_back(
"--no-as-needed");
595 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
596 if (HasCRTBeginEndFiles) {
602 if (ToolChain.
getVFS().exists(crtend))
607 if (Args.hasArg(options::OPT_shared))
608 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
609 else if (IsPIE || IsStaticPIE)
610 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
612 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
615 CmdArgs.push_back(Args.MakeArgString(P));
618 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
629 const char *Exec = Args.MakeArgString(ToolChain.
GetLinkerPath());
630 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
638 const char *LinkingOutput)
const {
639 const auto &D = getToolChain().getDriver();
643 ArgStringList CmdArgs;
645 llvm::Reloc::Model RelocationModel;
648 std::tie(RelocationModel, PICLevel, IsPIE) =
651 if (
const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
652 if (A->getOption().getID() == options::OPT_gz) {
653 CmdArgs.push_back(
"--compress-debug-sections");
655 StringRef
Value = A->getValue();
656 if (Value ==
"none" || Value ==
"zlib" || Value ==
"zlib-gnu") {
658 Args.MakeArgString(
"--compress-debug-sections=" + Twine(Value)));
660 D.Diag(diag::err_drv_unsupported_option_argument)
661 << A->getOption().getName() <<
Value;
666 if (getToolChain().isNoExecStackDefault()) {
667 CmdArgs.push_back(
"--noexecstack");
670 switch (getToolChain().getArch()) {
675 case llvm::Triple::x86:
676 CmdArgs.push_back(
"--32");
678 case llvm::Triple::x86_64:
679 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
680 CmdArgs.push_back(
"--x32");
682 CmdArgs.push_back(
"--64");
684 case llvm::Triple::ppc: {
685 CmdArgs.push_back(
"-a32");
686 CmdArgs.push_back(
"-mppc");
691 case llvm::Triple::ppc64: {
692 CmdArgs.push_back(
"-a64");
693 CmdArgs.push_back(
"-mppc64");
698 case llvm::Triple::ppc64le: {
699 CmdArgs.push_back(
"-a64");
700 CmdArgs.push_back(
"-mppc64");
701 CmdArgs.push_back(
"-mlittle-endian");
706 case llvm::Triple::riscv32:
707 case llvm::Triple::riscv64: {
709 CmdArgs.push_back(
"-mabi");
710 CmdArgs.push_back(ABIName.data());
711 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
712 StringRef MArch = A->getValue();
713 CmdArgs.push_back(
"-march");
714 CmdArgs.push_back(MArch.data());
718 case llvm::Triple::sparc:
719 case llvm::Triple::sparcel: {
720 CmdArgs.push_back(
"-32");
721 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
727 case llvm::Triple::sparcv9: {
728 CmdArgs.push_back(
"-64");
729 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
735 case llvm::Triple::arm:
736 case llvm::Triple::armeb:
737 case llvm::Triple::thumb:
738 case llvm::Triple::thumbeb: {
739 const llvm::Triple &Triple2 = getToolChain().getTriple();
741 switch (Triple2.getSubArch()) {
742 case llvm::Triple::ARMSubArch_v7:
743 CmdArgs.push_back(
"-mfpu=neon");
745 case llvm::Triple::ARMSubArch_v8:
746 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
753 case arm::FloatABI::Invalid: llvm_unreachable(
"must have an ABI!");
754 case arm::FloatABI::Soft:
755 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=soft"));
757 case arm::FloatABI::SoftFP:
758 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=softfp"));
760 case arm::FloatABI::Hard:
761 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=hard"));
765 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
768 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
771 case llvm::Triple::aarch64:
772 case llvm::Triple::aarch64_be: {
774 getToolChain().getArch() == llvm::Triple::aarch64_be ?
"-EB" :
"-EL");
775 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
780 case llvm::Triple::mips:
781 case llvm::Triple::mipsel:
782 case llvm::Triple::mips64:
783 case llvm::Triple::mips64el: {
789 CmdArgs.push_back(
"-march");
790 CmdArgs.push_back(CPUName.data());
792 CmdArgs.push_back(
"-mabi");
793 CmdArgs.push_back(ABIName.data());
797 if (RelocationModel == llvm::Reloc::Static)
798 CmdArgs.push_back(
"-mno-shared");
802 if (ABIName !=
"64" && !Args.hasArg(options::OPT_mno_abicalls))
803 CmdArgs.push_back(
"-call_nonpic");
805 if (getToolChain().getTriple().isLittleEndian())
806 CmdArgs.push_back(
"-EL");
808 CmdArgs.push_back(
"-EB");
810 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
811 if (StringRef(A->getValue()) ==
"2008")
812 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
816 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
817 options::OPT_mfp64)) {
819 A->render(Args, CmdArgs);
821 Args, getToolChain().getTriple(), CPUName, ABIName,
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 Args.AddAllArgs(CmdArgs, options::OPT_I);
872 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
874 CmdArgs.push_back(
"-o");
877 for (
const auto &II : Inputs)
878 CmdArgs.push_back(II.getFilename());
880 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
881 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
886 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
887 getToolChain().getTriple().isOSLinux())
894 class FilterNonExistent {
895 StringRef
Base, File;
896 llvm::vfs::FileSystem &VFS;
899 FilterNonExistent(StringRef Base, StringRef File, llvm::vfs::FileSystem &VFS)
900 : Base(Base), File(File), VFS(VFS) {}
901 bool operator()(
const Multilib &M) {
902 return !VFS.exists(Base + M.
gccSuffix() + File);
908 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
909 options::OPT_mfloat_abi_EQ);
913 return A->getOption().matches(options::OPT_msoft_float) ||
914 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
915 A->getValue() == StringRef(
"soft"));
919 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
922 static bool isMipsEL(llvm::Triple::ArchType Arch) {
923 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
927 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
928 return A && A->getOption().matches(options::OPT_mips16);
932 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
933 return A && A->getOption().matches(options::OPT_mmicromips);
936 static bool isMSP430(llvm::Triple::ArchType Arch) {
937 return Arch == llvm::Triple::msp430;
941 return Multilib(commonSuffix, commonSuffix, commonSuffix);
945 FilterNonExistent &NonExistent,
952 auto MArchMicroMips =
973 .includeSuffix(
"/64")
980 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
982 .
Either(SoftFloat, Nan2008, DefaultFloat)
985 .
Either(BigEndian, LittleEndian)
991 std::vector<std::string> Dirs({
"/include"});
994 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
996 Dirs.push_back(
"/../../../../mips-linux-gnu/libc/usr/include");
1008 .includeSuffix(
"/64")
1015 DebianMipsMultilibs =
1021 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1022 if (CSMipsMultilibs.
size() < DebianMipsMultilibs.size())
1023 std::iter_swap(Candidates, Candidates + 1);
1026 if (Candidate == &DebianMipsMultilibs)
1037 FilterNonExistent &NonExistent,
1049 Multilib(
"/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
1050 Multilib(
"/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
1056 Multilib().flag(
"+march=mips64r6"),
1057 Multilib(
"/32/mips-r1",
"",
"/mips-r1").flag(
"+march=mips32"),
1058 Multilib(
"/32/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
1059 Multilib(
"/32/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
1063 if (VFS.exists(Path +
"/mips-r6"))
1064 MS = &AndroidMipselMultilibs;
1065 else if (VFS.exists(Path +
"/32"))
1066 MS = &AndroidMips64elMultilibs;
1075 FilterNonExistent &NonExistent,
1084 .flag(
"+march=mips32r2");
1086 auto MArchMipselR2 =
makeMultilib(
"/mipsel-r2-hard-musl")
1089 .
flag(
"+march=mips32r2");
1095 return std::vector<std::string>(
1096 {
"/../sysroot" + M.
osSuffix() +
"/usr/include"});
1107 FilterNonExistent &NonExistent,
1115 .
flag(
"-mmicromips")
1116 .
flag(
"+march=mips32");
1121 .
flag(
"+mmicromips");
1126 .
flag(
"+march=mips64r2");
1134 .
flag(
"-mmicromips")
1135 .
flag(
"+march=mips32r2");
1152 MtiMipsMultilibsV1 =
1154 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1166 .
Either(BigEndian, LittleEndian)
1172 std::vector<std::string> Dirs({
"/include"});
1174 Dirs.push_back(
"/../../../../sysroot/uclibc/usr/include");
1176 Dirs.push_back(
"/../../../../sysroot/usr/include");
1186 .
flag(
"-msoft-float")
1191 .
flag(
"+msoft-float")
1192 .
flag(
"-mnan=2008");
1195 .
flag(
"-msoft-float")
1200 .
flag(
"+msoft-float")
1202 .
flag(
"-mmicromips");
1205 .
flag(
"-msoft-float")
1208 auto ElHardNan =
makeMultilib(
"/mipsel-r2-hard-nan2008")
1210 .
flag(
"-msoft-float")
1213 .
flag(
"-mmicromips");
1214 auto BeHardNanUclibc =
makeMultilib(
"/mips-r2-hard-nan2008-uclibc")
1216 .
flag(
"-msoft-float")
1219 auto ElHardNanUclibc =
makeMultilib(
"/mipsel-r2-hard-nan2008-uclibc")
1221 .
flag(
"-msoft-float")
1224 auto BeHardUclibc =
makeMultilib(
"/mips-r2-hard-uclibc")
1226 .
flag(
"-msoft-float")
1229 auto ElHardUclibc =
makeMultilib(
"/mipsel-r2-hard-uclibc")
1231 .
flag(
"-msoft-float")
1234 auto ElMicroHardNan =
makeMultilib(
"/micromipsel-r2-hard-nan2008")
1236 .
flag(
"-msoft-float")
1238 .
flag(
"+mmicromips");
1239 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r2-soft")
1241 .
flag(
"+msoft-float")
1243 .
flag(
"+mmicromips");
1252 MtiMipsMultilibsV2 =
1254 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1255 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1256 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1257 .Either(O32, N32, N64)
1260 return std::vector<std::string>({
"/../../../../sysroot" +
1262 "/../usr/include"});
1264 .setFilePathsCallback([](
const Multilib &M) {
1265 return std::vector<std::string>(
1266 {
"/../../../../mips-mti-linux-gnu/lib" + M.
gccSuffix()});
1269 for (
auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1279 FilterNonExistent &NonExistent,
1295 .
Maybe(LittleEndian)
1298 return std::vector<std::string>(
1299 {
"/include",
"/../../../../sysroot/usr/include"});
1308 .
flag(
"-msoft-float")
1309 .
flag(
"-mmicromips");
1312 .
flag(
"+msoft-float")
1313 .
flag(
"-mmicromips");
1316 .
flag(
"-msoft-float")
1317 .
flag(
"-mmicromips");
1320 .
flag(
"+msoft-float")
1321 .
flag(
"-mmicromips");
1324 .
flag(
"-msoft-float")
1325 .
flag(
"+mmicromips");
1328 .
flag(
"+msoft-float")
1329 .
flag(
"+mmicromips");
1330 auto ElMicroHard =
makeMultilib(
"/micromipsel-r6-hard")
1332 .
flag(
"-msoft-float")
1333 .
flag(
"+mmicromips");
1334 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r6-soft")
1336 .
flag(
"+msoft-float")
1337 .
flag(
"+mmicromips");
1348 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1349 ElMicroHard, ElMicroSoft})
1350 .Either(O32, N32, N64)
1353 return std::vector<std::string>({
"/../../../../sysroot" +
1355 "/../usr/include"});
1357 .setFilePathsCallback([](
const Multilib &M) {
1358 return std::vector<std::string>(
1359 {
"/../../../../mips-img-linux-gnu/lib" + M.
gccSuffix()});
1362 for (
auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1372 const llvm::Triple &TargetTriple,
1373 StringRef Path,
const ArgList &Args,
1375 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1381 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1389 CPUName ==
"mips32r5" || CPUName ==
"p5600",
1390 "march=mips32r2", Flags);
1394 CPUName ==
"mips64r5" || CPUName ==
"octeon",
1395 "march=mips64r2", Flags);
1408 if (TargetTriple.isAndroid())
1412 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1413 TargetTriple.getOS() == llvm::Triple::Linux &&
1414 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1417 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1418 TargetTriple.getOS() == llvm::Triple::Linux &&
1419 TargetTriple.isGNUEnvironment())
1422 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1423 TargetTriple.getOS() == llvm::Triple::Linux &&
1424 TargetTriple.isGNUEnvironment())
1444 const llvm::Triple &TargetTriple,
1445 StringRef Path,
const ArgList &Args,
1448 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1450 .
flag(
"+march=armv7-a")
1453 .
flag(
"-march=armv7-a")
1456 .
flag(
"+march=armv7-a")
1459 .
flag(
"-march=armv7-a")
1463 .
Either(ThumbMultilib, ArmV7Multilib,
1464 ArmV7ThumbMultilib, DefaultMultilib)
1468 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1469 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1470 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1471 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1472 bool IsThumbMode = IsThumbArch ||
1473 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb,
false) ||
1474 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1475 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1476 (llvm::ARM::parseArchVersion(Arch) == 7 ||
1477 (IsArmArch && Arch ==
"" && IsV7SubArch));
1486 const llvm::Triple &TargetTriple,
1487 StringRef Path,
const ArgList &Args,
1489 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1506 const llvm::Triple &TargetTriple, StringRef Path,
1509 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1520 .
Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1521 .FilterOut(NonExistent);
1524 bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1541 const llvm::Triple &TargetTriple,
1542 StringRef Path,
const ArgList &Args,
1543 bool NeedsBiarchSuffix,
1554 StringRef Suff64 =
"/64";
1556 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1557 switch (TargetTriple.getArch()) {
1558 case llvm::Triple::x86:
1559 case llvm::Triple::x86_64:
1562 case llvm::Triple::sparc:
1563 case llvm::Triple::sparcv9:
1564 Suff64 =
"/sparcv9";
1573 .includeSuffix(Suff64)
1579 .includeSuffix(
"/32")
1585 .includeSuffix(
"/x32")
1591 FilterNonExistent NonExistent(
1592 Path, TargetTriple.isOSIAMCU() ?
"/libgcc.a" :
"/crtbegin.o", D.
getVFS());
1597 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
1598 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1600 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1602 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1605 if (TargetTriple.isArch32Bit())
1606 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1608 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1610 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1615 else if (Want == WANT64)
1617 else if (Want == WANTX32)
1651 StringRef RHSPatchSuffix)
const {
1652 if (Major != RHSMajor)
1653 return Major < RHSMajor;
1654 if (Minor != RHSMinor)
1655 return Minor < RHSMinor;
1656 if (Patch != RHSPatch) {
1665 return Patch < RHSPatch;
1667 if (PatchSuffix != RHSPatchSuffix) {
1669 if (RHSPatchSuffix.empty())
1671 if (PatchSuffix.empty())
1675 return PatchSuffix < RHSPatchSuffix;
1687 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1688 std::pair<StringRef, StringRef>
First = VersionText.split(
'.');
1689 std::pair<StringRef, StringRef> Second = First.second.split(
'.');
1691 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1692 if (First.first.getAsInteger(10, GoodVersion.
Major) || GoodVersion.
Major < 0)
1694 GoodVersion.
MajorStr = First.first.str();
1695 if (First.second.empty())
1697 StringRef MinorStr = Second.first;
1698 if (Second.second.empty()) {
1699 if (
size_t EndNumber = MinorStr.find_first_not_of(
"0123456789")) {
1700 GoodVersion.
PatchSuffix = MinorStr.substr(EndNumber);
1701 MinorStr = MinorStr.slice(0, EndNumber);
1704 if (MinorStr.getAsInteger(10, GoodVersion.
Minor) || GoodVersion.
Minor < 0)
1706 GoodVersion.
MinorStr = MinorStr.str();
1719 StringRef PatchText = Second.second;
1720 if (!PatchText.empty()) {
1721 if (
size_t EndNumber = PatchText.find_first_not_of(
"0123456789")) {
1723 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.
Patch) ||
1724 GoodVersion.
Patch < 0)
1726 GoodVersion.
PatchSuffix = PatchText.substr(EndNumber);
1734 llvm::StringRef SysRoot) {
1735 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
1737 return A->getValue();
1742 if (!SysRoot.empty())
1745 return GCC_INSTALL_PREFIX;
1758 const llvm::Triple &TargetTriple,
const ArgList &Args,
1760 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1761 ? TargetTriple.get64BitArchVariant()
1762 : TargetTriple.get32BitArchVariant();
1768 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1769 CandidateTripleAliases, CandidateBiarchLibDirs,
1770 CandidateBiarchTripleAliases);
1777 if (GCCToolchainDir !=
"") {
1778 if (GCCToolchainDir.back() ==
'/')
1779 GCCToolchainDir = GCCToolchainDir.drop_back();
1781 Prefixes.push_back(GCCToolchainDir);
1785 Prefixes.push_back(D.
SysRoot);
1786 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
1796 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
1804 if (GCCToolchainDir ==
"" || GCCToolchainDir == D.
SysRoot +
"/usr") {
1811 GentooTestTriples.push_back(TargetTriple.str());
1813 GentooTestTriples.append(ExtraTripleAliases.begin(),
1814 ExtraTripleAliases.end());
1815 GentooTestTriples.append(CandidateTripleAliases.begin(),
1816 CandidateTripleAliases.end());
1817 if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
1818 CandidateBiarchTripleAliases))
1824 Version = GCCVersion::Parse(
"0.0.0");
1825 for (
const std::string &Prefix : Prefixes) {
1826 if (!D.
getVFS().exists(Prefix))
1828 for (StringRef Suffix : CandidateLibDirs) {
1829 const std::string LibDir = Prefix + Suffix.str();
1830 if (!D.
getVFS().exists(LibDir))
1833 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, TargetTriple.str());
1835 for (StringRef Candidate : ExtraTripleAliases)
1836 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1837 for (StringRef Candidate : CandidateTripleAliases)
1838 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1840 for (StringRef Suffix : CandidateBiarchLibDirs) {
1841 const std::string LibDir = Prefix + Suffix.str();
1842 if (!D.
getVFS().exists(LibDir))
1844 for (StringRef Candidate : CandidateBiarchTripleAliases)
1845 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1852 for (
const auto &InstallPath : CandidateGCCInstallPaths)
1853 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
1855 if (!GCCInstallPath.empty())
1856 OS <<
"Selected GCC installation: " << GCCInstallPath <<
"\n";
1858 for (
const auto &
Multilib : Multilibs)
1859 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
1861 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
1862 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
1866 if (BiarchSibling.hasValue()) {
1867 M = BiarchSibling.getValue();
1873 void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
1875 StringRef SysRoot) {
1876 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1883 std::string PrefixDir = SysRoot.str() +
"/usr/gcc";
1885 for (llvm::vfs::directory_iterator LI = D.
getVFS().dir_begin(PrefixDir, EC),
1887 !EC && LI != LE; LI = LI.increment(EC)) {
1888 StringRef VersionText = llvm::sys::path::filename(LI->path());
1889 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1892 if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
1895 std::string CandidatePrefix = PrefixDir +
"/" + VersionText.str();
1896 std::string CandidateLibPath = CandidatePrefix +
"/lib/gcc";
1897 if (!D.
getVFS().exists(CandidateLibPath))
1900 Prefixes.push_back(CandidatePrefix);
1906 if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux) {
1908 Prefixes.push_back(
"/opt/rh/devtoolset-8/root/usr");
1909 Prefixes.push_back(
"/opt/rh/devtoolset-7/root/usr");
1910 Prefixes.push_back(
"/opt/rh/devtoolset-6/root/usr");
1911 Prefixes.push_back(
"/opt/rh/devtoolset-4/root/usr");
1912 Prefixes.push_back(
"/opt/rh/devtoolset-3/root/usr");
1913 Prefixes.push_back(
"/opt/rh/devtoolset-2/root/usr");
1915 Prefixes.push_back(SysRoot.str() +
"/usr");
1918 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1919 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
1927 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
1928 static const char *
const AArch64Triples[] = {
1929 "aarch64-none-linux-gnu",
"aarch64-linux-gnu",
"aarch64-redhat-linux",
1930 "aarch64-suse-linux",
"aarch64-linux-android"};
1931 static const char *
const AArch64beLibDirs[] = {
"/lib"};
1932 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu",
1933 "aarch64_be-linux-gnu"};
1935 static const char *
const ARMLibDirs[] = {
"/lib"};
1936 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi",
1937 "arm-linux-androideabi"};
1938 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
1939 "armv7hl-redhat-linux-gnueabi",
1940 "armv6hl-suse-linux-gnueabi",
1941 "armv7hl-suse-linux-gnueabi"};
1942 static const char *
const ARMebLibDirs[] = {
"/lib"};
1943 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi",
1944 "armeb-linux-androideabi"};
1945 static const char *
const ARMebHFTriples[] = {
1946 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
1948 static const char *
const AVRLibDirs[] = {
"/lib"};
1949 static const char *
const AVRTriples[] = {
"avr"};
1951 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
1952 static const char *
const X86_64Triples[] = {
1953 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
1954 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
1955 "x86_64-redhat-linux",
"x86_64-suse-linux",
1956 "x86_64-manbo-linux-gnu",
"x86_64-linux-gnu",
1957 "x86_64-slackware-linux",
"x86_64-unknown-linux",
1958 "x86_64-amazon-linux",
"x86_64-linux-android"};
1959 static const char *
const X32LibDirs[] = {
"/libx32"};
1960 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
1961 static const char *
const X86Triples[] = {
1962 "i686-linux-gnu",
"i686-pc-linux-gnu",
"i486-linux-gnu",
1963 "i386-linux-gnu",
"i386-redhat-linux6E",
"i686-redhat-linux",
1964 "i586-redhat-linux",
"i386-redhat-linux",
"i586-suse-linux",
1965 "i486-slackware-linux",
"i686-montavista-linux",
"i586-linux-gnu",
1966 "i686-linux-android",
"i386-gnu",
"i486-gnu",
1967 "i586-gnu",
"i686-gnu"};
1969 static const char *
const MIPSLibDirs[] = {
"/lib"};
1970 static const char *
const MIPSTriples[] = {
1971 "mips-linux-gnu",
"mips-mti-linux",
"mips-mti-linux-gnu",
1972 "mips-img-linux-gnu",
"mipsisa32r6-linux-gnu"};
1973 static const char *
const MIPSELLibDirs[] = {
"/lib"};
1974 static const char *
const MIPSELTriples[] = {
1975 "mipsel-linux-gnu",
"mips-img-linux-gnu",
"mipsisa32r6el-linux-gnu",
1976 "mipsel-linux-android"};
1978 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
1979 static const char *
const MIPS64Triples[] = {
1980 "mips64-linux-gnu",
"mips-mti-linux-gnu",
1981 "mips-img-linux-gnu",
"mips64-linux-gnuabi64",
1982 "mipsisa64r6-linux-gnu",
"mipsisa64r6-linux-gnuabi64"};
1983 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
1984 static const char *
const MIPS64ELTriples[] = {
1985 "mips64el-linux-gnu",
"mips-mti-linux-gnu",
1986 "mips-img-linux-gnu",
"mips64el-linux-gnuabi64",
1987 "mipsisa64r6el-linux-gnu",
"mipsisa64r6el-linux-gnuabi64",
1988 "mips64el-linux-android"};
1990 static const char *
const MIPSN32LibDirs[] = {
"/lib32"};
1991 static const char *
const MIPSN32Triples[] = {
"mips64-linux-gnuabin32",
1992 "mipsisa64r6-linux-gnuabin32"};
1993 static const char *
const MIPSN32ELLibDirs[] = {
"/lib32"};
1994 static const char *
const MIPSN32ELTriples[] = {
1995 "mips64el-linux-gnuabin32",
"mipsisa64r6el-linux-gnuabin32"};
1997 static const char *
const MSP430LibDirs[] = {
"/lib"};
1998 static const char *
const MSP430Triples[] = {
"msp430-elf"};
2000 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
2001 static const char *
const PPCTriples[] = {
2002 "powerpc-linux-gnu",
"powerpc-unknown-linux-gnu",
"powerpc-linux-gnuspe",
2003 "powerpc-suse-linux",
"powerpc-montavista-linuxspe"};
2004 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
2005 static const char *
const PPC64Triples[] = {
2006 "powerpc64-linux-gnu",
"powerpc64-unknown-linux-gnu",
2007 "powerpc64-suse-linux",
"ppc64-redhat-linux"};
2008 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
2009 static const char *
const PPC64LETriples[] = {
2010 "powerpc64le-linux-gnu",
"powerpc64le-unknown-linux-gnu",
2011 "powerpc64le-suse-linux",
"ppc64le-redhat-linux"};
2013 static const char *
const RISCV32LibDirs[] = {
"/lib32",
"/lib"};
2014 static const char *
const RISCV32Triples[] = {
"riscv32-unknown-linux-gnu",
2015 "riscv32-linux-gnu",
2016 "riscv32-unknown-elf"};
2017 static const char *
const RISCV64LibDirs[] = {
"/lib64",
"/lib"};
2018 static const char *
const RISCV64Triples[] = {
"riscv64-unknown-linux-gnu",
2019 "riscv64-linux-gnu",
2020 "riscv64-unknown-elf"};
2022 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
2023 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
2024 "sparcv8-linux-gnu"};
2025 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
2026 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
2027 "sparcv9-linux-gnu"};
2029 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
2030 static const char *
const SystemZTriples[] = {
2031 "s390x-linux-gnu",
"s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
2032 "s390x-suse-linux",
"s390x-redhat-linux"};
2038 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2039 static const char *
const SolarisLibDirs[] = {
"/lib"};
2040 static const char *
const SolarisSparcV8Triples[] = {
2041 "sparc-sun-solaris2.11",
"sparc-sun-solaris2.12"};
2042 static const char *
const SolarisSparcV9Triples[] = {
2043 "sparcv9-sun-solaris2.11",
"sparcv9-sun-solaris2.12"};
2044 static const char *
const SolarisX86Triples[] = {
"i386-pc-solaris2.11",
2045 "i386-pc-solaris2.12"};
2046 static const char *
const SolarisX86_64Triples[] = {
"x86_64-pc-solaris2.11",
2047 "x86_64-pc-solaris2.12"};
2048 LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2049 BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2050 switch (TargetTriple.getArch()) {
2051 case llvm::Triple::x86:
2052 TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
2053 BiarchTripleAliases.append(begin(SolarisX86_64Triples),
2054 end(SolarisX86_64Triples));
2056 case llvm::Triple::x86_64:
2057 TripleAliases.append(begin(SolarisX86_64Triples),
2058 end(SolarisX86_64Triples));
2059 BiarchTripleAliases.append(begin(SolarisX86Triples),
2060 end(SolarisX86Triples));
2062 case llvm::Triple::sparc:
2063 TripleAliases.append(begin(SolarisSparcV8Triples),
2064 end(SolarisSparcV8Triples));
2065 BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2066 end(SolarisSparcV9Triples));
2068 case llvm::Triple::sparcv9:
2069 TripleAliases.append(begin(SolarisSparcV9Triples),
2070 end(SolarisSparcV9Triples));
2071 BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2072 end(SolarisSparcV8Triples));
2081 if (TargetTriple.isAndroid()) {
2082 static const char *
const AArch64AndroidTriples[] = {
2083 "aarch64-linux-android"};
2084 static const char *
const ARMAndroidTriples[] = {
"arm-linux-androideabi"};
2085 static const char *
const MIPSELAndroidTriples[] = {
"mipsel-linux-android"};
2086 static const char *
const MIPS64ELAndroidTriples[] = {
2087 "mips64el-linux-android"};
2088 static const char *
const X86AndroidTriples[] = {
"i686-linux-android"};
2089 static const char *
const X86_64AndroidTriples[] = {
"x86_64-linux-android"};
2091 switch (TargetTriple.getArch()) {
2092 case llvm::Triple::aarch64:
2093 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2094 TripleAliases.append(begin(AArch64AndroidTriples),
2095 end(AArch64AndroidTriples));
2097 case llvm::Triple::arm:
2098 case llvm::Triple::thumb:
2099 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2100 TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2102 case llvm::Triple::mipsel:
2103 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2104 TripleAliases.append(begin(MIPSELAndroidTriples),
2105 end(MIPSELAndroidTriples));
2106 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2107 BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples),
2108 end(MIPS64ELAndroidTriples));
2110 case llvm::Triple::mips64el:
2111 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2112 TripleAliases.append(begin(MIPS64ELAndroidTriples),
2113 end(MIPS64ELAndroidTriples));
2114 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2115 BiarchTripleAliases.append(begin(MIPSELAndroidTriples),
2116 end(MIPSELAndroidTriples));
2118 case llvm::Triple::x86_64:
2119 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2120 TripleAliases.append(begin(X86_64AndroidTriples),
2121 end(X86_64AndroidTriples));
2122 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2123 BiarchTripleAliases.append(begin(X86AndroidTriples),
2124 end(X86AndroidTriples));
2126 case llvm::Triple::x86:
2127 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2128 TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
2129 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2130 BiarchTripleAliases.append(begin(X86_64AndroidTriples),
2131 end(X86_64AndroidTriples));
2140 switch (TargetTriple.getArch()) {
2141 case llvm::Triple::aarch64:
2142 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2143 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2144 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2145 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2147 case llvm::Triple::aarch64_be:
2148 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2149 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2150 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2151 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2153 case llvm::Triple::arm:
2154 case llvm::Triple::thumb:
2155 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2156 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2157 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2159 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2162 case llvm::Triple::armeb:
2163 case llvm::Triple::thumbeb:
2164 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2165 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2166 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2168 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2171 case llvm::Triple::avr:
2172 LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs));
2173 TripleAliases.append(begin(AVRTriples), end(AVRTriples));
2175 case llvm::Triple::x86_64:
2176 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2177 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2180 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
2181 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2182 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2184 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2185 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2188 case llvm::Triple::x86:
2189 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2192 if (!TargetTriple.isOSIAMCU()) {
2193 TripleAliases.append(begin(X86Triples), end(X86Triples));
2194 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2195 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2198 case llvm::Triple::mips:
2199 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2200 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2201 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2202 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2203 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2204 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2206 case llvm::Triple::mipsel:
2207 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2208 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2209 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2210 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2211 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2212 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2213 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2215 case llvm::Triple::mips64:
2216 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2217 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2218 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2219 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2220 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2221 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2223 case llvm::Triple::mips64el:
2224 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2225 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2226 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2227 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2228 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2229 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2230 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2232 case llvm::Triple::msp430:
2233 LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2234 TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2236 case llvm::Triple::ppc:
2237 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2238 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2239 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2240 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2242 case llvm::Triple::ppc64:
2243 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2244 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2245 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2246 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2248 case llvm::Triple::ppc64le:
2249 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2250 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2252 case llvm::Triple::riscv32:
2253 LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2254 TripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2255 BiarchLibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2256 BiarchTripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2258 case llvm::Triple::riscv64:
2259 LibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2260 TripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2261 BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2262 BiarchTripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2264 case llvm::Triple::sparc:
2265 case llvm::Triple::sparcel:
2266 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2267 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2268 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2269 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2271 case llvm::Triple::sparcv9:
2272 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2273 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2274 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2275 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2277 case llvm::Triple::systemz:
2278 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2279 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2289 TripleAliases.push_back(TargetTriple.str());
2292 if (TargetTriple.str() != BiarchTriple.str())
2293 BiarchTripleAliases.push_back(BiarchTriple.str());
2296 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2297 const llvm::Triple &TargetTriple,
const ArgList &Args,
2298 StringRef Path,
bool NeedsBiarchSuffix) {
2299 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2308 }
else if (TargetTriple.isMIPS()) {
2311 }
else if (TargetTriple.isRISCV()) {
2315 }
else if (TargetArch == llvm::Triple::avr) {
2318 NeedsBiarchSuffix, Detected)) {
2329 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2330 const llvm::Triple &TargetTriple,
const ArgList &Args,
2331 const std::string &LibDir, StringRef CandidateTriple,
2332 bool NeedsBiarchSuffix) {
2333 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2336 struct GCCLibSuffix {
2338 std::string LibSuffix;
2341 StringRef ReversePath;
2346 {
"gcc/" + CandidateTriple.str(),
"../..",
true},
2349 {
"gcc-cross/" + CandidateTriple.str(),
"../..",
2350 TargetTriple.getOS() != llvm::Triple::Solaris},
2356 {CandidateTriple.str(),
"..",
2357 TargetTriple.getVendor() == llvm::Triple::Freescale ||
2358 TargetTriple.getVendor() == llvm::Triple::OpenEmbedded},
2363 {CandidateTriple.str() +
"/gcc/" + CandidateTriple.str(),
"../../..",
2364 TargetTriple.getOS() != llvm::Triple::Solaris},
2370 {
"i386-linux-gnu/gcc/" + CandidateTriple.str(),
"../../..",
2371 (TargetArch == llvm::Triple::x86 &&
2372 TargetTriple.getOS() != llvm::Triple::Solaris)},
2373 {
"i386-gnu/gcc/" + CandidateTriple.str(),
"../../..",
2374 (TargetArch == llvm::Triple::x86 &&
2375 TargetTriple.getOS() != llvm::Triple::Solaris)}};
2381 StringRef LibSuffix = Suffix.LibSuffix;
2383 for (llvm::vfs::directory_iterator
2384 LI = D.
getVFS().dir_begin(LibDir +
"/" + LibSuffix, EC),
2386 !EC && LI != LE; LI = LI.increment(EC)) {
2387 StringRef VersionText = llvm::sys::path::filename(LI->path());
2388 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2389 if (CandidateVersion.Major != -1)
2390 if (!CandidateGCCInstallPaths.insert(LI->path()).second)
2392 if (CandidateVersion.isOlderThan(4, 1, 1))
2394 if (CandidateVersion <= Version)
2397 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
2401 Version = CandidateVersion;
2402 GCCTriple.setTriple(CandidateTriple);
2406 GCCInstallPath = (LibDir +
"/" + LibSuffix +
"/" + VersionText).str();
2407 GCCParentLibPath = (GCCInstallPath +
"/../" + Suffix.ReversePath).str();
2413 bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
2414 const llvm::Triple &TargetTriple,
const ArgList &Args,
2417 for (StringRef CandidateTriple : CandidateTriples) {
2418 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
2422 for (StringRef CandidateTriple : CandidateBiarchTriples) {
2423 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple,
true))
2429 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2430 const llvm::Triple &TargetTriple,
const ArgList &Args,
2431 StringRef CandidateTriple,
bool NeedsBiarchSuffix) {
2432 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
2433 D.
getVFS().getBufferForFile(D.
SysRoot +
"/etc/env.d/gcc/config-" +
2434 CandidateTriple.str());
2437 File.get()->getBuffer().split(Lines,
"\n");
2438 for (StringRef
Line : Lines) {
2441 if (!
Line.consume_front(
"CURRENT="))
2444 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
2447 std::pair<StringRef, StringRef> ActiveVersion =
Line.rsplit(
'-');
2460 ConfigFile.get()->getBuffer().split(ConfigLines,
"\n");
2461 for (StringRef ConfLine : ConfigLines) {
2462 ConfLine = ConfLine.trim();
2463 if (ConfLine.consume_front(
"LDPATH=")) {
2465 ConfLine.consume_back(
"\"");
2466 ConfLine.consume_front(
"\"");
2468 ConfLine.split(GentooScanPaths,
':', -1,
false);
2473 std::string basePath =
"/usr/lib/gcc/" + ActiveVersion.first.str() +
"/" 2474 + ActiveVersion.second.str();
2475 GentooScanPaths.push_back(StringRef(basePath));
2478 for (
const auto &GentooScanPath : GentooScanPaths) {
2479 std::string GentooPath = D.
SysRoot + std::string(GentooScanPath);
2480 if (D.
getVFS().exists(GentooPath +
"/crtbegin.o")) {
2481 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2485 Version = GCCVersion::Parse(ActiveVersion.second);
2486 GCCInstallPath = GentooPath;
2487 GCCParentLibPath = GentooPath + std::string(
"/../../..");
2488 GCCTriple.setTriple(ActiveVersion.first);
2500 const ArgList &Args)
2501 :
ToolChain(D, Triple, Args), GCCInstallation(D),
2502 CudaInstallation(D, Triple, Args) {
2515 return Preprocess.get();
2519 return Compile.get();
2538 return getArch() == llvm::Triple::x86_64;
2543 case llvm::Triple::x86_64:
2545 case llvm::Triple::ppc64:
2548 case llvm::Triple::mips64:
2549 case llvm::Triple::mips64el:
2564 case llvm::Triple::x86:
2565 case llvm::Triple::x86_64:
2566 case llvm::Triple::aarch64:
2567 case llvm::Triple::aarch64_be:
2568 case llvm::Triple::arm:
2569 case llvm::Triple::armeb:
2570 case llvm::Triple::avr:
2571 case llvm::Triple::bpfel:
2572 case llvm::Triple::bpfeb:
2573 case llvm::Triple::thumb:
2574 case llvm::Triple::thumbeb:
2575 case llvm::Triple::ppc:
2576 case llvm::Triple::ppc64:
2577 case llvm::Triple::ppc64le:
2578 case llvm::Triple::riscv32:
2579 case llvm::Triple::riscv64:
2580 case llvm::Triple::systemz:
2581 case llvm::Triple::mips:
2582 case llvm::Triple::mipsel:
2583 case llvm::Triple::mips64:
2584 case llvm::Triple::mips64el:
2585 case llvm::Triple::msp430:
2587 case llvm::Triple::sparc:
2588 case llvm::Triple::sparcel:
2589 case llvm::Triple::sparcv9:
2600 ArgStringList &CC1Args)
const {
2601 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2602 DriverArgs.hasArg(options::OPT_nostdincxx))
2618 llvm::opt::ArgStringList &CC1Args)
const {
2621 getDriver().SysRoot +
"/usr/include/c++/v1");
2626 llvm::opt::ArgStringList &CC1Args)
const {
2633 Twine
Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2634 StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2635 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2636 if (!
getVFS().exists(Base + Suffix))
2644 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2645 getVFS().exists(Base + Suffix +
"/" + GCCTriple + IncludeSuffix)) {
2647 Base + Suffix +
"/" + GCCTriple + IncludeSuffix);
2655 Base +
"/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2657 Base +
"/" + TargetMultiarchTriple + Suffix);
2664 llvm::opt::DerivedArgList *
2673 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2678 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_shared));
2679 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_fPIC));
2683 for (
auto *A : Args) {
2688 case options::OPT_shared:
2689 case options::OPT_dynamic:
2690 case options::OPT_static:
2691 case options::OPT_fPIC:
2692 case options::OPT_fno_PIC:
2693 case options::OPT_fpic:
2694 case options::OPT_fno_pic:
2695 case options::OPT_fPIE:
2696 case options::OPT_fno_PIE:
2697 case options::OPT_fpie:
2698 case options::OPT_fno_pie:
2707 void Generic_ELF::anchor() {}
2710 ArgStringList &CC1Args,
2713 bool UseInitArrayDefault =
2714 getTriple().getArch() == llvm::Triple::aarch64 ||
2715 getTriple().getArch() == llvm::Triple::aarch64_be ||
2717 getTriple().getOSMajorVersion() >= 12) ||
2718 (
getTriple().getOS() == llvm::Triple::Linux &&
2721 getTriple().getOS() == llvm::Triple::NaCl ||
2722 (
getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2724 getTriple().getOS() == llvm::Triple::Solaris ||
2725 getTriple().getArch() == llvm::Triple::riscv32 ||
2726 getTriple().getArch() == llvm::Triple::riscv64;
2728 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2729 options::OPT_fno_use_init_array, UseInitArrayDefault))
2730 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.
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.
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)
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.
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)