19 #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;
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 {
236 const ArgList &Args) {
237 bool IsBigEndian =
false;
238 switch (Triple.getArch()) {
239 case llvm::Triple::armeb:
240 case llvm::Triple::thumbeb:
243 case llvm::Triple::arm:
244 case llvm::Triple::thumb:
245 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
246 options::OPT_mbig_endian))
247 IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
255 static const char *
getLDMOption(
const llvm::Triple &T,
const ArgList &Args) {
256 switch (T.getArch()) {
257 case llvm::Triple::x86:
261 case llvm::Triple::aarch64:
262 return "aarch64linux";
263 case llvm::Triple::aarch64_be:
264 return "aarch64linuxb";
265 case llvm::Triple::arm:
266 case llvm::Triple::thumb:
267 case llvm::Triple::armeb:
268 case llvm::Triple::thumbeb:
269 return isArmBigEndian(T, Args) ?
"armelfb_linux_eabi" :
"armelf_linux_eabi";
270 case llvm::Triple::ppc:
271 return "elf32ppclinux";
272 case llvm::Triple::ppc64:
274 case llvm::Triple::ppc64le:
276 case llvm::Triple::riscv32:
277 return "elf32lriscv";
278 case llvm::Triple::riscv64:
279 return "elf64lriscv";
280 case llvm::Triple::sparc:
281 case llvm::Triple::sparcel:
282 return "elf32_sparc";
283 case llvm::Triple::sparcv9:
284 return "elf64_sparc";
285 case llvm::Triple::mips:
286 return "elf32btsmip";
287 case llvm::Triple::mipsel:
288 return "elf32ltsmip";
289 case llvm::Triple::mips64:
291 T.getEnvironment() == llvm::Triple::GNUABIN32)
292 return "elf32btsmipn32";
293 return "elf64btsmip";
294 case llvm::Triple::mips64el:
296 T.getEnvironment() == llvm::Triple::GNUABIN32)
297 return "elf32ltsmipn32";
298 return "elf64ltsmip";
299 case llvm::Triple::systemz:
301 case llvm::Triple::x86_64:
302 if (T.getEnvironment() == llvm::Triple::GNUX32)
303 return "elf32_x86_64";
311 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) ||
312 Args.hasArg(options::OPT_r))
315 Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
319 return A->getOption().matches(options::OPT_pie);
326 const char *LinkingOutput)
const {
331 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
333 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
334 const bool isAndroid = ToolChain.
getTriple().isAndroid();
335 const bool IsIAMCU = ToolChain.
getTriple().isOSIAMCU();
336 const bool IsPIE =
getPIE(Args, ToolChain);
337 const bool HasCRTBeginEndFiles =
338 ToolChain.
getTriple().hasEnvironment() ||
339 (ToolChain.
getTriple().getVendor() != llvm::Triple::MipsTechnologies);
341 ArgStringList CmdArgs;
344 Args.ClaimAllArgs(options::OPT_g_Group);
346 Args.ClaimAllArgs(options::OPT_emit_llvm);
349 Args.ClaimAllArgs(options::OPT_w);
352 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
355 CmdArgs.push_back(
"-pie");
357 if (Args.hasArg(options::OPT_rdynamic))
358 CmdArgs.push_back(
"-export-dynamic");
360 if (Args.hasArg(options::OPT_s))
361 CmdArgs.push_back(
"-s");
363 if (Triple.isARM() || Triple.isThumb() || Triple.isAArch64()) {
367 IsBigEndian = IsBigEndian || Arch == llvm::Triple::aarch64_be;
368 CmdArgs.push_back(IsBigEndian ?
"-EB" :
"-EL");
373 if (Arch == llvm::Triple::aarch64 && isAndroid) {
375 if (CPU.empty() || CPU ==
"generic" || CPU ==
"cortex-a53")
376 CmdArgs.push_back(
"--fix-cortex-a53-843419");
379 for (
const auto &Opt : ToolChain.
ExtraOpts)
380 CmdArgs.push_back(Opt.c_str());
382 CmdArgs.push_back(
"--eh-frame-hdr");
385 CmdArgs.push_back(
"-m");
386 CmdArgs.push_back(LDMOption);
388 D.
Diag(diag::err_target_unknown_triple) << Triple.str();
392 if (Args.hasArg(options::OPT_static)) {
393 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
394 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
395 CmdArgs.push_back(
"-Bstatic");
397 CmdArgs.push_back(
"-static");
398 }
else if (Args.hasArg(options::OPT_shared)) {
399 CmdArgs.push_back(
"-shared");
402 if (!Args.hasArg(options::OPT_static)) {
403 if (Args.hasArg(options::OPT_rdynamic))
404 CmdArgs.push_back(
"-export-dynamic");
406 if (!Args.hasArg(options::OPT_shared)) {
407 const std::string Loader =
409 CmdArgs.push_back(
"-dynamic-linker");
410 CmdArgs.push_back(Args.MakeArgString(Loader));
414 CmdArgs.push_back(
"-o");
417 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
418 if (!isAndroid && !IsIAMCU) {
419 const char *crt1 =
nullptr;
420 if (!Args.hasArg(options::OPT_shared)) {
421 if (Args.hasArg(options::OPT_pg))
429 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crt1)));
431 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
435 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crt0.o")));
437 const char *crtbegin;
438 if (Args.hasArg(options::OPT_static))
439 crtbegin = isAndroid ?
"crtbegin_static.o" :
"crtbeginT.o";
440 else if (Args.hasArg(options::OPT_shared))
441 crtbegin = isAndroid ?
"crtbegin_so.o" :
"crtbeginS.o";
443 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbeginS.o";
445 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbegin.o";
447 if (HasCRTBeginEndFiles)
448 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtbegin)));
455 Args.AddAllArgs(CmdArgs, options::OPT_L);
456 Args.AddAllArgs(CmdArgs, options::OPT_u);
461 assert(!Inputs.empty() &&
"Must have at least one input.");
466 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
467 CmdArgs.push_back(
"--no-demangle");
473 getToolChain().addProfileRTLibs(Args, CmdArgs);
476 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
478 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
479 !Args.hasArg(options::OPT_static);
480 if (OnlyLibstdcxxStatic)
481 CmdArgs.push_back(
"-Bstatic");
483 if (OnlyLibstdcxxStatic)
484 CmdArgs.push_back(
"-Bdynamic");
486 CmdArgs.push_back(
"-lm");
489 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
491 if (!Args.hasArg(options::OPT_nostdlib)) {
492 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
493 if (Args.hasArg(options::OPT_static))
494 CmdArgs.push_back(
"--start-group");
496 if (NeedsSanitizerDeps)
502 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
503 Args.hasArg(options::OPT_pthreads);
516 if (WantPthread && !isAndroid)
517 CmdArgs.push_back(
"-lpthread");
519 if (Args.hasArg(options::OPT_fsplit_stack))
520 CmdArgs.push_back(
"--wrap=pthread_create");
522 CmdArgs.push_back(
"-lc");
526 CmdArgs.push_back(
"-lgloss");
528 if (Args.hasArg(options::OPT_static))
529 CmdArgs.push_back(
"--end-group");
535 CmdArgs.push_back(
"--as-needed");
536 CmdArgs.push_back(
"-lsoftfp");
537 CmdArgs.push_back(
"--no-as-needed");
541 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
543 if (Args.hasArg(options::OPT_shared))
544 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
546 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
548 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
550 if (HasCRTBeginEndFiles)
551 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtend)));
553 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
564 const char *Exec = Args.MakeArgString(ToolChain.
GetLinkerPath());
565 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
573 const char *LinkingOutput)
const {
574 const auto &D = getToolChain().getDriver();
578 ArgStringList CmdArgs;
580 llvm::Reloc::Model RelocationModel;
583 std::tie(RelocationModel, PICLevel, IsPIE) =
586 if (
const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
587 if (A->getOption().getID() == options::OPT_gz) {
588 CmdArgs.push_back(
"-compress-debug-sections");
590 StringRef
Value = A->getValue();
591 if (Value ==
"none") {
592 CmdArgs.push_back(
"-compress-debug-sections=none");
593 }
else if (Value ==
"zlib" || Value ==
"zlib-gnu") {
595 Args.MakeArgString(
"-compress-debug-sections=" + Twine(Value)));
597 D.Diag(diag::err_drv_unsupported_option_argument)
598 << A->getOption().getName() <<
Value;
603 switch (getToolChain().getArch()) {
608 case llvm::Triple::x86:
609 CmdArgs.push_back(
"--32");
611 case llvm::Triple::x86_64:
612 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
613 CmdArgs.push_back(
"--x32");
615 CmdArgs.push_back(
"--64");
617 case llvm::Triple::ppc: {
618 CmdArgs.push_back(
"-a32");
619 CmdArgs.push_back(
"-mppc");
624 case llvm::Triple::ppc64: {
625 CmdArgs.push_back(
"-a64");
626 CmdArgs.push_back(
"-mppc64");
631 case llvm::Triple::ppc64le: {
632 CmdArgs.push_back(
"-a64");
633 CmdArgs.push_back(
"-mppc64");
634 CmdArgs.push_back(
"-mlittle-endian");
639 case llvm::Triple::riscv32:
640 case llvm::Triple::riscv64: {
642 CmdArgs.push_back(
"-mabi");
643 CmdArgs.push_back(ABIName.data());
644 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
645 StringRef MArch = A->getValue();
646 CmdArgs.push_back(
"-march");
647 CmdArgs.push_back(MArch.data());
651 case llvm::Triple::sparc:
652 case llvm::Triple::sparcel: {
653 CmdArgs.push_back(
"-32");
654 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
659 case llvm::Triple::sparcv9: {
660 CmdArgs.push_back(
"-64");
661 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
666 case llvm::Triple::arm:
667 case llvm::Triple::armeb:
668 case llvm::Triple::thumb:
669 case llvm::Triple::thumbeb: {
670 const llvm::Triple &Triple2 = getToolChain().getTriple();
672 switch (Triple2.getSubArch()) {
673 case llvm::Triple::ARMSubArch_v7:
674 CmdArgs.push_back(
"-mfpu=neon");
676 case llvm::Triple::ARMSubArch_v8:
677 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
684 case arm::FloatABI::Invalid: llvm_unreachable(
"must have an ABI!");
685 case arm::FloatABI::Soft:
686 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=soft"));
688 case arm::FloatABI::SoftFP:
689 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=softfp"));
691 case arm::FloatABI::Hard:
692 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=hard"));
696 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
699 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
702 case llvm::Triple::aarch64:
703 case llvm::Triple::aarch64_be: {
705 getToolChain().getArch() == llvm::Triple::aarch64_be ?
"-EB" :
"-EL");
706 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
711 case llvm::Triple::mips:
712 case llvm::Triple::mipsel:
713 case llvm::Triple::mips64:
714 case llvm::Triple::mips64el: {
720 CmdArgs.push_back(
"-march");
721 CmdArgs.push_back(CPUName.data());
723 CmdArgs.push_back(
"-mabi");
724 CmdArgs.push_back(ABIName.data());
728 if (RelocationModel == llvm::Reloc::Static)
729 CmdArgs.push_back(
"-mno-shared");
733 if (ABIName !=
"64" && !Args.hasArg(options::OPT_mno_abicalls))
734 CmdArgs.push_back(
"-call_nonpic");
736 if (getToolChain().getTriple().isLittleEndian())
737 CmdArgs.push_back(
"-EL");
739 CmdArgs.push_back(
"-EB");
741 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
742 if (StringRef(A->getValue()) ==
"2008")
743 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
747 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
748 options::OPT_mfp64)) {
750 A->render(Args, CmdArgs);
752 Args, getToolChain().getTriple(), CPUName, ABIName,
754 CmdArgs.push_back(
"-mfpxx");
759 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
760 if (A->getOption().matches(options::OPT_mips16)) {
762 A->render(Args, CmdArgs);
765 CmdArgs.push_back(
"-no-mips16");
769 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
770 options::OPT_mno_micromips);
771 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
772 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
774 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
777 if (A->getOption().matches(options::OPT_mmsa))
778 CmdArgs.push_back(Args.MakeArgString(
"-mmsa"));
781 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
782 options::OPT_msoft_float);
784 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
785 options::OPT_msingle_float);
787 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
788 options::OPT_mno_odd_spreg);
793 case llvm::Triple::systemz: {
797 CmdArgs.push_back(Args.MakeArgString(
"-march=" + CPUName));
802 Args.AddAllArgs(CmdArgs, options::OPT_I);
803 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
805 CmdArgs.push_back(
"-o");
808 for (
const auto &II : Inputs)
809 CmdArgs.push_back(II.getFilename());
811 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
812 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
817 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
818 getToolChain().getTriple().isOSLinux())
825 class FilterNonExistent {
826 StringRef
Base, File;
827 llvm::vfs::FileSystem &VFS;
830 FilterNonExistent(StringRef Base, StringRef File, llvm::vfs::FileSystem &VFS)
831 : Base(Base), File(File), VFS(VFS) {}
832 bool operator()(
const Multilib &M) {
833 return !VFS.exists(Base + M.
gccSuffix() + File);
839 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
840 options::OPT_mfloat_abi_EQ);
844 return A->getOption().matches(options::OPT_msoft_float) ||
845 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
846 A->getValue() == StringRef(
"soft"));
852 std::vector<std::string> &Flags) {
854 Flags.push_back(std::string(
"+") + Flag);
856 Flags.push_back(std::string(
"-") + Flag);
860 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
863 static bool isMipsEL(llvm::Triple::ArchType Arch) {
864 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
868 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
869 return A && A->getOption().matches(options::OPT_mips16);
873 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
874 return A && A->getOption().matches(options::OPT_mmicromips);
877 static bool isRISCV(llvm::Triple::ArchType Arch) {
878 return Arch == llvm::Triple::riscv32 || Arch == llvm::Triple::riscv64;
881 static bool isMSP430(llvm::Triple::ArchType Arch) {
882 return Arch == llvm::Triple::msp430;
886 return Multilib(commonSuffix, commonSuffix, commonSuffix);
890 FilterNonExistent &NonExistent,
897 auto MArchMicroMips =
918 .includeSuffix(
"/64")
925 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
927 .
Either(SoftFloat, Nan2008, DefaultFloat)
930 .
Either(BigEndian, LittleEndian)
936 std::vector<std::string> Dirs({
"/include"});
939 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
941 Dirs.push_back(
"/../../../../mips-linux-gnu/libc/usr/include");
953 .includeSuffix(
"/64")
960 DebianMipsMultilibs =
966 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
967 if (CSMipsMultilibs.
size() < DebianMipsMultilibs.size())
968 std::iter_swap(Candidates, Candidates + 1);
971 if (Candidate == &DebianMipsMultilibs)
982 FilterNonExistent &NonExistent,
994 Multilib(
"/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
995 Multilib(
"/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
1001 Multilib().flag(
"+march=mips64r6"),
1002 Multilib(
"/32/mips-r1",
"",
"/mips-r1").flag(
"+march=mips32"),
1003 Multilib(
"/32/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
1004 Multilib(
"/32/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
1008 if (VFS.exists(Path +
"/mips-r6"))
1009 MS = &AndroidMipselMultilibs;
1010 else if (VFS.exists(Path +
"/32"))
1011 MS = &AndroidMips64elMultilibs;
1020 FilterNonExistent &NonExistent,
1029 .flag(
"+march=mips32r2");
1031 auto MArchMipselR2 =
makeMultilib(
"/mipsel-r2-hard-musl")
1034 .
flag(
"+march=mips32r2");
1040 return std::vector<std::string>(
1041 {
"/../sysroot" + M.
osSuffix() +
"/usr/include"});
1052 FilterNonExistent &NonExistent,
1060 .
flag(
"-mmicromips")
1061 .
flag(
"+march=mips32");
1066 .
flag(
"+mmicromips");
1071 .
flag(
"+march=mips64r2");
1079 .
flag(
"-mmicromips")
1080 .
flag(
"+march=mips32r2");
1097 MtiMipsMultilibsV1 =
1099 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1111 .
Either(BigEndian, LittleEndian)
1117 std::vector<std::string> Dirs({
"/include"});
1119 Dirs.push_back(
"/../../../../sysroot/uclibc/usr/include");
1121 Dirs.push_back(
"/../../../../sysroot/usr/include");
1131 .
flag(
"-msoft-float")
1136 .
flag(
"+msoft-float")
1137 .
flag(
"-mnan=2008");
1140 .
flag(
"-msoft-float")
1145 .
flag(
"+msoft-float")
1147 .
flag(
"-mmicromips");
1150 .
flag(
"-msoft-float")
1153 auto ElHardNan =
makeMultilib(
"/mipsel-r2-hard-nan2008")
1155 .
flag(
"-msoft-float")
1158 .
flag(
"-mmicromips");
1159 auto BeHardNanUclibc =
makeMultilib(
"/mips-r2-hard-nan2008-uclibc")
1161 .
flag(
"-msoft-float")
1164 auto ElHardNanUclibc =
makeMultilib(
"/mipsel-r2-hard-nan2008-uclibc")
1166 .
flag(
"-msoft-float")
1169 auto BeHardUclibc =
makeMultilib(
"/mips-r2-hard-uclibc")
1171 .
flag(
"-msoft-float")
1174 auto ElHardUclibc =
makeMultilib(
"/mipsel-r2-hard-uclibc")
1176 .
flag(
"-msoft-float")
1179 auto ElMicroHardNan =
makeMultilib(
"/micromipsel-r2-hard-nan2008")
1181 .
flag(
"-msoft-float")
1183 .
flag(
"+mmicromips");
1184 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r2-soft")
1186 .
flag(
"+msoft-float")
1188 .
flag(
"+mmicromips");
1197 MtiMipsMultilibsV2 =
1199 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1200 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1201 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1202 .Either(O32, N32, N64)
1205 return std::vector<std::string>({
"/../../../../sysroot" +
1207 "/../usr/include"});
1209 .setFilePathsCallback([](
const Multilib &M) {
1210 return std::vector<std::string>(
1211 {
"/../../../../mips-mti-linux-gnu/lib" + M.
gccSuffix()});
1214 for (
auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1224 FilterNonExistent &NonExistent,
1240 .
Maybe(LittleEndian)
1243 return std::vector<std::string>(
1244 {
"/include",
"/../../../../sysroot/usr/include"});
1253 .
flag(
"-msoft-float")
1254 .
flag(
"-mmicromips");
1257 .
flag(
"+msoft-float")
1258 .
flag(
"-mmicromips");
1261 .
flag(
"-msoft-float")
1262 .
flag(
"-mmicromips");
1265 .
flag(
"+msoft-float")
1266 .
flag(
"-mmicromips");
1269 .
flag(
"-msoft-float")
1270 .
flag(
"+mmicromips");
1273 .
flag(
"+msoft-float")
1274 .
flag(
"+mmicromips");
1275 auto ElMicroHard =
makeMultilib(
"/micromipsel-r6-hard")
1277 .
flag(
"-msoft-float")
1278 .
flag(
"+mmicromips");
1279 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r6-soft")
1281 .
flag(
"+msoft-float")
1282 .
flag(
"+mmicromips");
1293 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1294 ElMicroHard, ElMicroSoft})
1295 .Either(O32, N32, N64)
1298 return std::vector<std::string>({
"/../../../../sysroot" +
1300 "/../usr/include"});
1302 .setFilePathsCallback([](
const Multilib &M) {
1303 return std::vector<std::string>(
1304 {
"/../../../../mips-img-linux-gnu/lib" + M.
gccSuffix()});
1307 for (
auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1317 const llvm::Triple &TargetTriple,
1318 StringRef Path,
const ArgList &Args,
1320 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1326 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1334 CPUName ==
"mips32r5" || CPUName ==
"p5600",
1335 "march=mips32r2", Flags);
1339 CPUName ==
"mips64r5" || CPUName ==
"octeon",
1340 "march=mips64r2", Flags);
1353 if (TargetTriple.isAndroid())
1357 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1358 TargetTriple.getOS() == llvm::Triple::Linux &&
1359 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1362 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1363 TargetTriple.getOS() == llvm::Triple::Linux &&
1364 TargetTriple.isGNUEnvironment())
1367 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1368 TargetTriple.getOS() == llvm::Triple::Linux &&
1369 TargetTriple.isGNUEnvironment())
1389 const llvm::Triple &TargetTriple,
1390 StringRef Path,
const ArgList &Args,
1393 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1395 .
flag(
"+march=armv7-a")
1398 .
flag(
"-march=armv7-a")
1401 .
flag(
"+march=armv7-a")
1404 .
flag(
"-march=armv7-a")
1408 .
Either(ThumbMultilib, ArmV7Multilib,
1409 ArmV7ThumbMultilib, DefaultMultilib)
1413 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1414 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1415 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1416 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1417 bool IsThumbMode = IsThumbArch ||
1418 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb,
false) ||
1419 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1420 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1421 (llvm::ARM::parseArchVersion(Arch) == 7 ||
1422 (IsArmArch && Arch ==
"" && IsV7SubArch));
1431 const llvm::Triple &TargetTriple,
1432 StringRef Path,
const ArgList &Args,
1434 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1451 const llvm::Triple &TargetTriple, StringRef Path,
1454 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1465 .
Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1466 .FilterOut(NonExistent);
1469 bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1486 const llvm::Triple &TargetTriple,
1487 StringRef Path,
const ArgList &Args,
1488 bool NeedsBiarchSuffix,
1499 StringRef Suff64 =
"/64";
1501 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1502 switch (TargetTriple.getArch()) {
1503 case llvm::Triple::x86:
1504 case llvm::Triple::x86_64:
1507 case llvm::Triple::sparc:
1508 case llvm::Triple::sparcv9:
1509 Suff64 =
"/sparcv9";
1518 .includeSuffix(Suff64)
1524 .includeSuffix(
"/32")
1530 .includeSuffix(
"/x32")
1536 FilterNonExistent NonExistent(
1537 Path, TargetTriple.isOSIAMCU() ?
"/libgcc.a" :
"/crtbegin.o", D.
getVFS());
1542 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
1543 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1545 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1547 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1550 if (TargetTriple.isArch32Bit())
1551 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1553 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1555 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1560 else if (Want == WANT64)
1562 else if (Want == WANTX32)
1596 StringRef RHSPatchSuffix)
const {
1597 if (Major != RHSMajor)
1598 return Major < RHSMajor;
1599 if (Minor != RHSMinor)
1600 return Minor < RHSMinor;
1601 if (Patch != RHSPatch) {
1610 return Patch < RHSPatch;
1612 if (PatchSuffix != RHSPatchSuffix) {
1614 if (RHSPatchSuffix.empty())
1616 if (PatchSuffix.empty())
1620 return PatchSuffix < RHSPatchSuffix;
1632 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1633 std::pair<StringRef, StringRef>
First = VersionText.split(
'.');
1634 std::pair<StringRef, StringRef> Second = First.second.split(
'.');
1636 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1637 if (First.first.getAsInteger(10, GoodVersion.
Major) || GoodVersion.
Major < 0)
1639 GoodVersion.
MajorStr = First.first.str();
1640 if (First.second.empty())
1642 StringRef MinorStr = Second.first;
1643 if (Second.second.empty()) {
1644 if (
size_t EndNumber = MinorStr.find_first_not_of(
"0123456789")) {
1645 GoodVersion.
PatchSuffix = MinorStr.substr(EndNumber);
1646 MinorStr = MinorStr.slice(0, EndNumber);
1649 if (MinorStr.getAsInteger(10, GoodVersion.
Minor) || GoodVersion.
Minor < 0)
1651 GoodVersion.
MinorStr = MinorStr.str();
1664 StringRef PatchText = Second.second;
1665 if (!PatchText.empty()) {
1666 if (
size_t EndNumber = PatchText.find_first_not_of(
"0123456789")) {
1668 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.
Patch) ||
1669 GoodVersion.
Patch < 0)
1671 GoodVersion.
PatchSuffix = PatchText.substr(EndNumber);
1679 llvm::StringRef SysRoot) {
1680 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
1682 return A->getValue();
1687 if (!SysRoot.empty())
1690 return GCC_INSTALL_PREFIX;
1703 const llvm::Triple &TargetTriple,
const ArgList &Args,
1705 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1706 ? TargetTriple.get64BitArchVariant()
1707 : TargetTriple.get32BitArchVariant();
1713 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1714 CandidateTripleAliases, CandidateBiarchLibDirs,
1715 CandidateBiarchTripleAliases);
1722 if (GCCToolchainDir !=
"") {
1723 if (GCCToolchainDir.back() ==
'/')
1724 GCCToolchainDir = GCCToolchainDir.drop_back();
1726 Prefixes.push_back(GCCToolchainDir);
1730 Prefixes.push_back(D.
SysRoot);
1731 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
1741 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.
SysRoot);
1749 if (GCCToolchainDir ==
"" || GCCToolchainDir == D.
SysRoot +
"/usr") {
1756 GentooTestTriples.push_back(TargetTriple.str());
1758 GentooTestTriples.append(ExtraTripleAliases.begin(),
1759 ExtraTripleAliases.end());
1760 GentooTestTriples.append(CandidateTripleAliases.begin(),
1761 CandidateTripleAliases.end());
1762 if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
1763 CandidateBiarchTripleAliases))
1769 Version = GCCVersion::Parse(
"0.0.0");
1770 for (
const std::string &Prefix : Prefixes) {
1771 if (!D.
getVFS().exists(Prefix))
1773 for (StringRef Suffix : CandidateLibDirs) {
1774 const std::string LibDir = Prefix + Suffix.str();
1775 if (!D.
getVFS().exists(LibDir))
1778 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, TargetTriple.str());
1780 for (StringRef Candidate : ExtraTripleAliases)
1781 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1782 for (StringRef Candidate : CandidateTripleAliases)
1783 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1785 for (StringRef Suffix : CandidateBiarchLibDirs) {
1786 const std::string LibDir = Prefix + Suffix.str();
1787 if (!D.
getVFS().exists(LibDir))
1789 for (StringRef Candidate : CandidateBiarchTripleAliases)
1790 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1797 for (
const auto &InstallPath : CandidateGCCInstallPaths)
1798 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
1800 if (!GCCInstallPath.empty())
1801 OS <<
"Selected GCC installation: " << GCCInstallPath <<
"\n";
1803 for (
const auto &
Multilib : Multilibs)
1804 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
1806 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
1807 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
1811 if (BiarchSibling.hasValue()) {
1812 M = BiarchSibling.getValue();
1818 void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
1820 StringRef SysRoot) {
1821 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1828 std::string PrefixDir = SysRoot.str() +
"/usr/gcc";
1830 for (llvm::vfs::directory_iterator LI = D.
getVFS().dir_begin(PrefixDir, EC),
1832 !EC && LI != LE; LI = LI.increment(EC)) {
1833 StringRef VersionText = llvm::sys::path::filename(LI->path());
1834 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1837 if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
1840 std::string CandidatePrefix = PrefixDir +
"/" + VersionText.str();
1841 std::string CandidateLibPath = CandidatePrefix +
"/lib/gcc";
1842 if (!D.
getVFS().exists(CandidateLibPath))
1845 Prefixes.push_back(CandidatePrefix);
1851 if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux) {
1853 Prefixes.push_back(
"/opt/rh/devtoolset-7/root/usr");
1854 Prefixes.push_back(
"/opt/rh/devtoolset-6/root/usr");
1855 Prefixes.push_back(
"/opt/rh/devtoolset-4/root/usr");
1856 Prefixes.push_back(
"/opt/rh/devtoolset-3/root/usr");
1857 Prefixes.push_back(
"/opt/rh/devtoolset-2/root/usr");
1859 Prefixes.push_back(SysRoot.str() +
"/usr");
1862 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1863 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
1871 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
1872 static const char *
const AArch64Triples[] = {
1873 "aarch64-none-linux-gnu",
"aarch64-linux-gnu",
"aarch64-redhat-linux",
1874 "aarch64-suse-linux",
"aarch64-linux-android"};
1875 static const char *
const AArch64beLibDirs[] = {
"/lib"};
1876 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu",
1877 "aarch64_be-linux-gnu"};
1879 static const char *
const ARMLibDirs[] = {
"/lib"};
1880 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi",
1881 "arm-linux-androideabi"};
1882 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
1883 "armv7hl-redhat-linux-gnueabi",
1884 "armv6hl-suse-linux-gnueabi",
1885 "armv7hl-suse-linux-gnueabi"};
1886 static const char *
const ARMebLibDirs[] = {
"/lib"};
1887 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi",
1888 "armeb-linux-androideabi"};
1889 static const char *
const ARMebHFTriples[] = {
1890 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
1892 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
1893 static const char *
const X86_64Triples[] = {
1894 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
1895 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
1896 "x86_64-redhat-linux",
"x86_64-suse-linux",
1897 "x86_64-manbo-linux-gnu",
"x86_64-linux-gnu",
1898 "x86_64-slackware-linux",
"x86_64-unknown-linux",
1899 "x86_64-amazon-linux",
"x86_64-linux-android"};
1900 static const char *
const X32LibDirs[] = {
"/libx32"};
1901 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
1902 static const char *
const X86Triples[] = {
1903 "i686-linux-gnu",
"i686-pc-linux-gnu",
"i486-linux-gnu",
1904 "i386-linux-gnu",
"i386-redhat-linux6E",
"i686-redhat-linux",
1905 "i586-redhat-linux",
"i386-redhat-linux",
"i586-suse-linux",
1906 "i486-slackware-linux",
"i686-montavista-linux",
"i586-linux-gnu",
1907 "i686-linux-android",
"i386-gnu",
"i486-gnu",
1908 "i586-gnu",
"i686-gnu"};
1910 static const char *
const MIPSLibDirs[] = {
"/lib"};
1911 static const char *
const MIPSTriples[] = {
1912 "mips-linux-gnu",
"mips-mti-linux",
"mips-mti-linux-gnu",
1913 "mips-img-linux-gnu",
"mipsisa32r6-linux-gnu"};
1914 static const char *
const MIPSELLibDirs[] = {
"/lib"};
1915 static const char *
const MIPSELTriples[] = {
1916 "mipsel-linux-gnu",
"mips-img-linux-gnu",
"mipsisa32r6el-linux-gnu",
1917 "mipsel-linux-android"};
1919 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
1920 static const char *
const MIPS64Triples[] = {
1921 "mips64-linux-gnu",
"mips-mti-linux-gnu",
1922 "mips-img-linux-gnu",
"mips64-linux-gnuabi64",
1923 "mipsisa64r6-linux-gnu",
"mipsisa64r6-linux-gnuabi64"};
1924 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
1925 static const char *
const MIPS64ELTriples[] = {
1926 "mips64el-linux-gnu",
"mips-mti-linux-gnu",
1927 "mips-img-linux-gnu",
"mips64el-linux-gnuabi64",
1928 "mipsisa64r6el-linux-gnu",
"mipsisa64r6el-linux-gnuabi64",
1929 "mips64el-linux-android"};
1931 static const char *
const MIPSN32LibDirs[] = {
"/lib32"};
1932 static const char *
const MIPSN32Triples[] = {
"mips64-linux-gnuabin32",
1933 "mipsisa64r6-linux-gnuabin32"};
1934 static const char *
const MIPSN32ELLibDirs[] = {
"/lib32"};
1935 static const char *
const MIPSN32ELTriples[] = {
1936 "mips64el-linux-gnuabin32",
"mipsisa64r6el-linux-gnuabin32"};
1938 static const char *
const MSP430LibDirs[] = {
"/lib"};
1939 static const char *
const MSP430Triples[] = {
"msp430-elf"};
1941 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
1942 static const char *
const PPCTriples[] = {
1943 "powerpc-linux-gnu",
"powerpc-unknown-linux-gnu",
"powerpc-linux-gnuspe",
1944 "powerpc-suse-linux",
"powerpc-montavista-linuxspe"};
1945 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
1946 static const char *
const PPC64Triples[] = {
1947 "powerpc64-linux-gnu",
"powerpc64-unknown-linux-gnu",
1948 "powerpc64-suse-linux",
"ppc64-redhat-linux"};
1949 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
1950 static const char *
const PPC64LETriples[] = {
1951 "powerpc64le-linux-gnu",
"powerpc64le-unknown-linux-gnu",
1952 "powerpc64le-suse-linux",
"ppc64le-redhat-linux"};
1954 static const char *
const RISCV32LibDirs[] = {
"/lib",
"/lib32"};
1955 static const char *
const RISCVTriples[] = {
"riscv32-unknown-linux-gnu",
1956 "riscv64-unknown-linux-gnu",
1957 "riscv32-unknown-elf"};
1959 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
1960 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
1961 "sparcv8-linux-gnu"};
1962 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
1963 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
1964 "sparcv9-linux-gnu"};
1966 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
1967 static const char *
const SystemZTriples[] = {
1968 "s390x-linux-gnu",
"s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
1969 "s390x-suse-linux",
"s390x-redhat-linux"};
1975 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1976 static const char *
const SolarisLibDirs[] = {
"/lib"};
1977 static const char *
const SolarisSparcV8Triples[] = {
1978 "sparc-sun-solaris2.11",
"sparc-sun-solaris2.12"};
1979 static const char *
const SolarisSparcV9Triples[] = {
1980 "sparcv9-sun-solaris2.11",
"sparcv9-sun-solaris2.12"};
1981 static const char *
const SolarisX86Triples[] = {
"i386-pc-solaris2.11",
1982 "i386-pc-solaris2.12"};
1983 static const char *
const SolarisX86_64Triples[] = {
"x86_64-pc-solaris2.11",
1984 "x86_64-pc-solaris2.12"};
1985 LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
1986 BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
1987 switch (TargetTriple.getArch()) {
1988 case llvm::Triple::x86:
1989 TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
1990 BiarchTripleAliases.append(begin(SolarisX86_64Triples),
1991 end(SolarisX86_64Triples));
1993 case llvm::Triple::x86_64:
1994 TripleAliases.append(begin(SolarisX86_64Triples),
1995 end(SolarisX86_64Triples));
1996 BiarchTripleAliases.append(begin(SolarisX86Triples),
1997 end(SolarisX86Triples));
1999 case llvm::Triple::sparc:
2000 TripleAliases.append(begin(SolarisSparcV8Triples),
2001 end(SolarisSparcV8Triples));
2002 BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2003 end(SolarisSparcV9Triples));
2005 case llvm::Triple::sparcv9:
2006 TripleAliases.append(begin(SolarisSparcV9Triples),
2007 end(SolarisSparcV9Triples));
2008 BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2009 end(SolarisSparcV8Triples));
2018 if (TargetTriple.isAndroid()) {
2019 static const char *
const AArch64AndroidTriples[] = {
2020 "aarch64-linux-android"};
2021 static const char *
const ARMAndroidTriples[] = {
"arm-linux-androideabi"};
2022 static const char *
const MIPSELAndroidTriples[] = {
"mipsel-linux-android"};
2023 static const char *
const MIPS64ELAndroidTriples[] = {
2024 "mips64el-linux-android"};
2025 static const char *
const X86AndroidTriples[] = {
"i686-linux-android"};
2026 static const char *
const X86_64AndroidTriples[] = {
"x86_64-linux-android"};
2028 switch (TargetTriple.getArch()) {
2029 case llvm::Triple::aarch64:
2030 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2031 TripleAliases.append(begin(AArch64AndroidTriples),
2032 end(AArch64AndroidTriples));
2034 case llvm::Triple::arm:
2035 case llvm::Triple::thumb:
2036 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2037 TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2039 case llvm::Triple::mipsel:
2040 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2041 TripleAliases.append(begin(MIPSELAndroidTriples),
2042 end(MIPSELAndroidTriples));
2043 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2044 BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples),
2045 end(MIPS64ELAndroidTriples));
2047 case llvm::Triple::mips64el:
2048 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2049 TripleAliases.append(begin(MIPS64ELAndroidTriples),
2050 end(MIPS64ELAndroidTriples));
2051 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2052 BiarchTripleAliases.append(begin(MIPSELAndroidTriples),
2053 end(MIPSELAndroidTriples));
2055 case llvm::Triple::x86_64:
2056 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2057 TripleAliases.append(begin(X86_64AndroidTriples),
2058 end(X86_64AndroidTriples));
2059 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2060 BiarchTripleAliases.append(begin(X86AndroidTriples),
2061 end(X86AndroidTriples));
2063 case llvm::Triple::x86:
2064 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2065 TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
2066 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2067 BiarchTripleAliases.append(begin(X86_64AndroidTriples),
2068 end(X86_64AndroidTriples));
2077 switch (TargetTriple.getArch()) {
2078 case llvm::Triple::aarch64:
2079 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2080 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2081 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2082 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2084 case llvm::Triple::aarch64_be:
2085 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2086 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2087 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2088 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2090 case llvm::Triple::arm:
2091 case llvm::Triple::thumb:
2092 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2093 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2094 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2096 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2099 case llvm::Triple::armeb:
2100 case llvm::Triple::thumbeb:
2101 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2102 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2103 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2105 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2108 case llvm::Triple::x86_64:
2109 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2110 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2113 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
2114 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2115 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2117 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2118 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2121 case llvm::Triple::x86:
2122 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2125 if (!TargetTriple.isOSIAMCU()) {
2126 TripleAliases.append(begin(X86Triples), end(X86Triples));
2127 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2128 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2131 case llvm::Triple::mips:
2132 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2133 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2134 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2135 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2136 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2137 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2139 case llvm::Triple::mipsel:
2140 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2141 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2142 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2143 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2144 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2145 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2146 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2148 case llvm::Triple::mips64:
2149 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2150 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2151 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2152 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2153 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2154 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2156 case llvm::Triple::mips64el:
2157 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2158 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2159 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2160 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2161 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2162 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2163 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2165 case llvm::Triple::msp430:
2166 LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2167 TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2169 case llvm::Triple::ppc:
2170 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2171 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2172 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2173 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2175 case llvm::Triple::ppc64:
2176 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2177 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2178 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2179 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2181 case llvm::Triple::ppc64le:
2182 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2183 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2185 case llvm::Triple::riscv32:
2186 LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2187 BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2188 TripleAliases.append(begin(RISCVTriples), end(RISCVTriples));
2189 BiarchTripleAliases.append(begin(RISCVTriples), end(RISCVTriples));
2191 case llvm::Triple::sparc:
2192 case llvm::Triple::sparcel:
2193 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2194 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2195 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2196 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2198 case llvm::Triple::sparcv9:
2199 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2200 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2201 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2202 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2204 case llvm::Triple::systemz:
2205 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2206 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2216 TripleAliases.push_back(TargetTriple.str());
2219 if (TargetTriple.str() != BiarchTriple.str())
2220 BiarchTripleAliases.push_back(BiarchTriple.str());
2223 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2224 const llvm::Triple &TargetTriple,
const ArgList &Args,
2225 StringRef Path,
bool NeedsBiarchSuffix) {
2226 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2235 }
else if (TargetTriple.isMIPS()) {
2238 }
else if (
isRISCV(TargetArch)) {
2243 NeedsBiarchSuffix, Detected)) {
2254 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2255 const llvm::Triple &TargetTriple,
const ArgList &Args,
2256 const std::string &LibDir, StringRef CandidateTriple,
2257 bool NeedsBiarchSuffix) {
2258 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2261 struct GCCLibSuffix {
2263 std::string LibSuffix;
2266 StringRef ReversePath;
2271 {
"gcc/" + CandidateTriple.str(),
"../..",
true},
2274 {
"gcc-cross/" + CandidateTriple.str(),
"../..",
2275 TargetTriple.getOS() != llvm::Triple::Solaris},
2281 {CandidateTriple.str(),
"..",
2282 TargetTriple.getVendor() == llvm::Triple::Freescale ||
2283 TargetTriple.getVendor() == llvm::Triple::OpenEmbedded},
2288 {CandidateTriple.str() +
"/gcc/" + CandidateTriple.str(),
"../../..",
2289 TargetTriple.getOS() != llvm::Triple::Solaris},
2295 {
"i386-linux-gnu/gcc/" + CandidateTriple.str(),
"../../..",
2296 (TargetArch == llvm::Triple::x86 &&
2297 TargetTriple.getOS() != llvm::Triple::Solaris)},
2298 {
"i386-gnu/gcc/" + CandidateTriple.str(),
"../../..",
2299 (TargetArch == llvm::Triple::x86 &&
2300 TargetTriple.getOS() != llvm::Triple::Solaris)}};
2306 StringRef LibSuffix = Suffix.LibSuffix;
2308 for (llvm::vfs::directory_iterator
2309 LI = D.
getVFS().dir_begin(LibDir +
"/" + LibSuffix, EC),
2311 !EC && LI != LE; LI = LI.increment(EC)) {
2312 StringRef VersionText = llvm::sys::path::filename(LI->path());
2313 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2314 if (CandidateVersion.Major != -1)
2315 if (!CandidateGCCInstallPaths.insert(LI->path()).second)
2317 if (CandidateVersion.isOlderThan(4, 1, 1))
2319 if (CandidateVersion <= Version)
2322 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
2326 Version = CandidateVersion;
2327 GCCTriple.setTriple(CandidateTriple);
2331 GCCInstallPath = (LibDir +
"/" + LibSuffix +
"/" + VersionText).
str();
2332 GCCParentLibPath = (GCCInstallPath +
"/../" + Suffix.ReversePath).
str();
2338 bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
2339 const llvm::Triple &TargetTriple,
const ArgList &Args,
2342 for (StringRef CandidateTriple : CandidateTriples) {
2343 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
2347 for (StringRef CandidateTriple : CandidateBiarchTriples) {
2348 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple,
true))
2354 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2355 const llvm::Triple &TargetTriple,
const ArgList &Args,
2356 StringRef CandidateTriple,
bool NeedsBiarchSuffix) {
2357 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
2358 D.
getVFS().getBufferForFile(D.
SysRoot +
"/etc/env.d/gcc/config-" +
2359 CandidateTriple.str());
2362 File.get()->getBuffer().split(Lines,
"\n");
2363 for (StringRef
Line : Lines) {
2366 if (!
Line.consume_front(
"CURRENT="))
2369 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
2372 std::pair<StringRef, StringRef> ActiveVersion =
Line.rsplit(
'-');
2385 ConfigFile.get()->getBuffer().split(ConfigLines,
"\n");
2386 for (StringRef ConfLine : ConfigLines) {
2387 ConfLine = ConfLine.trim();
2388 if (ConfLine.consume_front(
"LDPATH=")) {
2390 ConfLine.consume_back(
"\"");
2391 ConfLine.consume_front(
"\"");
2393 ConfLine.split(GentooScanPaths,
':', -1,
false);
2398 std::string basePath =
"/usr/lib/gcc/" + ActiveVersion.first.str() +
"/" 2399 + ActiveVersion.second.str();
2400 GentooScanPaths.push_back(StringRef(basePath));
2403 for (
const auto &GentooScanPath : GentooScanPaths) {
2404 std::string GentooPath = D.
SysRoot + std::string(GentooScanPath);
2405 if (D.
getVFS().exists(GentooPath +
"/crtbegin.o")) {
2406 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2410 Version = GCCVersion::Parse(ActiveVersion.second);
2411 GCCInstallPath = GentooPath;
2412 GCCParentLibPath = GentooPath + std::string(
"/../../..");
2413 GCCTriple.setTriple(ActiveVersion.first);
2425 const ArgList &Args)
2426 :
ToolChain(D, Triple, Args), GCCInstallation(D),
2427 CudaInstallation(D, Triple, Args) {
2440 return Preprocess.get();
2444 return Compile.get();
2463 return getArch() == llvm::Triple::x86_64;
2468 case llvm::Triple::x86_64:
2470 case llvm::Triple::ppc64:
2473 case llvm::Triple::mips64:
2474 case llvm::Triple::mips64el:
2489 case llvm::Triple::x86:
2490 case llvm::Triple::x86_64:
2491 case llvm::Triple::aarch64:
2492 case llvm::Triple::aarch64_be:
2493 case llvm::Triple::arm:
2494 case llvm::Triple::armeb:
2495 case llvm::Triple::avr:
2496 case llvm::Triple::bpfel:
2497 case llvm::Triple::bpfeb:
2498 case llvm::Triple::thumb:
2499 case llvm::Triple::thumbeb:
2500 case llvm::Triple::ppc:
2501 case llvm::Triple::ppc64:
2502 case llvm::Triple::ppc64le:
2503 case llvm::Triple::riscv32:
2504 case llvm::Triple::riscv64:
2505 case llvm::Triple::systemz:
2506 case llvm::Triple::mips:
2507 case llvm::Triple::mipsel:
2508 case llvm::Triple::mips64:
2509 case llvm::Triple::mips64el:
2510 case llvm::Triple::msp430:
2512 case llvm::Triple::sparc:
2513 case llvm::Triple::sparcel:
2514 case llvm::Triple::sparcv9:
2524 ArgStringList &CC1Args)
const {
2525 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2526 DriverArgs.hasArg(options::OPT_nostdincxx))
2542 llvm::opt::ArgStringList &CC1Args)
const {
2545 getDriver().SysRoot +
"/usr/include/c++/v1");
2550 llvm::opt::ArgStringList &CC1Args)
const {
2557 Twine
Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2558 StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2559 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2560 if (!
getVFS().exists(Base + Suffix))
2568 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2569 getVFS().exists(Base + Suffix +
"/" + GCCTriple + IncludeSuffix)) {
2571 Base + Suffix +
"/" + GCCTriple + IncludeSuffix);
2579 Base +
"/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2581 Base +
"/" + TargetMultiarchTriple + Suffix);
2588 llvm::opt::DerivedArgList *
2597 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2602 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_shared));
2603 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_fPIC));
2607 for (
auto *A : Args) {
2612 case options::OPT_shared:
2613 case options::OPT_dynamic:
2614 case options::OPT_static:
2615 case options::OPT_fPIC:
2616 case options::OPT_fno_PIC:
2617 case options::OPT_fpic:
2618 case options::OPT_fno_pic:
2619 case options::OPT_fPIE:
2620 case options::OPT_fno_PIE:
2621 case options::OPT_fpie:
2622 case options::OPT_fno_pie:
2631 void Generic_ELF::anchor() {}
2634 ArgStringList &CC1Args,
2637 bool UseInitArrayDefault =
2638 getTriple().getArch() == llvm::Triple::aarch64 ||
2639 getTriple().getArch() == llvm::Triple::aarch64_be ||
2641 getTriple().getOSMajorVersion() >= 12) ||
2642 (
getTriple().getOS() == llvm::Triple::Linux &&
2645 getTriple().getOS() == llvm::Triple::NaCl ||
2646 (
getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2648 getTriple().getOS() == llvm::Triple::Solaris ||
2649 getTriple().getArch() == llvm::Triple::riscv32 ||
2650 getTriple().getArch() == llvm::Triple::riscv64;
2652 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2653 options::OPT_fno_use_init_array, UseInitArrayDefault))
2654 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)
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)
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 isRISCV(llvm::Triple::ArchType Arch)
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.
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.