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 <system_error> 33 using namespace clang;
36 void tools::GnuTool::anchor() {}
41 return O.getKind() != Option::InputClass &&
49 ArgStringList &CmdArgs) {
50 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
51 StringRef CPUArg(A->getValue());
52 if (CPUArg.equals_lower(
"krait"))
53 CmdArgs.push_back(
"-mcpu=cortex-a15");
54 else if(CPUArg.equals_lower(
"kryo"))
55 CmdArgs.push_back(
"-mcpu=cortex-a57");
57 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
65 const char *LinkingOutput)
const {
66 const Driver &D = getToolChain().getDriver();
67 ArgStringList CmdArgs;
69 for (
const auto &A : Args) {
78 if (isa<AssembleJobAction>(JA) &&
79 A->getOption().matches(options::OPT_g_Group))
83 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
84 A->getOption().matches(options::OPT_W_Group))
87 A->render(Args, CmdArgs);
91 RenderExtraToolArgs(JA, CmdArgs);
94 if (getToolChain().getTriple().isOSDarwin()) {
95 CmdArgs.push_back(
"-arch");
97 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
105 switch (getToolChain().getArch()) {
108 case llvm::Triple::x86:
109 case llvm::Triple::ppc:
110 CmdArgs.push_back(
"-m32");
112 case llvm::Triple::x86_64:
113 case llvm::Triple::ppc64:
114 case llvm::Triple::ppc64le:
115 CmdArgs.push_back(
"-m64");
117 case llvm::Triple::sparcel:
118 CmdArgs.push_back(
"-EL");
123 CmdArgs.push_back(
"-o");
126 assert(Output.
isNothing() &&
"Unexpected output");
127 CmdArgs.push_back(
"-fsyntax-only");
130 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
140 for (
const auto &II : Inputs) {
143 D.
Diag(clang::diag::err_drv_no_linker_llvm_support)
144 << getToolChain().getTripleString();
145 else if (II.getType() == types::TY_AST)
146 D.
Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
147 else if (II.getType() == types::TY_ModuleFile)
148 D.
Diag(diag::err_drv_no_module_support)
149 << getToolChain().getTripleString();
152 CmdArgs.push_back(
"-x");
157 CmdArgs.push_back(II.getFilename());
159 const Arg &A = II.getInputArg();
162 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
163 CmdArgs.push_back(
"-lstdc++");
168 A.render(Args, CmdArgs);
174 if (!customGCCName.empty())
175 GCCName = customGCCName.c_str();
181 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
182 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
186 const JobAction &JA, ArgStringList &CmdArgs)
const {
187 CmdArgs.push_back(
"-E");
191 ArgStringList &CmdArgs)
const {
192 const Driver &D = getToolChain().getDriver();
196 case types::TY_LLVM_IR:
197 case types::TY_LTO_IR:
198 case types::TY_LLVM_BC:
199 case types::TY_LTO_BC:
200 CmdArgs.push_back(
"-c");
204 case types::TY_Object:
205 CmdArgs.push_back(
"-c");
207 case types::TY_PP_Asm:
208 CmdArgs.push_back(
"-S");
210 case types::TY_Nothing:
211 CmdArgs.push_back(
"-fsyntax-only");
219 ArgStringList &CmdArgs)
const {
224 ArgStringList &CmdArgs) {
226 if (Args.hasArg(options::OPT_shared))
229 if (Args.hasFlag(options::OPT_fxray_instrument,
230 options::OPT_fnoxray_instrument,
false)) {
231 CmdArgs.push_back(
"-whole-archive");
233 CmdArgs.push_back(
"-no-whole-archive");
241 ArgStringList &CmdArgs) {
242 CmdArgs.push_back(
"--no-as-needed");
243 CmdArgs.push_back(
"-lpthread");
244 CmdArgs.push_back(
"-lrt");
245 CmdArgs.push_back(
"-lm");
247 if (TC.
getTriple().getOS() != llvm::Triple::FreeBSD &&
248 TC.
getTriple().getOS() != llvm::Triple::NetBSD)
249 CmdArgs.push_back(
"-ldl");
252 static const char *
getLDMOption(
const llvm::Triple &
T,
const ArgList &Args) {
253 switch (T.getArch()) {
254 case llvm::Triple::x86:
258 case llvm::Triple::aarch64:
259 return "aarch64linux";
260 case llvm::Triple::aarch64_be:
261 return "aarch64_be_linux";
262 case llvm::Triple::arm:
263 case llvm::Triple::thumb:
264 return "armelf_linux_eabi";
265 case llvm::Triple::armeb:
266 case llvm::Triple::thumbeb:
267 return "armelfb_linux_eabi";
268 case llvm::Triple::ppc:
269 return "elf32ppclinux";
270 case llvm::Triple::ppc64:
272 case llvm::Triple::ppc64le:
274 case llvm::Triple::sparc:
275 case llvm::Triple::sparcel:
276 return "elf32_sparc";
277 case llvm::Triple::sparcv9:
278 return "elf64_sparc";
279 case llvm::Triple::mips:
280 return "elf32btsmip";
281 case llvm::Triple::mipsel:
282 return "elf32ltsmip";
283 case llvm::Triple::mips64:
285 return "elf32btsmipn32";
286 return "elf64btsmip";
287 case llvm::Triple::mips64el:
289 return "elf32ltsmipn32";
290 return "elf64ltsmip";
291 case llvm::Triple::systemz:
293 case llvm::Triple::x86_64:
294 if (T.getEnvironment() == llvm::Triple::GNUX32)
295 return "elf32_x86_64";
303 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static))
306 Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
310 return A->getOption().matches(options::OPT_pie);
317 const char *LinkingOutput)
const {
322 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
324 const llvm::Triple::ArchType Arch = ToolChain.
getArch();
325 const bool isAndroid = ToolChain.
getTriple().isAndroid();
326 const bool IsIAMCU = ToolChain.
getTriple().isOSIAMCU();
327 const bool IsPIE =
getPIE(Args, ToolChain);
328 const bool HasCRTBeginEndFiles =
329 ToolChain.
getTriple().hasEnvironment() ||
330 (ToolChain.
getTriple().getVendor() != llvm::Triple::MipsTechnologies);
332 ArgStringList CmdArgs;
335 Args.ClaimAllArgs(options::OPT_g_Group);
337 Args.ClaimAllArgs(options::OPT_emit_llvm);
340 Args.ClaimAllArgs(options::OPT_w);
342 const char *Exec = Args.MakeArgString(ToolChain.
GetLinkerPath());
343 if (llvm::sys::path::stem(Exec) ==
"lld") {
344 CmdArgs.push_back(
"-flavor");
345 CmdArgs.push_back(
"old-gnu");
346 CmdArgs.push_back(
"-target");
347 CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString()));
351 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
354 CmdArgs.push_back(
"-pie");
356 if (Args.hasArg(options::OPT_rdynamic))
357 CmdArgs.push_back(
"-export-dynamic");
359 if (Args.hasArg(options::OPT_s))
360 CmdArgs.push_back(
"-s");
362 if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
367 if (Arch == llvm::Triple::aarch64 && isAndroid) {
369 if (CPU.empty() || CPU ==
"generic" || CPU ==
"cortex-a53")
370 CmdArgs.push_back(
"--fix-cortex-a53-843419");
373 for (
const auto &Opt : ToolChain.
ExtraOpts)
374 CmdArgs.push_back(Opt.c_str());
376 if (!Args.hasArg(options::OPT_static)) {
377 CmdArgs.push_back(
"--eh-frame-hdr");
381 CmdArgs.push_back(
"-m");
382 CmdArgs.push_back(LDMOption);
384 D.
Diag(diag::err_target_unknown_triple) << Triple.str();
388 if (Args.hasArg(options::OPT_static)) {
389 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
390 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
391 CmdArgs.push_back(
"-Bstatic");
393 CmdArgs.push_back(
"-static");
394 }
else if (Args.hasArg(options::OPT_shared)) {
395 CmdArgs.push_back(
"-shared");
398 if (!Args.hasArg(options::OPT_static)) {
399 if (Args.hasArg(options::OPT_rdynamic))
400 CmdArgs.push_back(
"-export-dynamic");
402 if (!Args.hasArg(options::OPT_shared)) {
403 const std::string Loader =
405 CmdArgs.push_back(
"-dynamic-linker");
406 CmdArgs.push_back(Args.MakeArgString(Loader));
410 CmdArgs.push_back(
"-o");
413 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
414 if (!isAndroid && !IsIAMCU) {
415 const char *crt1 =
nullptr;
416 if (!Args.hasArg(options::OPT_shared)) {
417 if (Args.hasArg(options::OPT_pg))
425 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crt1)));
427 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crti.o")));
431 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crt0.o")));
433 const char *crtbegin;
434 if (Args.hasArg(options::OPT_static))
435 crtbegin = isAndroid ?
"crtbegin_static.o" :
"crtbeginT.o";
436 else if (Args.hasArg(options::OPT_shared))
437 crtbegin = isAndroid ?
"crtbegin_so.o" :
"crtbeginS.o";
439 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbeginS.o";
441 crtbegin = isAndroid ?
"crtbegin_dynamic.o" :
"crtbegin.o";
443 if (HasCRTBeginEndFiles)
444 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtbegin)));
451 Args.AddAllArgs(CmdArgs, options::OPT_L);
452 Args.AddAllArgs(CmdArgs, options::OPT_u);
459 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
460 CmdArgs.push_back(
"--no-demangle");
466 getToolChain().addProfileRTLibs(Args, CmdArgs);
469 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
471 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
472 !Args.hasArg(options::OPT_static);
473 if (OnlyLibstdcxxStatic)
474 CmdArgs.push_back(
"-Bstatic");
476 if (OnlyLibstdcxxStatic)
477 CmdArgs.push_back(
"-Bdynamic");
479 CmdArgs.push_back(
"-lm");
482 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
484 if (!Args.hasArg(options::OPT_nostdlib)) {
485 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
486 if (Args.hasArg(options::OPT_static))
487 CmdArgs.push_back(
"--start-group");
489 if (NeedsSanitizerDeps)
495 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
496 Args.hasArg(options::OPT_pthreads);
509 if (WantPthread && !isAndroid)
510 CmdArgs.push_back(
"-lpthread");
512 if (Args.hasArg(options::OPT_fsplit_stack))
513 CmdArgs.push_back(
"--wrap=pthread_create");
515 CmdArgs.push_back(
"-lc");
519 CmdArgs.push_back(
"-lgloss");
521 if (Args.hasArg(options::OPT_static))
522 CmdArgs.push_back(
"--end-group");
528 CmdArgs.push_back(
"--as-needed");
529 CmdArgs.push_back(
"-lsoftfp");
530 CmdArgs.push_back(
"--no-as-needed");
534 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
536 if (Args.hasArg(options::OPT_shared))
537 crtend = isAndroid ?
"crtend_so.o" :
"crtendS.o";
539 crtend = isAndroid ?
"crtend_android.o" :
"crtendS.o";
541 crtend = isAndroid ?
"crtend_android.o" :
"crtend.o";
543 if (HasCRTBeginEndFiles)
544 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(crtend)));
546 CmdArgs.push_back(Args.MakeArgString(ToolChain.
GetFilePath(
"crtn.o")));
553 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
561 const char *LinkingOutput)
const {
562 const auto &D = getToolChain().getDriver();
566 ArgStringList CmdArgs;
568 llvm::Reloc::Model RelocationModel;
571 std::tie(RelocationModel, PICLevel, IsPIE) =
574 if (
const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
575 if (A->getOption().getID() == options::OPT_gz) {
576 CmdArgs.push_back(
"-compress-debug-sections");
578 StringRef
Value = A->getValue();
579 if (Value ==
"none") {
580 CmdArgs.push_back(
"-compress-debug-sections=none");
581 }
else if (Value ==
"zlib" || Value ==
"zlib-gnu") {
583 Args.MakeArgString(
"-compress-debug-sections=" + Twine(Value)));
585 D.Diag(diag::err_drv_unsupported_option_argument)
586 << A->getOption().getName() <<
Value;
591 switch (getToolChain().getArch()) {
596 case llvm::Triple::x86:
597 CmdArgs.push_back(
"--32");
599 case llvm::Triple::x86_64:
600 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
601 CmdArgs.push_back(
"--x32");
603 CmdArgs.push_back(
"--64");
605 case llvm::Triple::ppc: {
606 CmdArgs.push_back(
"-a32");
607 CmdArgs.push_back(
"-mppc");
612 case llvm::Triple::ppc64: {
613 CmdArgs.push_back(
"-a64");
614 CmdArgs.push_back(
"-mppc64");
619 case llvm::Triple::ppc64le: {
620 CmdArgs.push_back(
"-a64");
621 CmdArgs.push_back(
"-mppc64");
622 CmdArgs.push_back(
"-mlittle-endian");
627 case llvm::Triple::sparc:
628 case llvm::Triple::sparcel: {
629 CmdArgs.push_back(
"-32");
630 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
635 case llvm::Triple::sparcv9: {
636 CmdArgs.push_back(
"-64");
637 std::string CPU =
getCPUName(Args, getToolChain().getTriple());
642 case llvm::Triple::arm:
643 case llvm::Triple::armeb:
644 case llvm::Triple::thumb:
645 case llvm::Triple::thumbeb: {
646 const llvm::Triple &Triple2 = getToolChain().getTriple();
647 switch (Triple2.getSubArch()) {
648 case llvm::Triple::ARMSubArch_v7:
649 CmdArgs.push_back(
"-mfpu=neon");
651 case llvm::Triple::ARMSubArch_v8:
652 CmdArgs.push_back(
"-mfpu=crypto-neon-fp-armv8");
659 case arm::FloatABI::Invalid: llvm_unreachable(
"must have an ABI!");
660 case arm::FloatABI::Soft:
661 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=soft"));
663 case arm::FloatABI::SoftFP:
664 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=softfp"));
666 case arm::FloatABI::Hard:
667 CmdArgs.push_back(Args.MakeArgString(
"-mfloat-abi=hard"));
671 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
674 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
677 case llvm::Triple::aarch64:
678 case llvm::Triple::aarch64_be: {
679 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
684 case llvm::Triple::mips:
685 case llvm::Triple::mipsel:
686 case llvm::Triple::mips64:
687 case llvm::Triple::mips64el: {
693 CmdArgs.push_back(
"-march");
694 CmdArgs.push_back(CPUName.data());
696 CmdArgs.push_back(
"-mabi");
697 CmdArgs.push_back(ABIName.data());
701 if (RelocationModel == llvm::Reloc::Static)
702 CmdArgs.push_back(
"-mno-shared");
706 if (ABIName !=
"64" && !Args.hasArg(options::OPT_mno_abicalls))
707 CmdArgs.push_back(
"-call_nonpic");
709 if (getToolChain().getArch() == llvm::Triple::mips ||
710 getToolChain().getArch() == llvm::Triple::mips64)
711 CmdArgs.push_back(
"-EB");
713 CmdArgs.push_back(
"-EL");
715 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
716 if (StringRef(A->getValue()) ==
"2008")
717 CmdArgs.push_back(Args.MakeArgString(
"-mnan=2008"));
721 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
722 options::OPT_mfp64)) {
724 A->render(Args, CmdArgs);
726 Args, getToolChain().getTriple(), CPUName, ABIName,
728 CmdArgs.push_back(
"-mfpxx");
733 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
734 if (A->getOption().matches(options::OPT_mips16)) {
736 A->render(Args, CmdArgs);
739 CmdArgs.push_back(
"-no-mips16");
743 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
744 options::OPT_mno_micromips);
745 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
746 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
748 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
751 if (A->getOption().matches(options::OPT_mmsa))
752 CmdArgs.push_back(Args.MakeArgString(
"-mmsa"));
755 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
756 options::OPT_msoft_float);
758 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
759 options::OPT_msingle_float);
761 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
762 options::OPT_mno_odd_spreg);
767 case llvm::Triple::systemz: {
771 CmdArgs.push_back(Args.MakeArgString(
"-march=" + CPUName));
776 Args.AddAllArgs(CmdArgs, options::OPT_I);
777 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
779 CmdArgs.push_back(
"-o");
782 for (
const auto &II : Inputs)
783 CmdArgs.push_back(II.getFilename());
785 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
786 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
791 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
792 getToolChain().getTriple().isOSLinux())
799 class FilterNonExistent {
800 StringRef
Base, File;
804 FilterNonExistent(StringRef Base, StringRef File,
vfs::FileSystem &VFS)
805 : Base(Base), File(File), VFS(VFS) {}
806 bool operator()(
const Multilib &M) {
813 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
814 options::OPT_mfloat_abi_EQ);
818 return A->getOption().matches(options::OPT_msoft_float) ||
819 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
820 A->getValue() == StringRef(
"soft"));
826 std::vector<std::string> &Flags) {
828 Flags.push_back(std::string(
"+") + Flag);
830 Flags.push_back(std::string(
"-") + Flag);
834 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
837 static bool isMips32(llvm::Triple::ArchType Arch) {
838 return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel;
841 static bool isMips64(llvm::Triple::ArchType Arch) {
842 return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
845 static bool isMipsEL(llvm::Triple::ArchType Arch) {
846 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
850 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
851 return A && A->getOption().matches(options::OPT_mips16);
855 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
856 return A && A->getOption().matches(options::OPT_mmicromips);
860 return Multilib(commonSuffix, commonSuffix, commonSuffix);
864 FilterNonExistent &NonExistent,
871 auto MArchMicroMips =
892 .includeSuffix(
"/64")
899 .
Either(MArchMips16, MArchMicroMips, MArchDefault)
901 .
Either(SoftFloat, Nan2008, DefaultFloat)
904 .
Either(BigEndian, LittleEndian)
910 std::vector<std::string> Dirs({
"/include"});
913 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
915 Dirs.push_back(
"/../../../../mips-linux-gnu/libc/usr/include");
927 .includeSuffix(
"/64")
934 DebianMipsMultilibs =
940 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
941 if (CSMipsMultilibs.
size() < DebianMipsMultilibs.size())
942 std::iter_swap(Candidates, Candidates + 1);
945 if (Candidate == &DebianMipsMultilibs)
956 FilterNonExistent &NonExistent,
968 Multilib(
"/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
969 Multilib(
"/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
976 Multilib(
"/32/mips-r1",
"",
"/mips-r1").flag(
"+march=mips32"),
977 Multilib(
"/32/mips-r2",
"",
"/mips-r2").flag(
"+march=mips32r2"),
978 Multilib(
"/32/mips-r6",
"",
"/mips-r6").flag(
"+march=mips32r6"))
982 if (VFS.
exists(Path +
"/mips-r6"))
983 MS = &AndroidMipselMultilibs;
984 else if (VFS.
exists(Path +
"/32"))
985 MS = &AndroidMips64elMultilibs;
994 FilterNonExistent &NonExistent,
1003 .flag(
"+march=mips32r2");
1005 auto MArchMipselR2 =
makeMultilib(
"/mipsel-r2-hard-musl")
1008 .
flag(
"+march=mips32r2");
1014 return std::vector<std::string>(
1015 {
"/../sysroot" + M.
osSuffix() +
"/usr/include"});
1026 FilterNonExistent &NonExistent,
1034 .
flag(
"-mmicromips")
1035 .
flag(
"+march=mips32");
1040 .
flag(
"+mmicromips");
1045 .
flag(
"+march=mips64r2");
1053 .
flag(
"-mmicromips")
1054 .
flag(
"+march=mips32r2");
1071 MtiMipsMultilibsV1 =
1073 .
Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1085 .
Either(BigEndian, LittleEndian)
1091 std::vector<std::string> Dirs({
"/include"});
1093 Dirs.push_back(
"/../../../../sysroot/uclibc/usr/include");
1095 Dirs.push_back(
"/../../../../sysroot/usr/include");
1105 .
flag(
"-msoft-float")
1110 .
flag(
"+msoft-float")
1111 .
flag(
"-mnan=2008");
1114 .
flag(
"-msoft-float")
1119 .
flag(
"+msoft-float")
1121 .
flag(
"-mmicromips");
1124 .
flag(
"-msoft-float")
1127 auto ElHardNan =
makeMultilib(
"/mipsel-r2-hard-nan2008")
1129 .
flag(
"-msoft-float")
1132 .
flag(
"-mmicromips");
1133 auto BeHardNanUclibc =
makeMultilib(
"/mips-r2-hard-nan2008-uclibc")
1135 .
flag(
"-msoft-float")
1138 auto ElHardNanUclibc =
makeMultilib(
"/mipsel-r2-hard-nan2008-uclibc")
1140 .
flag(
"-msoft-float")
1143 auto BeHardUclibc =
makeMultilib(
"/mips-r2-hard-uclibc")
1145 .
flag(
"-msoft-float")
1148 auto ElHardUclibc =
makeMultilib(
"/mipsel-r2-hard-uclibc")
1150 .
flag(
"-msoft-float")
1153 auto ElMicroHardNan =
makeMultilib(
"/micromipsel-r2-hard-nan2008")
1155 .
flag(
"-msoft-float")
1157 .
flag(
"+mmicromips");
1158 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r2-soft")
1160 .
flag(
"+msoft-float")
1162 .
flag(
"+mmicromips");
1171 MtiMipsMultilibsV2 =
1173 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1174 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1175 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1176 .Either(O32, N32, N64)
1179 return std::vector<std::string>({
"/../../../../sysroot" +
1181 "/../usr/include"});
1183 .setFilePathsCallback([](
const Multilib &M) {
1184 return std::vector<std::string>(
1185 {
"/../../../../mips-mti-linux-gnu/lib" + M.
gccSuffix()});
1188 for (
auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1198 FilterNonExistent &NonExistent,
1214 .
Maybe(LittleEndian)
1217 return std::vector<std::string>(
1218 {
"/include",
"/../../../../sysroot/usr/include"});
1227 .
flag(
"-msoft-float")
1228 .
flag(
"-mmicromips");
1231 .
flag(
"+msoft-float")
1232 .
flag(
"-mmicromips");
1235 .
flag(
"-msoft-float")
1236 .
flag(
"-mmicromips");
1239 .
flag(
"+msoft-float")
1240 .
flag(
"-mmicromips");
1243 .
flag(
"-msoft-float")
1244 .
flag(
"+mmicromips");
1247 .
flag(
"+msoft-float")
1248 .
flag(
"+mmicromips");
1249 auto ElMicroHard =
makeMultilib(
"/micromipsel-r6-hard")
1251 .
flag(
"-msoft-float")
1252 .
flag(
"+mmicromips");
1253 auto ElMicroSoft =
makeMultilib(
"/micromipsel-r6-soft")
1255 .
flag(
"+msoft-float")
1256 .
flag(
"+mmicromips");
1267 .
Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1268 ElMicroHard, ElMicroSoft})
1269 .Either(O32, N32, N64)
1272 return std::vector<std::string>({
"/../../../../sysroot" +
1274 "/../usr/include"});
1276 .setFilePathsCallback([](
const Multilib &M) {
1277 return std::vector<std::string>(
1278 {
"/../../../../mips-img-linux-gnu/lib" + M.
gccSuffix()});
1281 for (
auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1291 const llvm::Triple &TargetTriple,
1292 StringRef Path,
const ArgList &Args,
1294 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1300 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1308 CPUName ==
"mips32r5" || CPUName ==
"p5600",
1309 "march=mips32r2", Flags);
1313 CPUName ==
"mips64r5" || CPUName ==
"octeon",
1314 "march=mips64r2", Flags);
1327 if (TargetTriple.isAndroid())
1331 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1332 TargetTriple.getOS() == llvm::Triple::Linux &&
1333 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1336 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1337 TargetTriple.getOS() == llvm::Triple::Linux &&
1338 TargetTriple.isGNUEnvironment())
1341 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1342 TargetTriple.getOS() == llvm::Triple::Linux &&
1343 TargetTriple.isGNUEnvironment())
1363 const llvm::Triple &TargetTriple,
1364 StringRef Path,
const ArgList &Args,
1367 FilterNonExistent NonExistent(Path,
"/crtbegin.o", D.
getVFS());
1369 .
flag(
"+march=armv7-a")
1372 .
flag(
"-march=armv7-a")
1375 .
flag(
"+march=armv7-a")
1378 .
flag(
"-march=armv7-a")
1382 .
Either(ThumbMultilib, ArmV7Multilib,
1383 ArmV7ThumbMultilib, DefaultMultilib)
1387 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1388 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1389 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1390 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1391 bool IsThumbMode = IsThumbArch ||
1392 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb,
false) ||
1393 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1394 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1395 (llvm::ARM::parseArchVersion(Arch) == 7 ||
1396 (IsArmArch && Arch ==
"" && IsV7SubArch));
1405 const llvm::Triple &TargetTriple,
1406 StringRef Path,
const ArgList &Args,
1407 bool NeedsBiarchSuffix,
1419 .includeSuffix(
"/64")
1425 .includeSuffix(
"/32")
1431 .includeSuffix(
"/x32")
1437 FilterNonExistent NonExistent(
1438 Path, TargetTriple.isOSIAMCU() ?
"/libgcc.a" :
"/crtbegin.o", D.
getVFS());
1443 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
1444 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1446 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1448 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1451 if (TargetTriple.isArch32Bit())
1452 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1454 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1456 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1461 else if (Want == WANT64)
1463 else if (Want == WANTX32)
1497 StringRef RHSPatchSuffix)
const {
1498 if (Major != RHSMajor)
1499 return Major < RHSMajor;
1500 if (Minor != RHSMinor)
1501 return Minor < RHSMinor;
1502 if (Patch != RHSPatch) {
1511 return Patch < RHSPatch;
1513 if (PatchSuffix != RHSPatchSuffix) {
1515 if (RHSPatchSuffix.empty())
1517 if (PatchSuffix.empty())
1521 return PatchSuffix < RHSPatchSuffix;
1533 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1534 std::pair<StringRef, StringRef> First = VersionText.split(
'.');
1535 std::pair<StringRef, StringRef> Second = First.second.split(
'.');
1537 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1,
"",
"",
""};
1538 if (First.first.getAsInteger(10, GoodVersion.
Major) || GoodVersion.
Major < 0)
1540 GoodVersion.
MajorStr = First.first.str();
1541 if (First.second.empty())
1543 if (Second.first.getAsInteger(10, GoodVersion.
Minor) || GoodVersion.
Minor < 0)
1545 GoodVersion.
MinorStr = Second.first.str();
1557 StringRef PatchText = GoodVersion.
PatchSuffix = Second.second.str();
1558 if (!PatchText.empty()) {
1559 if (
size_t EndNumber = PatchText.find_first_not_of(
"0123456789")) {
1561 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.
Patch) ||
1562 GoodVersion.
Patch < 0)
1564 GoodVersion.
PatchSuffix = PatchText.substr(EndNumber);
1572 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
1574 return A->getValue();
1575 return GCC_INSTALL_PREFIX;
1588 const llvm::Triple &TargetTriple,
const ArgList &Args,
1590 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1591 ? TargetTriple.get64BitArchVariant()
1592 : TargetTriple.get32BitArchVariant();
1598 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1599 CandidateTripleAliases, CandidateBiarchLibDirs,
1600 CandidateBiarchTripleAliases);
1607 if (GCCToolchainDir !=
"") {
1608 if (GCCToolchainDir.back() ==
'/')
1609 GCCToolchainDir = GCCToolchainDir.drop_back();
1611 Prefixes.push_back(GCCToolchainDir);
1615 Prefixes.push_back(D.
SysRoot);
1616 Prefixes.push_back(D.
SysRoot +
"/usr");
1625 Prefixes.push_back(
"/opt/rh/devtoolset-6/root/usr");
1626 Prefixes.push_back(
"/opt/rh/devtoolset-4/root/usr");
1627 Prefixes.push_back(
"/opt/rh/devtoolset-3/root/usr");
1628 Prefixes.push_back(
"/opt/rh/devtoolset-2/root/usr");
1630 Prefixes.push_back(
"/usr");
1638 if (GCCToolchainDir ==
"" || GCCToolchainDir == D.
SysRoot +
"/usr") {
1639 for (StringRef CandidateTriple : ExtraTripleAliases) {
1640 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
1643 for (StringRef CandidateTriple : CandidateTripleAliases) {
1644 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
1647 for (StringRef CandidateTriple : CandidateBiarchTripleAliases) {
1648 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple,
true))
1655 Version = GCCVersion::Parse(
"0.0.0");
1656 for (
const std::string &Prefix : Prefixes) {
1659 for (StringRef Suffix : CandidateLibDirs) {
1660 const std::string LibDir = Prefix + Suffix.str();
1663 for (StringRef Candidate : ExtraTripleAliases)
1664 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1665 for (StringRef Candidate : CandidateTripleAliases)
1666 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1668 for (StringRef Suffix : CandidateBiarchLibDirs) {
1669 const std::string LibDir = Prefix + Suffix.str();
1672 for (StringRef Candidate : CandidateBiarchTripleAliases)
1673 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1680 for (
const auto &InstallPath : CandidateGCCInstallPaths)
1681 OS <<
"Found candidate GCC installation: " << InstallPath <<
"\n";
1683 if (!GCCInstallPath.empty())
1684 OS <<
"Selected GCC installation: " << GCCInstallPath <<
"\n";
1686 for (
const auto &
Multilib : Multilibs)
1687 OS <<
"Candidate multilib: " <<
Multilib <<
"\n";
1689 if (Multilibs.size() != 0 || !SelectedMultilib.
isDefault())
1690 OS <<
"Selected multilib: " << SelectedMultilib <<
"\n";
1694 if (BiarchSibling.hasValue()) {
1695 M = BiarchSibling.getValue();
1701 void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1702 const llvm::Triple &TargetTriple,
const llvm::Triple &BiarchTriple,
1710 static const char *
const AArch64LibDirs[] = {
"/lib64",
"/lib"};
1711 static const char *
const AArch64Triples[] = {
1712 "aarch64-none-linux-gnu",
"aarch64-linux-gnu",
"aarch64-linux-android",
1713 "aarch64-redhat-linux",
"aarch64-suse-linux"};
1714 static const char *
const AArch64beLibDirs[] = {
"/lib"};
1715 static const char *
const AArch64beTriples[] = {
"aarch64_be-none-linux-gnu",
1716 "aarch64_be-linux-gnu"};
1718 static const char *
const ARMLibDirs[] = {
"/lib"};
1719 static const char *
const ARMTriples[] = {
"arm-linux-gnueabi",
1720 "arm-linux-androideabi"};
1721 static const char *
const ARMHFTriples[] = {
"arm-linux-gnueabihf",
1722 "armv7hl-redhat-linux-gnueabi",
1723 "armv6hl-suse-linux-gnueabi",
1724 "armv7hl-suse-linux-gnueabi"};
1725 static const char *
const ARMebLibDirs[] = {
"/lib"};
1726 static const char *
const ARMebTriples[] = {
"armeb-linux-gnueabi",
1727 "armeb-linux-androideabi"};
1728 static const char *
const ARMebHFTriples[] = {
1729 "armeb-linux-gnueabihf",
"armebv7hl-redhat-linux-gnueabi"};
1731 static const char *
const X86_64LibDirs[] = {
"/lib64",
"/lib"};
1732 static const char *
const X86_64Triples[] = {
1733 "x86_64-linux-gnu",
"x86_64-unknown-linux-gnu",
1734 "x86_64-pc-linux-gnu",
"x86_64-redhat-linux6E",
1735 "x86_64-redhat-linux",
"x86_64-suse-linux",
1736 "x86_64-manbo-linux-gnu",
"x86_64-linux-gnu",
1737 "x86_64-slackware-linux",
"x86_64-linux-android",
1738 "x86_64-unknown-linux"};
1739 static const char *
const X32LibDirs[] = {
"/libx32"};
1740 static const char *
const X86LibDirs[] = {
"/lib32",
"/lib"};
1741 static const char *
const X86Triples[] = {
1742 "i686-linux-gnu",
"i686-pc-linux-gnu",
"i486-linux-gnu",
1743 "i386-linux-gnu",
"i386-redhat-linux6E",
"i686-redhat-linux",
1744 "i586-redhat-linux",
"i386-redhat-linux",
"i586-suse-linux",
1745 "i486-slackware-linux",
"i686-montavista-linux",
"i686-linux-android",
1748 static const char *
const MIPSLibDirs[] = {
"/lib"};
1749 static const char *
const MIPSTriples[] = {
"mips-linux-gnu",
"mips-mti-linux",
1750 "mips-mti-linux-gnu",
1751 "mips-img-linux-gnu"};
1752 static const char *
const MIPSELLibDirs[] = {
"/lib"};
1753 static const char *
const MIPSELTriples[] = {
"mipsel-linux-gnu",
1754 "mips-img-linux-gnu"};
1756 static const char *
const MIPS64LibDirs[] = {
"/lib64",
"/lib"};
1757 static const char *
const MIPS64Triples[] = {
1758 "mips64-linux-gnu",
"mips-mti-linux-gnu",
"mips-img-linux-gnu",
1759 "mips64-linux-gnuabi64"};
1760 static const char *
const MIPS64ELLibDirs[] = {
"/lib64",
"/lib"};
1761 static const char *
const MIPS64ELTriples[] = {
1762 "mips64el-linux-gnu",
"mips-mti-linux-gnu",
"mips-img-linux-gnu",
1763 "mips64el-linux-gnuabi64"};
1765 static const char *
const MIPSELAndroidLibDirs[] = {
"/lib",
"/libr2",
1767 static const char *
const MIPSELAndroidTriples[] = {
"mipsel-linux-android"};
1768 static const char *
const MIPS64ELAndroidLibDirs[] = {
"/lib64",
"/lib",
1769 "/libr2",
"/libr6"};
1770 static const char *
const MIPS64ELAndroidTriples[] = {
1771 "mips64el-linux-android"};
1773 static const char *
const PPCLibDirs[] = {
"/lib32",
"/lib"};
1774 static const char *
const PPCTriples[] = {
1775 "powerpc-linux-gnu",
"powerpc-unknown-linux-gnu",
"powerpc-linux-gnuspe",
1776 "powerpc-suse-linux",
"powerpc-montavista-linuxspe"};
1777 static const char *
const PPC64LibDirs[] = {
"/lib64",
"/lib"};
1778 static const char *
const PPC64Triples[] = {
1779 "powerpc64-linux-gnu",
"powerpc64-unknown-linux-gnu",
1780 "powerpc64-suse-linux",
"ppc64-redhat-linux"};
1781 static const char *
const PPC64LELibDirs[] = {
"/lib64",
"/lib"};
1782 static const char *
const PPC64LETriples[] = {
1783 "powerpc64le-linux-gnu",
"powerpc64le-unknown-linux-gnu",
1784 "powerpc64le-suse-linux",
"ppc64le-redhat-linux"};
1786 static const char *
const SPARCv8LibDirs[] = {
"/lib32",
"/lib"};
1787 static const char *
const SPARCv8Triples[] = {
"sparc-linux-gnu",
1788 "sparcv8-linux-gnu"};
1789 static const char *
const SPARCv9LibDirs[] = {
"/lib64",
"/lib"};
1790 static const char *
const SPARCv9Triples[] = {
"sparc64-linux-gnu",
1791 "sparcv9-linux-gnu"};
1793 static const char *
const SystemZLibDirs[] = {
"/lib64",
"/lib"};
1794 static const char *
const SystemZTriples[] = {
1795 "s390x-linux-gnu",
"s390x-unknown-linux-gnu",
"s390x-ibm-linux-gnu",
1796 "s390x-suse-linux",
"s390x-redhat-linux"};
1799 static const char *
const SolarisSPARCLibDirs[] = {
"/gcc"};
1800 static const char *
const SolarisSPARCTriples[] = {
"sparc-sun-solaris2.11",
1801 "i386-pc-solaris2.11"};
1806 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1807 LibDirs.append(begin(SolarisSPARCLibDirs), end(SolarisSPARCLibDirs));
1808 TripleAliases.append(begin(SolarisSPARCTriples), end(SolarisSPARCTriples));
1812 switch (TargetTriple.getArch()) {
1813 case llvm::Triple::aarch64:
1814 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1815 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1816 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1817 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1819 case llvm::Triple::aarch64_be:
1820 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1821 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1822 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1823 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1825 case llvm::Triple::arm:
1826 case llvm::Triple::thumb:
1827 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
1828 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1829 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
1831 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
1834 case llvm::Triple::armeb:
1835 case llvm::Triple::thumbeb:
1836 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
1837 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1838 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
1840 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
1843 case llvm::Triple::x86_64:
1844 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1845 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1848 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
1849 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
1850 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1852 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1853 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
1856 case llvm::Triple::x86:
1857 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1860 if (!TargetTriple.isOSIAMCU()) {
1861 TripleAliases.append(begin(X86Triples), end(X86Triples));
1862 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1863 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1866 case llvm::Triple::mips:
1867 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1868 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1869 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1870 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1872 case llvm::Triple::mipsel:
1873 if (TargetTriple.isAndroid()) {
1874 LibDirs.append(begin(MIPSELAndroidLibDirs), end(MIPSELAndroidLibDirs));
1875 TripleAliases.append(begin(MIPSELAndroidTriples),
1876 end(MIPSELAndroidTriples));
1877 BiarchLibDirs.append(begin(MIPS64ELAndroidLibDirs),
1878 end(MIPS64ELAndroidLibDirs));
1879 BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples),
1880 end(MIPS64ELAndroidTriples));
1883 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1884 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1885 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1886 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1887 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1890 case llvm::Triple::mips64:
1891 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
1892 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
1893 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
1894 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1896 case llvm::Triple::mips64el:
1897 if (TargetTriple.isAndroid()) {
1898 LibDirs.append(begin(MIPS64ELAndroidLibDirs),
1899 end(MIPS64ELAndroidLibDirs));
1900 TripleAliases.append(begin(MIPS64ELAndroidTriples),
1901 end(MIPS64ELAndroidTriples));
1902 BiarchLibDirs.append(begin(MIPSELAndroidLibDirs),
1903 end(MIPSELAndroidLibDirs));
1904 BiarchTripleAliases.append(begin(MIPSELAndroidTriples),
1905 end(MIPSELAndroidTriples));
1908 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
1909 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
1910 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
1911 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
1912 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
1915 case llvm::Triple::ppc:
1916 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1917 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
1918 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1919 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1921 case llvm::Triple::ppc64:
1922 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
1923 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
1924 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
1925 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
1927 case llvm::Triple::ppc64le:
1928 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
1929 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
1931 case llvm::Triple::sparc:
1932 case llvm::Triple::sparcel:
1933 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1934 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1935 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1936 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1938 case llvm::Triple::sparcv9:
1939 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
1940 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
1941 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
1942 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
1944 case llvm::Triple::systemz:
1945 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
1946 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
1956 TripleAliases.push_back(TargetTriple.str());
1959 if (TargetTriple.str() != BiarchTriple.str())
1960 BiarchTripleAliases.push_back(BiarchTriple.str());
1963 void Generic_GCC::GCCInstallationDetector::scanLibDirForGCCTripleSolaris(
1964 const llvm::Triple &TargetArch,
const llvm::opt::ArgList &Args,
1965 const std::string &LibDir, StringRef CandidateTriple,
1966 bool NeedsBiarchSuffix) {
1972 !EC && LI != LE; LI = LI.
increment(EC)) {
1973 StringRef VersionText = llvm::sys::path::filename(LI->getName());
1974 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1976 if (CandidateVersion.Major != -1)
1977 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
1979 if (CandidateVersion.isOlderThan(4, 1, 1))
1981 if (CandidateVersion <= Version)
1985 LibDir +
"/" + VersionText.str() +
"/lib/gcc/" + CandidateTriple.str();
1991 std::error_code EEC;
1995 !EEC && LLI != LLE; LLI = LLI.
increment(EEC)) {
1997 StringRef SubVersionText = llvm::sys::path::filename(LLI->getName());
1998 GCCVersion CandidateSubVersion = GCCVersion::Parse(SubVersionText);
2000 if (CandidateSubVersion > Version)
2001 Version = CandidateSubVersion;
2004 GCCTriple.setTriple(CandidateTriple);
2006 GCCInstallPath +=
"/" + Version.Text;
2007 GCCParentLibPath = GCCInstallPath +
"/../../../../";
2013 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2014 const llvm::Triple &TargetTriple,
const ArgList &Args,
2015 StringRef Path,
bool NeedsBiarchSuffix) {
2016 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2029 NeedsBiarchSuffix, Detected)) {
2040 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2041 const llvm::Triple &TargetTriple,
const ArgList &Args,
2042 const std::string &LibDir, StringRef CandidateTriple,
2043 bool NeedsBiarchSuffix) {
2044 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2045 scanLibDirForGCCTripleSolaris(TargetTriple, Args, LibDir, CandidateTriple,
2050 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2053 struct GCCLibSuffix {
2055 std::string LibSuffix;
2058 StringRef ReversePath;
2063 {
"gcc/" + CandidateTriple.str(),
"../..",
true},
2066 {
"gcc-cross/" + CandidateTriple.str(),
"../..",
true},
2072 {CandidateTriple.str(),
"..",
2073 TargetTriple.getVendor() == llvm::Triple::Freescale},
2078 {CandidateTriple.str() +
"/gcc/" + CandidateTriple.str(),
"../../..",
true},
2084 {
"i386-linux-gnu/gcc/" + CandidateTriple.str(),
"../../..",
2085 TargetArch == llvm::Triple::x86}
2088 for (
auto &Suffix : Suffixes) {
2092 StringRef LibSuffix = Suffix.LibSuffix;
2097 !EC && LI != LE; LI = LI.
increment(EC)) {
2098 StringRef VersionText = llvm::sys::path::filename(LI->getName());
2099 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2100 if (CandidateVersion.Major != -1)
2101 if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2103 if (CandidateVersion.isOlderThan(4, 1, 1))
2105 if (CandidateVersion <= Version)
2108 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->getName(),
2112 Version = CandidateVersion;
2113 GCCTriple.setTriple(CandidateTriple);
2117 GCCInstallPath = (LibDir +
"/" + LibSuffix +
"/" + VersionText).str();
2118 GCCParentLibPath = (GCCInstallPath +
"/../" + Suffix.ReversePath).str();
2124 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2125 const llvm::Triple &TargetTriple,
const ArgList &Args,
2126 StringRef CandidateTriple,
bool NeedsBiarchSuffix) {
2127 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
2129 CandidateTriple.str());
2132 File.get()->getBuffer().split(Lines,
"\n");
2133 for (StringRef
Line : Lines) {
2136 if (
Line.consume_front(
"CURRENT=")) {
2137 const std::pair<StringRef, StringRef> ActiveVersion =
2142 const std::string GentooPath = D.
SysRoot +
"/usr/lib/gcc/" +
2143 ActiveVersion.first.str() +
"/" +
2144 ActiveVersion.second.str();
2146 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2150 Version = GCCVersion::Parse(ActiveVersion.second);
2151 GCCInstallPath = GentooPath;
2152 GCCParentLibPath = GentooPath +
"/../../..";
2153 GCCTriple.setTriple(ActiveVersion.first);
2165 const ArgList &Args)
2166 :
ToolChain(D, Triple, Args), GCCInstallation(D),
2167 CudaInstallation(D, Triple, Args) {
2180 return Preprocess.get();
2184 return Compile.get();
2203 return getArch() == llvm::Triple::x86_64;
2208 case llvm::Triple::x86_64:
2210 case llvm::Triple::ppc64:
2211 case llvm::Triple::ppc64le:
2213 case llvm::Triple::mips64:
2214 case llvm::Triple::mips64el:
2229 case llvm::Triple::x86:
2230 case llvm::Triple::x86_64:
2231 case llvm::Triple::aarch64:
2232 case llvm::Triple::aarch64_be:
2233 case llvm::Triple::arm:
2234 case llvm::Triple::armeb:
2235 case llvm::Triple::avr:
2236 case llvm::Triple::bpfel:
2237 case llvm::Triple::bpfeb:
2238 case llvm::Triple::thumb:
2239 case llvm::Triple::thumbeb:
2240 case llvm::Triple::ppc:
2241 case llvm::Triple::ppc64:
2242 case llvm::Triple::ppc64le:
2243 case llvm::Triple::systemz:
2244 case llvm::Triple::mips:
2245 case llvm::Triple::mipsel:
2247 case llvm::Triple::mips64:
2248 case llvm::Triple::mips64el:
2252 if (
getTriple().getEnvironment() == llvm::Triple::GNUABI64 ||
2262 ArgStringList &CC1Args)
const {
2263 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2264 DriverArgs.hasArg(options::OPT_nostdincxx))
2288 llvm::opt::ArgStringList &CC1Args)
const {
2295 Twine
Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2296 StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2297 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
2298 if (!
getVFS().exists(Base + Suffix))
2306 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2307 getVFS().
exists(Base + Suffix +
"/" + GCCTriple + IncludeSuffix)) {
2309 Base + Suffix +
"/" + GCCTriple + IncludeSuffix);
2317 Base +
"/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2319 Base +
"/" + TargetMultiarchTriple + Suffix);
2326 llvm::opt::DerivedArgList *
2335 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2340 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_shared));
2341 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_fPIC));
2345 for (
auto *A : Args) {
2350 case options::OPT_shared:
2351 case options::OPT_dynamic:
2352 case options::OPT_static:
2353 case options::OPT_fPIC:
2354 case options::OPT_fno_PIC:
2355 case options::OPT_fpic:
2356 case options::OPT_fno_pic:
2357 case options::OPT_fPIE:
2358 case options::OPT_fno_PIE:
2359 case options::OPT_fpie:
2360 case options::OPT_fno_pie:
2369 void Generic_ELF::anchor() {}
2372 ArgStringList &CC1Args,
2375 bool UseInitArrayDefault =
2376 getTriple().getArch() == llvm::Triple::aarch64 ||
2377 getTriple().getArch() == llvm::Triple::aarch64_be ||
2378 (
getTriple().getOS() == llvm::Triple::Linux &&
2381 getTriple().getOS() == llvm::Triple::NaCl ||
2382 (
getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2384 getTriple().getOS() == llvm::Triple::Solaris;
2386 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2387 options::OPT_fno_use_init_array, UseInitArrayDefault))
2388 CC1Args.push_back(
"-fuse-init-array");
MultilibSet & Either(const Multilib &M1, const Multilib &M2)
Add a set of mutually incompatible Multilib segments.
MultilibSet & Maybe(const Multilib &M)
Add an optional Multilib segment.
static bool getPIE(const ArgList &Args, const toolchains::Linux &ToolChain)
bool isDefault() const
Check whether the default is selected.
llvm::Optional< Multilib > BiarchSibling
On Biarch systems, this corresponds to the default multilib when targeting the non-default multilib...
static llvm::StringRef getGCCToolchainDir(const ArgList &Args)
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
static bool findMipsAndroidMultilibs(vfs::FileSystem &VFS, StringRef Path, const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
std::string DyldPrefix
Dynamic loader prefix, if present.
bool canTypeBeUserSpecified(ID Id)
canTypeBeUserSpecified - Can this type be specified on the command line (by the type name); this is u...
bool isHostOffloading(OffloadKind OKind) const
Check if this action have any offload kinds.
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
DiagnosticBuilder Diag(unsigned DiagID) const
virtual directory_iterator dir_begin(const Twine &Dir, std::error_code &EC)=0
Get a directory_iterator for Dir.
bool select(const Multilib::flags_list &Flags, Multilib &M) const
Pick the best multilib in the set,.
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
The virtual file system interface.
Multilib & flag(StringRef F)
Add a flag to the flags list Flag must be a flag accepted by the driver with its leading '-' removed...
static void linkXRayRuntimeDeps(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static Multilib makeMultilib(StringRef commonSuffix)
const std::string & includeSuffix() const
Get the include directory suffix.
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
static bool isMips64(llvm::Triple::ArchType Arch)
directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
static bool isMipsEL(llvm::Triple::ArchType Arch)
MultilibSet & setIncludeDirsCallback(IncludeDirsFunc F)
types::ID getType() const
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
static bool isMips16(const ArgList &Args)
static bool isSoftFloatABI(const ArgList &Args)
static void addMultilibFlag(bool Enabled, const char *const Flag, std::vector< std::string > &Flags)
Flag must be a flag accepted by the driver with its leading '-' removed,
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
const AnnotatedLine * Line
const FunctionProtoType * T
static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static void normalizeCPUNamesForAssembler(const ArgList &Args, ArgStringList &CmdArgs)
void push_back(const Multilib &M)
Add a completed Multilib to the set.
void addCommand(std::unique_ptr< Command > C)
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag...
static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
static bool forwardToGCC(const Option &O)
static const char * getLDMOption(const llvm::Triple &T, const ArgList &Args)
static bool findMipsImgMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
vfs::FileSystem & getVFS() const
std::string InstalledDir
The path to the installed clang directory, if any.
static bool isMips32(llvm::Triple::ArchType Arch)
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
static bool isArmOrThumbArch(llvm::Triple::ArchType Arch)
static bool findBiarchMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, bool NeedsBiarchSuffix, DetectedMultilibs &Result)
Dataflow Directional Tag Classes.
const std::string & getCCCGenericGCCName() const
Name to use when invoking gcc/g++.
std::string SysRoot
sysroot, if present
Defines the virtual file system interface vfs::FileSystem.
static bool addXRayRuntime(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs)
static bool findMipsCsMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
bool exists(const Twine &Path)
Check whether a file exists. Provided for convenience.
Compilation - A set of tasks to perform for a single driver invocation.
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const Twine &Name, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
This is a convenience method that opens a file, gets its content and then closes the file...
bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const llvm::opt::ArgList &Args, DetectedMultilibs &Result)
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
MultilibSet & FilterOut(FilterCallback F)
Filter out some subset of the Multilibs using a user defined callback.
const llvm::opt::OptTable & getOpts() const
MultilibSet Multilibs
The set of multilibs that the detected installation supports.
std::vector< std::string > flags_list
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)
Multilib SelectedMultilib
The primary multilib appropriate for the given flags.